@madarco/agentbox 0.4.1 → 0.5.0

package/dist/{chunk-NSIECUCS.js → chunk-PXUBE5KS.js}

@@ -6,11 +6,11 @@ import {
   execInBox,
   orbstackVolumePath,
   removeContainer,
+  sanitizeMnemonic,
   volumeExists
-} from "./chunk-SOMIKEN2.js";
+} from "./chunk-RFC5F5HR.js";
 
-// ../../packages/sandbox-docker/dist/chunk-NY7PB7KY.js
-import { spawnSync } from "child_process";
+// ../../packages/sandbox-docker/dist/chunk-LGNJND37.js
 import { mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from "fs/promises";
 import { homedir, tmpdir } from "os";
 import { join, relative } from "path";
@@ -20,6 +20,7 @@ import { execa as execa2 } from "execa";
 import { readdir as readdir2, stat as stat2 } from "fs/promises";
 import { join as join2 } from "path";
 import { execa as execa3 } from "execa";
+import { execa as execa4 } from "execa";
 import { mkdir as mkdir2, readdir as readdir3, rm as rm2, stat as stat3 } from "fs/promises";
 import { homedir as homedir2, platform } from "os";
 import { join as join3, resolve } from "path";
@@ -41,7 +42,7 @@ var RELAY_NETWORK_NAME = "agentbox-net";
 var RELAY_IMAGE_REF = "agentbox/relay:dev";
 var MAX_BODY_BYTES = 1024 * 1024;
 
-// ../../packages/sandbox-docker/dist/chunk-NY7PB7KY.js
+// ../../packages/sandbox-docker/dist/chunk-LGNJND37.js
 function isHostPathHookCommand(command, hostHome) {
   if (typeof command !== "string" || command.length === 0) return false;
   if (hostHome.length === 0) return false;
@@ -193,6 +194,8 @@ var DEFAULT_CLAUDE_SESSION = "claude";
 var CONTAINER_CLAUDE_DIR = "/home/vscode/.claude";
 var CONTAINER_USER = "vscode";
 var CONTAINER_WORKSPACE = "/workspace";
+var IN_BOX_SETUP_GUIDE_PATH = "/usr/local/share/agentbox/setup-guide.md";
+var SETUP_SKILL_DST = "/dst/skills/agentbox-setup/SKILL.md";
 function resolveClaudeVolume(opts) {
   if (opts.isolate) {
     return { volume: `${SHARED_CLAUDE_VOLUME}-${opts.boxId}` };
@@ -334,6 +337,28 @@ async function ensureClaudeVolume(spec, opts) {
   }
   return { created, synced: true, filteredHookCount, clearedInstallMethod, aliasedProjectKey };
 }
+async function seedSetupSkillIntoVolume(volume, image) {
+  try {
+    const { stdout } = await execa("docker", [
+      "run",
+      "--rm",
+      "--user",
+      "0",
+      "-v",
+      `${volume}:/dst`,
+      image,
+      "sh",
+      "-c",
+      // Prints SEEDED only when it actually copies, so the caller can log
+      // accurately. The whole thing is `|| true` so an already-present skill
+      // (or missing image asset) is a clean no-op, never a non-zero exit.
+      `{ [ ! -e /dst/skills/agentbox-setup ] && [ -f ${IN_BOX_SETUP_GUIDE_PATH} ] && mkdir -p /dst/skills/agentbox-setup && cp -a ${IN_BOX_SETUP_GUIDE_PATH} ${SETUP_SKILL_DST} && chown -R 1000:1000 /dst/skills/agentbox-setup && echo SEEDED; } || true`
+    ]);
+    return { seeded: stdout.includes("SEEDED") };
+  } catch {
+    return { seeded: false };
+  }
+}
 async function maybeFilterTo(src, dest, hostHome, opts = {}) {
   let parsed;
   try {
@@ -564,7 +589,6 @@ function shQuote(arg) {
 }
 async function startClaudeSession(opts) {
   const sessionName = opts.sessionName ?? DEFAULT_CLAUDE_SESSION;
-  const boxName = opts.boxName ?? opts.container.replace(/^agentbox-/, "");
   const cmd = ["claude", ...opts.claudeArgs].map(shQuote).join(" ");
   const term = process.env["TERM"] ?? "xterm-256color";
   const envFlags = ["-e", `TERM=${term}`];
@@ -586,7 +610,7 @@ async function startClaudeSession(opts) {
       "-s",
       sessionName,
       cmd,
-      ...buildClaudeStatusBarArgs(sessionName, boxName)
+      ...buildClaudeStatusBarArgs(sessionName)
     ],
     { reject: false }
   );
@@ -660,13 +684,15 @@ function buildClaudeDashboardAttachArgv(container, sessionName) {
     dash
   ];
 }
-function buildClaudeStatusBarArgs(sessionName, boxName) {
+function buildClaudeStatusBarArgs(sessionName) {
   const s = sessionName;
-  const name = boxName;
   return [
-    // Server-global (no -t): remap prefix Ctrl-b -> Ctrl+a, bind `q` to detach
-    // so Ctrl+a q matches the dashboard's quit chord. `send-prefix` makes a
-    // double Ctrl+a reach Claude as a literal Ctrl+a.
+    // Server-global (no -t): primary prefix Ctrl+a (dashboard parity), keep
+    // tmux's default Ctrl+b as a secondary prefix so users with existing
+    // muscle memory / integrations aren't broken. `q` is the same key under
+    // both prefixes (single key table) -> Ctrl+a q AND Ctrl+b q both detach.
+    // `send-prefix` / `send-prefix -2` let a double-tap of either prefix
+    // reach Claude as that literal key.
     ";",
     "set",
     "-g",
@@ -676,9 +702,6 @@ function buildClaudeStatusBarArgs(sessionName, boxName) {
     "set",
     "-g",
     "prefix2",
-    "None",
-    ";",
-    "unbind-key",
     "C-b",
     ";",
     "bind-key",
@@ -686,62 +709,23 @@ function buildClaudeStatusBarArgs(sessionName, boxName) {
     "send-prefix",
     ";",
     "bind-key",
+    "C-b",
+    "send-prefix",
+    "-2",
+    ";",
+    "bind-key",
     "q",
     "detach-client",
+    // Hide the inner tmux status bar — the wrapped-pty footer (for
+    // `agentbox claude` / `agentbox shell`) and the dashboard's own status
+    // row already show the box name + detach hint; without `status off`
+    // they double up.
     ";",
     "set",
     "-t",
     s,
-    "status-interval",
-    "60",
-    ";",
-    "set",
-    "-t",
-    s,
-    "status-justify",
-    "left",
-    ";",
-    "set",
-    "-t",
-    s,
-    "status-style",
-    "bg=colour236,fg=colour250",
-    ";",
-    "set",
-    "-t",
-    s,
-    "status-left-length",
-    "60",
-    ";",
-    "set",
-    "-t",
-    s,
-    "status-left",
-    `#[fg=colour16,bg=colour39,bold] agentbox \u25B8 ${name} #[default] `,
-    ";",
-    "set",
-    "-t",
-    s,
-    "status-right-length",
-    "30",
-    ";",
-    "set",
-    "-t",
-    s,
-    "status-right",
-    "#[fg=colour255]Control+a q#[fg=colour245]: detach ",
-    ";",
-    "set",
-    "-t",
-    s,
-    "window-status-format",
-    "",
-    ";",
-    "set",
-    "-t",
-    s,
-    "window-status-current-format",
-    ""
+    "status",
+    "off"
   ];
 }
 function buildShellArgv(container) {
@@ -751,16 +735,6 @@ function buildShellArgv(container) {
 function formatDetachNotice(ref) {
   return `Session detached. Reattach with: agentbox claude attach ${ref}`;
 }
-function attachClaudeSession(container, sessionName, reattachRef) {
-  const child = spawnSync("docker", buildClaudeAttachArgv(container, sessionName), {
-    stdio: "inherit"
-  });
-  const code = child.status ?? 0;
-  if (reattachRef && code === 0) {
-    process.stdout.write("\x1B[1A\x1B[2K\r" + formatDetachNotice(reattachRef) + "\n");
-  }
-  process.exit(code);
-}
 async function claudeSessionInfo(container, sessionName) {
   const name = sessionName ?? DEFAULT_CLAUDE_SESSION;
   const has = await execa(
@@ -1053,211 +1027,281 @@ async function isGitDir(path) {
     return false;
   }
 }
-async function createBoxWorktree(args) {
-  const log = args.onLog ?? (() => {
-  });
-  const stash = await execa2("git", ["-C", args.hostMainRepo, "stash", "create"], {
-    reject: false
-  });
-  const stashSha = stash.exitCode === 0 ? stash.stdout.trim() || null : null;
-  const untracked = await execa2(
-    "git",
-    ["-C", args.hostMainRepo, "ls-files", "--others", "--exclude-standard", "-z"],
-    { reject: false }
-  );
-  const untrackedList = untracked.exitCode === 0 && untracked.stdout.length > 0 ? untracked.stdout.split("\0").filter((s) => s.length > 0) : [];
-  const branchName = await pickFreshBranch(args.hostMainRepo, args.branchName);
-  const wadd = await execa2(
+async function pickFreshBranch(hostMainRepo, base) {
+  let candidate = base;
+  let suffix = 2;
+  while (await branchExists(hostMainRepo, candidate)) {
+    candidate = `${base}-${String(suffix++)}`;
+    if (suffix > 100) throw new GitWorktreeError(`could not find a free branch name near ${base}`);
+  }
+  return candidate;
+}
+async function branchExists(hostMainRepo, name) {
+  const result = await execa2(
     "git",
-    ["-C", args.hostMainRepo, "worktree", "add", "-b", branchName, args.worktreeDir, "HEAD"],
+    ["-C", hostMainRepo, "show-ref", "--verify", "--quiet", `refs/heads/${name}`],
     { reject: false }
   );
-  if (wadd.exitCode !== 0) {
-    throw new GitWorktreeError(
-      `git worktree add failed for ${args.hostMainRepo}: ${wadd.stderr || wadd.stdout}`
-    );
+  return result.exitCode === 0;
+}
+var GitWorktreeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GitWorktreeError";
   }
-  log(`created worktree ${args.worktreeDir} on branch ${branchName}`);
-  await execa2(
+};
+var WORKTREE_ROOT = "/home/vscode/.agentbox-worktrees";
+function fsSafeBranch(branch) {
+  return branch.replace(/[^A-Za-z0-9._-]+/g, "_");
+}
+function gitWorktreePathFor(branch) {
+  return `${WORKTREE_ROOT}/${fsSafeBranch(branch)}`;
+}
+async function collectRepoCarryOver(repo, branch, containerPath, gitWorktreePath) {
+  const stash = await execa3("git", ["-C", repo.hostMainRepo, "stash", "create"], { reject: false });
+  const stashSha = stash.exitCode === 0 ? stash.stdout.trim() || null : null;
+  const untracked = await execa3(
     "git",
-    ["-C", args.hostMainRepo, "config", "extensions.worktreeConfig", "true"],
+    ["-C", repo.hostMainRepo, "ls-files", "--others", "--exclude-standard", "-z"],
     { reject: false }
   );
-  await execa2(
-    "git",
-    ["-C", args.worktreeDir, "config", "--worktree", "commit.gpgsign", "false"],
+  const untrackedNul = untracked.exitCode === 0 ? untracked.stdout : "";
+  return {
+    repo,
+    containerPath,
+    gitWorktreePath,
+    branch,
+    stashSha,
+    untrackedNul,
+    hostSource: repo.hostMainRepo
+  };
+}
+async function dexec(container, argv, user = "vscode", cwd = "/") {
+  const r = await execa3(
+    "docker",
+    ["exec", "-w", cwd, "--user", user, container, ...argv],
     { reject: false }
   );
-  if (stashSha) {
-    const withIndex = await execa2(
-      "git",
-      ["-C", args.worktreeDir, "stash", "apply", "--index", stashSha],
+  if (r.exitCode !== 0) {
+    throw new GitWorktreeError(`${argv.join(" ")} failed: ${r.stderr || r.stdout}`);
+  }
+}
+async function chownGitBindParents(args) {
+  const log = args.onLog ?? (() => {
+  });
+  const repos = Array.from(new Set(args.hostMainRepos));
+  for (const repo of repos) {
+    const result = await execInBox(args.container, ["chown", "vscode:vscode", repo], {
+      user: "root"
+    });
+    if (result.exitCode === 0) {
+      log(`chowned ${repo} to vscode:vscode (parent of bind-mounted .git)`);
+    } else {
+      const msg = (result.stderr || result.stdout || `exit ${result.exitCode}`).trim();
+      log(`chown ${repo} failed (best-effort, ignoring): ${msg}`);
+    }
+  }
+}
+async function bindWorktrees(container, binds, onLog) {
+  const log = onLog ?? (() => {
+  });
+  const ordered = [...binds].sort(
+    (a, b) => a.kind === "root" && b.kind !== "root" ? -1 : a.kind !== "root" && b.kind === "root" ? 1 : 0
+  );
+  for (const b of ordered) {
+    await execa3(
+      "docker",
+      ["exec", "-w", "/", "--user", "root", container, "sh", "-c", `mountpoint -q ${b.containerPath} && umount ${b.containerPath} || true`],
+      { reject: false }
+    );
+    if (b.kind === "nested") {
+      await dexec(container, ["mkdir", "-p", ctParent(b.containerPath)], "root");
+      await dexec(container, ["mkdir", "-p", b.containerPath], "root");
+    }
+    await dexec(container, ["mount", "--bind", b.gitWorktreePath, b.containerPath], "root");
+    log(`bind-mounted ${b.containerPath} <- ${b.gitWorktreePath}`);
+  }
+}
+async function seedWorkspace(opts) {
+  const log = opts.onLog ?? (() => {
+  });
+  await dexec(opts.container, ["mkdir", "-p", WORKTREE_ROOT]);
+  for (const r of opts.repos) {
+    const main = r.repo.hostMainRepo;
+    const wt = r.gitWorktreePath;
+    const add = await execa3(
+      "docker",
+      [
+        "exec",
+        "--user",
+        "vscode",
+        opts.container,
+        "git",
+        "-C",
+        main,
+        "worktree",
+        "add",
+        "-b",
+        r.branch,
+        wt,
+        "HEAD"
+      ],
+      { reject: false }
+    );
+    if (add.exitCode !== 0) {
+      throw new GitWorktreeError(
+        `git worktree add ${wt} (branch ${r.branch}) failed: ${add.stderr || add.stdout}`
+      );
+    }
+    log(`worktree ${wt} on branch ${r.branch} (host main ${main})`);
+    await execa3(
+      "docker",
+      [
+        "exec",
+        "--user",
+        "vscode",
+        opts.container,
+        "git",
+        "-C",
+        main,
+        "config",
+        "extensions.worktreeConfig",
+        "true"
+      ],
       { reject: false }
     );
-    if (withIndex.exitCode !== 0) {
-      const noIndex = await execa2(
+    await execa3(
+      "docker",
+      [
+        "exec",
+        "--user",
+        "vscode",
+        opts.container,
         "git",
-        ["-C", args.worktreeDir, "stash", "apply", stashSha],
+        "-C",
+        wt,
+        "config",
+        "--worktree",
+        "commit.gpgsign",
+        "false"
+      ],
+      { reject: false }
+    );
+  }
+  await bindWorktrees(
+    opts.container,
+    opts.repos.map((r) => ({
+      kind: r.repo.kind,
+      containerPath: r.containerPath,
+      gitWorktreePath: r.gitWorktreePath
+    })),
+    log
+  );
+  for (const r of opts.repos) {
+    const ct = r.containerPath;
+    if (r.stashSha) {
+      const withIndex = await execa3(
+        "docker",
+        [
+          "exec",
+          "--user",
+          "vscode",
+          opts.container,
+          "git",
+          "-C",
+          ct,
+          "stash",
+          "apply",
+          "--index",
+          r.stashSha
+        ],
         { reject: false }
       );
-      if (noIndex.exitCode !== 0) {
-        log(
-          `warning: stash apply failed in worktree (${withIndex.stderr || withIndex.stdout || "no message"})`
+      if (withIndex.exitCode !== 0) {
+        const noIndex = await execa3(
+          "docker",
+          [
+            "exec",
+            "--user",
+            "vscode",
+            opts.container,
+            "git",
+            "-C",
+            ct,
+            "stash",
+            "apply",
+            r.stashSha
+          ],
+          { reject: false }
         );
+        if (noIndex.exitCode !== 0) {
+          log(
+            `warning: stash apply failed in ${ct} (${withIndex.stderr || withIndex.stdout || "no message"})`
+          );
+        } else {
+          log(`applied tracked changes (without index \u2014 staged state lost) in ${ct}`);
+        }
       } else {
-        log(`applied tracked changes (without index \u2014 staged state lost)`);
+        log(`applied tracked changes from host main into ${ct}`);
       }
-    } else {
-      log(`applied tracked changes from host main`);
     }
-  }
-  if (untrackedList.length > 0) {
-    const tarOut = await execa2(
-      "tar",
-      ["-C", args.hostMainRepo, "--null", "-T", "-", "-cf", "-"],
-      {
-        input: untrackedList.join("\0"),
+    if (r.untrackedNul.length > 0) {
+      const tarOut = await execa3("tar", ["-C", r.hostSource, "--null", "-T", "-", "-cf", "-"], {
+        input: r.untrackedNul.replace(/\0$/, ""),
         encoding: "buffer",
         reject: false
-      }
-    );
-    if (tarOut.exitCode === 0) {
-      const tarIn = await execa2("tar", ["-C", args.worktreeDir, "-xf", "-"], {
-        input: tarOut.stdout,
-        reject: false
       });
+      if (tarOut.exitCode !== 0) {
+        log(`warning: tar of untracked files for ${r.repo.hostMainRepo} failed: ${tarOut.stderr}`);
+        continue;
+      }
+      const tarIn = await execa3(
+        "docker",
+        ["exec", "-i", "--user", "vscode", opts.container, "tar", "-C", ct, "-xf", "-"],
+        { input: tarOut.stdout, reject: false }
+      );
       if (tarIn.exitCode !== 0) {
-        log(`warning: untracked-file copy into worktree failed: ${tarIn.stderr}`);
+        log(`warning: untracked-file copy into ${ct} failed: ${tarIn.stderr}`);
       } else {
-        log(`copied ${String(untrackedList.length)} untracked file(s) into worktree`);
+        const count = r.untrackedNul.split("\0").filter((s) => s.length > 0).length;
+        log(`copied ${String(count)} untracked file(s) into ${ct}`);
       }
-    } else {
-      log(`warning: tar of untracked files failed: ${tarOut.stderr}`);
     }
   }
-  return { branchName, stashSha, untrackedCount: untrackedList.length };
 }
-async function pickFreshBranch(hostMainRepo, base) {
-  let candidate = base;
-  let suffix = 2;
-  while (await branchExists(hostMainRepo, candidate)) {
-    candidate = `${base}-${String(suffix++)}`;
-    if (suffix > 100) throw new GitWorktreeError(`could not find a free branch name near ${base}`);
+async function seedWorkspaceFromDir(opts) {
+  const log = opts.onLog ?? (() => {
+  });
+  const tarOut = await execa3("tar", ["-C", opts.hostSource, "-cf", "-", "."], {
+    encoding: "buffer",
+    reject: false
+  });
+  if (tarOut.exitCode !== 0) {
+    throw new GitWorktreeError(`tar of ${opts.hostSource} failed: ${tarOut.stderr}`);
   }
-  return candidate;
-}
-async function branchExists(hostMainRepo, name) {
-  const result = await execa2(
-    "git",
-    ["-C", hostMainRepo, "show-ref", "--verify", "--quiet", `refs/heads/${name}`],
-    { reject: false }
+  const tarIn = await execa3(
+    "docker",
+    ["exec", "-i", "--user", "1000:1000", opts.container, "tar", "-C", "/workspace", "-xf", "-"],
+    { input: tarOut.stdout, reject: false }
   );
-  return result.exitCode === 0;
+  if (tarIn.exitCode !== 0) {
+    throw new GitWorktreeError(`tar extract into /workspace failed: ${tarIn.stderr}`);
+  }
+  log(`seeded /workspace from ${opts.hostSource}`);
 }
-async function removeBoxWorktree(args) {
-  const remove = await execa2(
+async function removeInBoxWorktree(args) {
+  const remove = await execa3(
     "git",
-    ["-C", args.hostMainRepo, "worktree", "remove", "--force", args.worktreeDir],
+    ["-C", args.hostMainRepo, "worktree", "remove", "--force", args.gitWorktreePath],
     { reject: false }
   );
   if (remove.exitCode === 0) return;
-  await execa2("rm", ["-rf", args.worktreeDir], { reject: false });
-  await execa2("git", ["-C", args.hostMainRepo, "worktree", "prune"], { reject: false });
-}
-var GitWorktreeError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "GitWorktreeError";
-  }
-};
-var DEFAULT_LOWER_DIRS = ["/host-src"];
-var BOX_USER_UID = 1e3;
-var BOX_USER_GID = 1e3;
-async function mountOverlay(container, opts = {}) {
-  const lowerDirs = opts.lowerDirs && opts.lowerDirs.length > 0 ? opts.lowerDirs : ["/host-src"];
-  const mountOpts = [
-    `lowerdir=${lowerDirs.join(":")}`,
-    "upperdir=/upper/upper",
-    "workdir=/upper/work",
-    `squash_to_uid=${String(BOX_USER_UID)}`,
-    `squash_to_gid=${String(BOX_USER_GID)}`
-  ].join(",");
-  const lines = [
-    "set -euo pipefail",
-    "mkdir -p /upper/upper /upper/work /workspace",
-    // Idempotent — if a previous attempt left a stale overlay, unmount first.
-    "mountpoint -q /workspace && fusermount3 -u /workspace || true",
-    `fuse-overlayfs -o ${mountOpts} /workspace`,
-    "mountpoint -q /workspace"
-  ];
-  for (const w of opts.nestedWorktrees ?? []) {
-    lines.push(
-      `mkdir -p ${shellQuote(w.containerPath)}`,
-      `mountpoint -q ${shellQuote(w.containerPath)} && umount ${shellQuote(w.containerPath)} || true`,
-      `mount --bind ${shellQuote(w.mountFromPath)} ${shellQuote(w.containerPath)}`,
-      `mountpoint -q ${shellQuote(w.containerPath)}`
-    );
-  }
-  const result = await execInBox(container, ["bash", "-lc", lines.join("\n")], { user: "root" });
-  if (result.exitCode !== 0) {
-    throw new OverlayError(
-      `failed to mount FUSE overlay in ${container}`,
-      result.stdout,
-      result.stderr
-    );
-  }
-  return { upperWritePath: "/upper/upper" };
+  await execa3("git", ["-C", args.hostMainRepo, "worktree", "prune"], { reject: false });
 }
-function shellQuote(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
+function ctParent(p) {
+  const i = p.lastIndexOf("/");
+  return i <= 0 ? "/" : p.slice(0, i);
 }
-async function verifyOverlay(container, lowerDirs = DEFAULT_LOWER_DIRS) {
-  const sentinel = ".agentbox-overlay-check";
-  const checks = [];
-  const ls = await execInBox(container, ["bash", "-lc", `ls -A /workspace | head -1`], {
-    user: "root"
-  });
-  checks.push({
-    name: "workspace lists lower contents",
-    ok: ls.exitCode === 0,
-    detail: ls.exitCode === 0 ? `first entry: ${ls.stdout.trim() || "(empty)"}` : ls.stderr.trim()
-  });
-  const write = await execInBox(container, ["bash", "-lc", `touch /workspace/${sentinel}`], {
-    user: "root"
-  });
-  checks.push({
-    name: "write through overlay succeeds",
-    ok: write.exitCode === 0,
-    detail: write.exitCode === 0 ? `created /workspace/${sentinel}` : write.stderr.trim()
-  });
-  const upper = await execInBox(container, ["bash", "-lc", `test -f /upper/upper/${sentinel}`], {
-    user: "root"
-  });
-  checks.push({
-    name: "write lands in /upper (cow target)",
-    ok: upper.exitCode === 0,
-    detail: upper.exitCode === 0 ? `/upper/upper/${sentinel} exists` : `expected /upper/upper/${sentinel} to exist`
-  });
-  const lowerProbe = lowerDirs.map((d) => `test ! -e ${shellQuote(d)}/${sentinel}`).join(" && ");
-  const lower = await execInBox(container, ["bash", "-lc", lowerProbe], { user: "root" });
-  checks.push({
-    name: `lower untouched (${lowerDirs.join(", ")})`,
-    ok: lower.exitCode === 0,
-    detail: lower.exitCode === 0 ? `${sentinel} absent from every lower` : `${sentinel} leaked into a lower layer`
-  });
-  await execInBox(container, ["bash", "-lc", `rm -f /workspace/${sentinel}`], { user: "root" });
-  return checks;
-}
-var OverlayError = class extends Error {
-  constructor(message, stdout, stderr) {
-    super(message);
-    this.stdout = stdout;
-    this.stderr = stderr;
-    this.name = "OverlayError";
-  }
-  stdout;
-  stderr;
-};
 var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".next",
@@ -1274,8 +1318,11 @@ var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
   ".parcel-cache"
 ]);
 var SNAPSHOTS_ROOT = join3(homedir2(), ".agentbox", "snapshots");
-function snapshotPathFor(boxId) {
-  return join3(SNAPSHOTS_ROOT, boxId);
+function snapshotPathFor(box) {
+  const mnemonic = sanitizeMnemonic(box.name);
+  const n = box.projectIndex;
+  const segment = typeof n === "number" && Number.isFinite(n) && n > 0 ? `${box.id}-${String(n)}-${mnemonic}` : `${box.id}-${mnemonic}`;
+  return join3(SNAPSHOTS_ROOT, segment);
 }
 async function findExcludedDirs(root, excluded = EXCLUDE_DIRS) {
   const matches = [];
@@ -1305,7 +1352,7 @@ async function createSnapshot(opts) {
   const excluded = opts.excluded ?? EXCLUDE_DIRS;
   await mkdir2(SNAPSHOTS_ROOT, { recursive: true });
   const cpArgs = platform() === "darwin" ? ["-cR"] : ["-R"];
-  await execa3("cp", [...cpArgs, `${source}/`, destination]);
+  await execa4("cp", [...cpArgs, `${source}/`, destination]);
   const toPrune = await findExcludedDirs(destination, excluded);
   await Promise.all(toPrune.map((p) => rm2(p, { recursive: true, force: true })));
   return { destination, prunedPaths: toPrune };
@@ -1466,6 +1513,21 @@ async function stopRelay() {
   });
   return { stopped: true, pid };
 }
+async function getRelayStatus() {
+  const pid = await readPidFile();
+  const pidAlive = pid !== null && await processAlive(pid);
+  const health = await fetchHealthz(300);
+  return {
+    running: health !== null,
+    pid,
+    pidAlive,
+    port: PORT,
+    endpoint: ENDPOINT,
+    health: health === null ? null : { boxes: health.boxes, events: health.events },
+    pidFile: PID_FILE,
+    logFile: LOG_FILE
+  };
+}
 function pingHealthz(timeoutMs) {
   return new Promise((resolveP) => {
     const req = httpRequest(
@@ -1484,6 +1546,42 @@ function pingHealthz(timeoutMs) {
     req.end();
   });
 }
+function fetchHealthz(timeoutMs) {
+  return new Promise((resolveP) => {
+    const req = httpRequest(
+      { host: "127.0.0.1", port: PORT, method: "GET", path: "/healthz", timeout: timeoutMs },
+      (res) => {
+        const status = res.statusCode ?? 0;
+        if (status < 200 || status >= 300) {
+          res.resume();
+          resolveP(null);
+          return;
+        }
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+            if (typeof parsed.ok === "boolean" && typeof parsed.boxes === "number" && typeof parsed.events === "number") {
+              resolveP({ ok: parsed.ok, boxes: parsed.boxes, events: parsed.events });
+            } else {
+              resolveP(null);
+            }
+          } catch {
+            resolveP(null);
+          }
+        });
+        res.on("error", () => resolveP(null));
+      }
+    );
+    req.on("error", () => resolveP(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolveP(null);
+    });
+    req.end();
+  });
+}
 async function readPidFile() {
   try {
     const text = await readFile2(PID_FILE, "utf8");
@@ -1507,7 +1605,7 @@ function generateRelayToken() {
 async function registerBoxWithRelay(args) {
   const worktrees = (args.worktrees ?? []).map((w) => ({
     containerPath: w.containerPath,
-    hostWorktreeDir: w.hostWorktreeDir,
+    hostMainRepo: w.hostMainRepo,
     branch: w.branch
   }));
   await adminPost("/admin/register-box", {
@@ -1516,6 +1614,7 @@ async function registerBoxWithRelay(args) {
     name: args.name,
     containerName: args.containerName,
     createdAt: args.createdAt,
+    projectIndex: args.projectIndex,
     worktrees
   });
 }
@@ -1573,6 +1672,7 @@ async function rehydrateRelayRegistry(boxes) {
         name: b.name,
         containerName: b.container,
         createdAt: b.createdAt,
+        projectIndex: b.projectIndex,
         worktrees: b.gitWorktrees
       });
     } catch {
@@ -1682,10 +1782,10 @@ async function ensureAgentboxTasksFile(container, services, opts = {}) {
   return { status: "wrote" };
 }
 async function writeFileInBox(container, path, content) {
-  const { execa: execa4 } = await import("execa");
-  const result = await execa4(
+  const { execa: execa5 } = await import("execa");
+  const result = await execa5(
     "docker",
-    ["exec", "-i", "--user", "vscode", container, "sh", "-c", `cat > ${shellQuote2(path)}`],
+    ["exec", "-i", "--user", "vscode", container, "sh", "-c", `cat > ${shellQuote(path)}`],
     { input: content, reject: false }
   );
   return {
@@ -1694,7 +1794,7 @@ async function writeFileInBox(container, path, content) {
     stderr: result.stderr ?? ""
   };
 }
-function shellQuote2(s) {
+function shellQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 
@@ -2181,19 +2281,22 @@ async function loadConfig(path) {
 }
 
 export {
+  DEFAULT_RELAY_PORT,
   RELAY_CONTAINER_NAME,
   RELAY_NETWORK_NAME,
   RELAY_IMAGE_REF,
   SHARED_CLAUDE_VOLUME,
   resolveClaudeVolume,
   ensureClaudeVolume,
+  seedSetupSkillIntoVolume,
   buildClaudeMounts,
   rebuildPluginNativeDeps,
   ClaudeSessionError,
   startClaudeSession,
+  buildClaudeAttachArgv,
   buildClaudeDashboardAttachArgv,
   buildShellArgv,
-  attachClaudeSession,
+  formatDetachNotice,
   claudeSessionInfo,
   pullClaudeExtras,
   SHARED_DOCKER_CACHE_VOLUME,
@@ -2205,17 +2308,21 @@ export {
   buildVncUrls,
   WEB_CONTAINER_PORT,
   detectGitRepos,
-  createBoxWorktree,
-  removeBoxWorktree,
-  DEFAULT_LOWER_DIRS,
-  mountOverlay,
-  verifyOverlay,
+  pickFreshBranch,
+  gitWorktreePathFor,
+  collectRepoCarryOver,
+  chownGitBindParents,
+  bindWorktrees,
+  seedWorkspace,
+  seedWorkspaceFromDir,
+  removeInBoxWorktree,
   SNAPSHOTS_ROOT,
   snapshotPathFor,
   createSnapshot,
   launchCtlDaemon,
   ensureRelay,
   stopRelay,
+  getRelayStatus,
   generateRelayToken,
   registerBoxWithRelay,
   forgetBoxFromRelay,
@@ -2236,4 +2343,4 @@ export {
   ConfigError,
   loadConfig
 };
-//# sourceMappingURL=chunk-NSIECUCS.js.map
+//# sourceMappingURL=chunk-PXUBE5KS.js.map