@madarco/agentbox 0.4.1 → 0.6.0

package/dist/index.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import {
-  createBox
-} from "./chunk-WR5FFGE5.js";
+  createBox,
+  hostBackupHasCredentials,
+  syncClaudeCredentials
+} from "./chunk-KJNZP6I3.js";
 import {
   AmbiguousBoxError,
   BoxNotFoundError,
   destroyBox,
-  getBoxEndpoints,
   getBoxHostPaths,
   inspectBox,
   listBoxes,
@@ -16,19 +17,24 @@ import {
   startBox,
   stopBox,
   unpauseBox
-} from "./chunk-FQD6ZWYW.js";
+} from "./chunk-M7I247BK.js";
 import {
   ClaudeSessionError,
+  DEFAULT_RELAY_PORT,
   SHARED_CLAUDE_VOLUME,
-  attachClaudeSession,
+  buildClaudeAttachArgv,
   buildClaudeDashboardAttachArgv,
+  buildClaudeLoginRunArgv,
   buildShellArgv,
   buildVncUrls,
   claudeSessionInfo,
+  clearRelayNotice,
   containerHex,
   ensureAgentboxTasksFile,
   ensureClaudeVolume,
   ensureRelay,
+  formatDetachNotice,
+  getRelayStatus,
   ideProfile,
   pullClaudeExtras,
   rebuildPluginNativeDeps,
@@ -36,20 +42,24 @@ import {
   renderStatusTable,
   renderTaskTable,
   resolveClaudeVolume,
+  runInteractiveClaudeLogin,
+  seedSetupSkillIntoVolume,
+  setRelayNotice,
   startClaudeSession,
-  stopRelay
-} from "./chunk-NSIECUCS.js";
+  stopRelay,
+  warmUpClaudeCredentials
+} from "./chunk-HTTKML3C.js";
 import {
   STATE_DIR,
   readState,
   resolveBoxRef
-} from "./chunk-IDR4HVIC.js";
+} from "./chunk-HPZMD5DE.js";
 import {
   agentboxHomeBytes,
-  allCheckpointVolumesBytes,
+  allCheckpointImagesBytes,
   boxResourceStats,
-  projectCheckpointVolumeBytes
-} from "./chunk-J35IH7W5.js";
+  projectCheckpointImageBytes
+} from "./chunk-BBZMA2K6.js";
 import {
   DEFAULT_BOX_IMAGE,
   DEFAULT_ENV_PATTERNS,
@@ -59,6 +69,7 @@ import {
   configPathFor,
   createCheckpoint,
   detectEngine,
+  ensureImage,
   execInBox,
   findProjectRoot,
   listCheckpoints,
@@ -71,19 +82,20 @@ import {
   refreshExport,
   removeCheckpoint,
   removeImage,
+  scanHostEnvFiles,
   setConfigValue,
   setEngineOverride,
   unsetConfigValue
-} from "./chunk-SOMIKEN2.js";
+} from "./chunk-HHMWQNLF.js";
 
 // src/index.ts
-import { Command as Command27 } from "commander";
+import { Command as Command29 } from "commander";
 
 // ../../packages/sandbox-docker/dist/index.js
 function browserSessionActive(stdout, exitCode) {
   return exitCode === 0 && !/no active sessions/i.test(stdout);
 }
-async function ensureBoxBrowser(container, timeoutMs = 8e3) {
+async function ensureBoxBrowser(container, timeoutMs = 8e3, targetUrl = "about:blank") {
   const list = await execInBox(container, ["agent-browser", "session", "list"], {
     user: "vscode",
     timeoutMs
@@ -91,7 +103,7 @@ async function ensureBoxBrowser(container, timeoutMs = 8e3) {
   if (browserSessionActive(list.stdout, list.exitCode)) {
     return { up: true, alreadyRunning: true };
   }
-  const open = await execInBox(container, ["agent-browser", "open", "--headed", "about:blank"], {
+  const open = await execInBox(container, ["agent-browser", "open", "--headed", targetUrl], {
     user: "vscode",
     timeoutMs
   });
@@ -122,10 +134,10 @@ var HELP_GROUPS = [
   },
   { title: "Inspect", commands: ["list", "status", "top"] },
   { title: "Lifecycle", commands: ["start", "stop", "destroy", "pause", "unpause"] },
-  { title: "Sync & state", commands: ["pull", "checkpoint"] },
+  { title: "Sync & state", commands: ["download", "cp", "checkpoint"] },
   {
     title: "Advanced",
-    commands: ["wait", "prune", "self-update", "config"]
+    commands: ["wait", "prune", "self-update", "config", "relay"]
   }
 ];
 function term(cmd) {
@@ -258,7 +270,7 @@ var browserCommand = new Command("browser").description(
       log3.info("box is paused; unpausing");
       await unpauseBox(box.id);
     } else if (insp.state === "stopped") {
-      log3.info("box is stopped; starting (remounting overlay)");
+      log3.info("box is stopped; starting");
       await startBox(box.id);
     } else if (insp.state === "missing") {
       throw new Error(`box ${box.name} has no container; was it destroyed?`);
@@ -298,13 +310,12 @@ var browserCommand = new Command("browser").description(
 });
 
 // src/commands/claude.ts
-import { confirm as confirm2, intro, isCancel as isCancel2, log as log5, outro, password, spinner } from "@clack/prompts";
+import { confirm as confirm2, intro, isCancel as isCancel2, log as log5, outro, spinner } from "@clack/prompts";
 import { Command as Command2 } from "commander";
 
 // src/auth.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { dirname, join } from "path";
+import { readFile } from "fs/promises";
+import { join } from "path";
 var AUTH_FILE = join(STATE_DIR, "auth.json");
 async function resolveClaudeAuth(processEnv, opts = {}) {
   const env = {};
@@ -322,9 +333,9 @@ async function resolveClaudeAuth(processEnv, opts = {}) {
   }
   return { env: {}, source: "none" };
 }
-async function readAuthFile(path = AUTH_FILE) {
+async function readAuthFile(path2 = AUTH_FILE) {
   try {
-    const raw = await readFile(path, "utf8");
+    const raw = await readFile(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const t = parsed.claudeCodeOauthToken;
@@ -336,22 +347,6 @@ async function readAuthFile(path = AUTH_FILE) {
     return {};
   }
 }
-async function writeAuthFile(next, path = AUTH_FILE) {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, JSON.stringify(next, null, 2) + "\n", { mode: 384, flag: "w" });
-}
-function hostClaudeAvailable() {
-  const r = spawnSync2("which", ["claude"], { stdio: ["ignore", "pipe", "ignore"] });
-  return r.status === 0 && (r.stdout?.toString().trim().length ?? 0) > 0;
-}
-function runHostSetupToken() {
-  const child = spawnSync2("claude", ["setup-token"], { stdio: "inherit" });
-  return { exitCode: child.status ?? -1 };
-}
-function isPlausibleOauthToken(s) {
-  const t = s.trim();
-  return t.startsWith("sk-ant-oat") && t.length >= 40;
-}
 
 // ../../packages/core/dist/index.js
 var claudeCodeLauncher = {
@@ -429,51 +424,27 @@ function resolveLimits(box, flags) {
 }
 
 // src/wizard.ts
-import { confirm, isCancel, log as log4 } from "@clack/prompts";
-import { copyFile, mkdir as mkdir2, stat } from "fs/promises";
-import { homedir } from "os";
-import { basename, join as join2 } from "path";
-import { fileURLToPath } from "url";
+import { confirm, isCancel, log as log4, multiselect } from "@clack/prompts";
+import { basename } from "path";
 var IN_BOX_SETUP_GUIDE_PATH = "/usr/local/share/agentbox/setup-guide.md";
-var HOST_SKILLS_DIR = join2(homedir(), ".claude", "skills", "agentbox-setup");
-var HOST_SKILL_FILE = join2(HOST_SKILLS_DIR, "SKILL.md");
-function bundledSkillPath() {
-  return fileURLToPath(new URL("../share/agentbox-setup/SKILL.md", import.meta.url));
-}
-async function fileExists(p) {
-  try {
-    const st = await stat(p);
-    return st.isFile();
-  } catch {
-    return false;
-  }
-}
-async function installAgentboxSetupSkill(opts = {}) {
-  const targetFile = opts.targetFile ?? HOST_SKILL_FILE;
-  const targetDir = join2(targetFile, "..");
-  if (await fileExists(targetFile)) return { installed: false, targetFile };
-  const src = opts.sourceFile ?? bundledSkillPath();
-  if (!await fileExists(src)) {
-    return { installed: false, targetFile };
-  }
-  await mkdir2(targetDir, { recursive: true, mode: 448 });
-  await copyFile(src, targetFile);
-  return { installed: true, targetFile };
-}
 function buildSetupInitialPrompt(workspace) {
   const name = basename(workspace);
-  return `The user just opened a new agentbox sandbox for "${name}" but the workspace has no agentbox.yaml yet. Please run the /agentbox-setup skill (or read ${IN_BOX_SETUP_GUIDE_PATH} if the skill is not loaded), then explore /workspace and propose an agentbox.yaml. Save the file to /workspace/agentbox.yaml. Then run \`agentbox-ctl reload\` from inside the box so the already-running supervisor applies the new config and immediately runs the declared tasks and autostarts the services (no box restart needed). When done, summarise what services and tasks you declared, and remind the user how to land the file on the host (commit through the bind-mounted .git, or "agentbox pull env" on the host).`;
+  return `The user just opened a new agentbox sandbox for "${name}" but the workspace has no agentbox.yaml yet. Please run the /agentbox-setup skill (or read ${IN_BOX_SETUP_GUIDE_PATH} if the skill is not loaded), then explore /workspace and propose an agentbox.yaml. Save the file to /workspace/agentbox.yaml. Then run \`agentbox-ctl reload\` from inside the box so the already-running supervisor applies the new config and immediately runs the declared tasks and autostarts the services (no box restart needed). When done, summarise what services and tasks you declared, and remind the user how to land the file on the host (commit through the bind-mounted .git, or "agentbox download env" on the host).`;
 }
 var WIZARD_AUTOLAUNCH_ENV = "AGENTBOX_WIZARD_AUTOLAUNCH";
+var WIZARD_ENV_FILES_ENV = "AGENTBOX_WIZARD_ENV_FILES";
+var WIZARD_ENV_SCAN_PATTERNS = DEFAULT_ENV_PATTERNS.filter((p) => p !== "agentbox.yaml");
 async function maybeRunSetupWizard(args) {
   if (process.env[WIZARD_AUTOLAUNCH_ENV] === "1") {
     if (args.command !== "claude") return { action: "proceed" };
-    if (args.checkpointRef) return { action: "proceed" };
+    const envFiles = parseEnvFilesFromEnv(process.env[WIZARD_ENV_FILES_ENV]);
+    if (args.checkpointRef) return { action: "proceed", envFilesToImport: envFiles };
     const proj2 = await findProjectRoot(args.workspace);
-    if (proj2.hasAgentboxYaml) return { action: "proceed" };
+    if (proj2.hasAgentboxYaml) return { action: "proceed", envFilesToImport: envFiles };
     return {
       action: "launch-with-prompt",
-      initialPrompt: buildSetupInitialPrompt(proj2.root)
+      initialPrompt: buildSetupInitialPrompt(proj2.root),
+      envFilesToImport: envFiles
     };
   }
   if (args.yes) return { action: "proceed" };
@@ -484,25 +455,42 @@ async function maybeRunSetupWizard(args) {
     log4.info(`starting from checkpoint "${args.checkpointRef}"; skipping agentbox.yaml setup`);
     return { action: "proceed" };
   }
+  let envFilesToImport;
+  if (!args.withEnv) {
+    const found = await scanHostEnvFiles(proj.root, WIZARD_ENV_SCAN_PATTERNS);
+    if (found.length > 0) {
+      const picked = await multiselect({
+        message: "Import host env/secret files into the box? (space to toggle, enter to confirm)",
+        options: found.map((p) => ({ value: p, label: p })),
+        initialValues: found,
+        required: false
+      });
+      if (!isCancel(picked) && Array.isArray(picked) && picked.length > 0) {
+        envFilesToImport = picked;
+      }
+    }
+  }
   const go = await confirm({
-    message: "Set up a new Agentbox environment?",
+    message: "New project detected, run setup wizard?",
     initialValue: true
   });
-  if (isCancel(go) || !go) return { action: "proceed" };
-  try {
-    const r = await installAgentboxSetupSkill();
-    if (r.installed) {
-      log4.success(`installed /agentbox-setup skill at ${r.targetFile}`);
-    }
-  } catch (err) {
-    log4.warn(`could not install /agentbox-setup skill: ${err.message}`);
-  }
-  if (args.command === "create") return { action: "switch-to-claude" };
+  if (isCancel(go) || !go) return { action: "proceed", envFilesToImport };
+  if (args.command === "create") return { action: "switch-to-claude", envFilesToImport };
   return {
     action: "launch-with-prompt",
-    initialPrompt: buildSetupInitialPrompt(proj.root)
+    initialPrompt: buildSetupInitialPrompt(proj.root),
+    envFilesToImport
   };
 }
+function serializeEnvFilesForEnv(files) {
+  if (!files || files.length === 0) return void 0;
+  return files.join("\0");
+}
+function parseEnvFilesFromEnv(raw) {
+  if (!raw) return void 0;
+  const out = raw.split("\0").filter((p) => p.length > 0);
+  return out.length > 0 ? out : void 0;
+}
 function passthroughFlags(opts) {
   const out = [];
   if (opts.workspace) out.push("--workspace", opts.workspace);
@@ -517,237 +505,1035 @@ function passthroughFlags(opts) {
   return out;
 }
 
-// src/commands/claude.ts
-function reattachRef(r) {
-  return typeof r.projectIndex === "number" ? String(r.projectIndex) : r.name;
-}
-function buildClaudeCliOverrides(opts) {
-  const box = {};
-  if (opts.hostSnapshot !== void 0) box.hostSnapshot = opts.hostSnapshot;
-  if (opts.image !== void 0) box.image = opts.image;
-  if (opts.withPlaywright === true) box.withPlaywright = true;
-  if (opts.withEnv === true) box.withEnv = true;
-  if (opts.vnc === false) box.vnc = false;
-  if (opts.isolateClaudeConfig === true) box.isolateClaudeConfig = true;
-  if (opts.sharedDockerCache === true) box.dockerCacheShared = true;
-  const claude = {};
-  if (opts.sessionName !== void 0) claude.sessionName = opts.sessionName;
-  const out = {};
-  if (Object.keys(box).length > 0) out.box = box;
-  if (Object.keys(claude).length > 0) out.claude = claude;
-  return out;
-}
-async function offerSetupToken() {
-  log5.info("first time setup: setup token for Claude Code");
-  const canRun = hostClaudeAvailable();
-  if (canRun) {
-    const yes = await confirm2({
-      message: "Run `claude setup-token` now to save a token?",
-      initialValue: true
-    });
-    if (isCancel2(yes) || !yes) {
-      log5.info("ok, continuing without a saved token; /login inside the box once and it persists in the shared volume.");
+// src/wrapped-pty/run.ts
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/pty/pty-backend.ts
+async function loadPtyBackend() {
+  try {
+    const ptyMod = await import("@homebridge/node-pty-prebuilt-multiarch");
+    const xtermMod = await import("@xterm/headless");
+    const spawn5 = ptyMod["spawn"] ?? ptyMod["default"]?.["spawn"];
+    const Terminal = xtermMod["Terminal"] ?? xtermMod["default"]?.["Terminal"];
+    if (typeof spawn5 !== "function" || typeof Terminal !== "function") {
       return null;
     }
-    const { exitCode } = runHostSetupToken();
-    if (exitCode !== 0) {
-      log5.warn(`\`claude setup-token\` exited with code ${String(exitCode)}; you can still paste a token below if you have one.`);
-    }
-  } else {
-    log5.warn(
-      "Claude Code is not installed on the host, so I cannot run `claude setup-token` for you. Run it on a machine that has Claude Code installed, then paste the token below \u2014 or skip and /login inside the box."
-    );
-  }
-  const pasted = await password({ message: "Paste OAuth token (or empty to skip):" });
-  if (isCancel2(pasted) || !pasted) {
-    log5.info("ok, continuing without a saved token; /login inside the box once and it persists in the shared volume.");
+    return {
+      ptySpawn: spawn5,
+      termCtor: Terminal
+    };
+  } catch {
     return null;
   }
-  const token = pasted.trim();
-  if (!isPlausibleOauthToken(token)) {
-    log5.warn("That doesn't look like an OAuth token (expected `sk-ant-oat\u2026`); saving anyway \u2014 verify inside the box.");
-  }
-  await writeAuthFile({ claudeCodeOauthToken: token });
-  log5.success(`saved to ${AUTH_FILE} (mode 0600)`);
-  return { env: { CLAUDE_CODE_OAUTH_TOKEN: token }, source: "auth-file" };
 }
-var claudeCommand = new Command2("claude").description("Create a sandboxed box and launch Claude Code in a detachable tmux session").option("-w, --workspace <path>", "host workspace to mount", process.cwd()).option("-n, --name <name>", "friendly box name (default: <workspace-basename>-<id>)").option("--host-snapshot", "use a frozen APFS clone of the host workspace as the overlay lower").option("--no-host-snapshot", "bind the live workspace directly (host edits leak into reads)").option(
-  "--snapshot <ref>",
-  "start from a project checkpoint (see `agentbox checkpoint`); overrides box.defaultCheckpoint"
-).option("--image <ref>", "override the box image").option("-y, --yes", "skip prompts, accept defaults (host-snapshot=on)").option(
-  "--isolate-claude-config",
-  "use a per-box ~/.claude volume instead of the shared agentbox-claude-config"
-).option("--with-playwright", "also install @playwright/cli@latest globally inside the box").option(
-  "--with-env",
-  "copy host env/config files (.env*, secrets.toml, agentbox.yaml, ...) into /workspace at create time (gitignore-bypassing)"
-).option("--no-vnc", "disable the per-box Xvnc + noVNC web client (on by default)").option(
-  "--shared-docker-cache",
-  "use the shared 'agentbox-docker-cache' volume for in-box docker images (preserved on destroy; only one box can run at a time when set)"
-).option("--session-name <name>", "tmux session name (default from config; built-in: claude)").option("--memory <size>", "memory ceiling (e.g. 512m, 2g); unset = unlimited").option("--cpus <n>", "CPU count cap (fractional ok, e.g. 1.5); unset = unlimited").option("--pids-limit <n>", "max process count (PIDs cgroup); unset = unlimited").option("--disk <size>", "best-effort writable-layer size (e.g. 10g); no-op on overlay2/macOS").argument(
-  "[claude-args...]",
-  "extra args passed to claude inside the box; place after `--`, e.g. `agentbox claude -- --model sonnet`"
-).action(async (claudeArgs, opts) => {
-  intro("agentbox claude");
-  const cfg = await loadEffectiveConfig(opts.workspace, {
-    cliOverrides: buildClaudeCliOverrides(opts)
-  });
-  const projectRoot = (await findProjectRoot(opts.workspace)).root;
-  const checkpointRef = opts.snapshot && opts.snapshot.length > 0 ? opts.snapshot : cfg.effective.box.defaultCheckpoint.length > 0 ? cfg.effective.box.defaultCheckpoint : void 0;
-  const wiz = await maybeRunSetupWizard({
-    workspace: opts.workspace,
-    yes: !!opts.yes,
-    command: "claude",
-    checkpointRef
-  });
-  let effectiveClaudeArgs = claudeArgs;
-  if (wiz.action === "launch-with-prompt" && wiz.initialPrompt) {
-    effectiveClaudeArgs = resolveAgentLauncher("claude-code").buildArgs(
-      wiz.initialPrompt,
-      claudeArgs
-    );
-  }
-  const useSnapshot = opts.hostSnapshot === false ? false : opts.hostSnapshot === true ? true : cfg.effective.box.hostSnapshot ?? true;
-  const sessionName = cfg.effective.claude.sessionName;
-  let resolved = await resolveClaudeAuth(process.env);
-  if (resolved.source === "none" && process.stdin.isTTY && !opts.yes) {
-    const next = await offerSetupToken();
-    if (next) resolved = next;
-  }
-  const s = spinner();
-  s.start("creating box");
-  let containerName = "";
-  try {
-    const withPlaywright = cfg.effective.box.withPlaywright || cfg.effective.browser.default !== "agent-browser";
-    const result = await createBox({
-      workspacePath: opts.workspace,
-      name: opts.name,
-      useSnapshot,
-      checkpointRef,
-      image: cfg.effective.box.image,
-      claudeConfig: { isolate: cfg.effective.box.isolateClaudeConfig },
-      claudeEnv: resolved.env,
-      withPlaywright,
-      withEnv: cfg.effective.box.withEnv,
-      vnc: { enabled: cfg.effective.box.vnc },
-      docker: { sharedCache: cfg.effective.box.dockerCacheShared },
-      limits: resolveLimits(cfg.effective.box, opts),
-      projectRoot,
-      onLog: (line) => s.message(clampSpinnerLine(line))
-    });
-    containerName = result.record.container;
-    s.message("checking plugin native deps");
-    const rebuild = await rebuildPluginNativeDeps(result.record.container, {
-      volume: result.record.claudeConfigVolume ?? SHARED_CLAUDE_VOLUME,
-      onProgress: (line) => s.message(clampSpinnerLine(line))
-    });
-    s.message("starting claude session");
-    await startClaudeSession({
-      container: result.record.container,
-      claudeArgs: effectiveClaudeArgs,
-      sessionName,
-      boxName: result.record.name
-    });
-    const nSuffix = typeof result.record.projectIndex === "number" ? `  \xB7  n ${String(result.record.projectIndex)}` : "";
-    s.stop(`box ${result.record.container} ready${nSuffix}`);
-    for (const f of rebuild.failed) {
-      log5.warn(`plugin install failed for ${f.dir}; claude may still load it. stderr:
-${f.stderr.trim()}`);
+
+// src/wrapped-pty/input-router.ts
+var KEY_ENTER = 13;
+var KEY_LF = 10;
+var KEY_ESC = 27;
+var KEY_CTRL_C = 3;
+var KEY_Y_LOW = 121;
+var KEY_Y_UP = 89;
+var KEY_N_LOW = 110;
+var KEY_N_UP = 78;
+function createInputRouter(opts) {
+  let active = null;
+  let disposed = false;
+  const settle = (answer, cancelled) => {
+    if (!active) return;
+    const body = {
+      id: active.ev.id,
+      answer,
+      ...cancelled ? { cancelled: true } : {}
+    };
+    const p = active;
+    active = null;
+    p.resolve(body);
+    opts.onAnswer(body);
+  };
+  const handleCapturedByte = (b) => {
+    if (!active) return;
+    if (b === KEY_Y_LOW || b === KEY_Y_UP) {
+      settle("y");
+      return;
     }
-    outro("attaching \u2014 Control+a q to detach, leaves claude running");
-    attachClaudeSession(result.record.container, sessionName, reattachRef(result.record));
-  } catch (err) {
-    s.stop("failed");
-    if (err instanceof ClaudeSessionError) {
-      log5.error(err.message);
-      if (containerName) {
-        log5.info(`The box ${containerName} is still running. Destroy it with:`);
-        log5.info(`  agentbox destroy ${containerName} -y`);
-      }
-      process.exit(1);
+    if (b === KEY_N_LOW || b === KEY_N_UP) {
+      settle("n");
+      return;
     }
-    handleLifecycleError(err);
-  }
-});
-async function startOrAttachClaude(box, claudeArgs, opts) {
-  const cfg = await loadEffectiveConfig(box.workspacePath, {
-    cliOverrides: opts.sessionName ? { claude: { sessionName: opts.sessionName } } : {}
-  });
-  const sessionName = cfg.effective.claude.sessionName;
-  const insp = await inspectBox(box.id);
-  if (insp.state === "missing") {
-    throw new Error(`box ${box.name} has no container; was it destroyed?`);
-  }
-  const existing = await claudeSessionInfo(box.container, sessionName);
-  if (existing.running) {
-    outro(`session "${sessionName}" already running \u2014 attaching (Control+a q to detach)`);
-    attachClaudeSession(box.container, sessionName, reattachRef(box));
-    return;
-  }
-  const s = spinner();
-  s.start("preparing box");
-  if (insp.state === "paused") {
-    s.message("unpausing box");
-    await unpauseBox(box.id);
-  } else if (insp.state === "stopped") {
-    s.message("starting box (remounting overlay)");
-    await startBox(box.id);
-  }
-  const syncConfig = opts.syncConfig !== false;
-  if (syncConfig) {
-    s.message("syncing ~/.claude into box volume");
-    const volume = box.claudeConfigVolume ?? SHARED_CLAUDE_VOLUME;
-    await ensureClaudeVolume(
-      { volume },
-      {
-        syncFromHost: true,
-        image: box.image,
-        hostWorkspace: box.workspacePath
+    if (b === KEY_ESC || b === KEY_CTRL_C) {
+      settle("n", true);
+      return;
+    }
+    if (b === KEY_ENTER || b === KEY_LF) {
+      const def = active.ev.defaultAnswer ?? "n";
+      settle(def);
+      return;
+    }
+  };
+  return {
+    get capturing() {
+      return active !== null;
+    },
+    feed(buf) {
+      if (disposed) return;
+      if (active) {
+        if (buf.length > 1 && buf[0] === KEY_ESC) return;
+        for (let i = 0; i < buf.length; i++) {
+          const byte = buf[i];
+          if (byte === void 0) continue;
+          if (active) {
+            handleCapturedByte(byte);
+          } else {
+            opts.onForward(buf.subarray(i));
+            return;
+          }
+        }
+        return;
+      }
+      opts.onForward(buf);
+    },
+    capture(ev) {
+      return new Promise((resolve2, reject) => {
+        if (active) {
+          settle("n", true);
+        }
+        active = { ev, resolve: resolve2, reject };
+      });
+    },
+    abort(reason) {
+      if (!active) return;
+      const p = active;
+      active = null;
+      const msg = reason === "pty-exit" ? "pty exited" : "resolved by sibling wrapper";
+      p.reject(new Error(msg));
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (active) {
+        const p = active;
+        active = null;
+        p.reject(new Error("input router disposed"));
       }
-    );
-  }
-  s.message("checking plugin native deps");
-  const rebuild = await rebuildPluginNativeDeps(box.container, {
-    volume: box.claudeConfigVolume ?? SHARED_CLAUDE_VOLUME,
-    onProgress: (line) => s.message(clampSpinnerLine(line))
-  });
-  s.message("starting claude session");
-  await startClaudeSession({
-    container: box.container,
-    claudeArgs,
-    sessionName,
-    boxName: box.name
-  });
-  s.stop(`box ${box.container} ready`);
-  for (const f of rebuild.failed) {
-    log5.warn(`plugin install failed for ${f.dir}; claude may still load it. stderr:
-${f.stderr.trim()}`);
-  }
-  outro("attaching \u2014 Control+a q to detach, leaves claude running");
-  attachClaudeSession(box.container, sessionName, reattachRef(box));
-}
-var claudeAttachCommand = new Command2("attach").description(
-  "Attach to a Claude Code tmux session in a box, starting one if none is running (auto-unpause/start)"
-).argument(
-  "[box]",
-  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
-).option("--session-name <name>", "tmux session name (default from config; built-in: claude)").option(
-  "--no-sync-config",
-  "when starting a fresh session, skip rsyncing the host's ~/.claude into the box's volume (faster)"
-).action(async function(idOrName) {
-  const opts = this.optsWithGlobals();
-  intro("agentbox claude attach");
-  try {
-    const box = await resolveBoxOrExit(idOrName);
-    await startOrAttachClaude(box, [], opts);
-  } catch (err) {
-    if (err instanceof ClaudeSessionError) {
-      log5.error(err.message);
-      process.exit(1);
     }
-    handleLifecycleError(err);
+  };
+}
+
+// src/dashboard/sidebar.ts
+function ellipsize(s, max) {
+  if (max <= 0) return "";
+  if (s.length <= max) return s;
+  if (max === 1) return "\u2026";
+  return s.slice(0, max - 1) + "\u2026";
+}
+function ellipsizeHead(s, max) {
+  if (max <= 0) return "";
+  if (s.length <= max) return s;
+  if (max === 1) return "\u2026";
+  return "\u2026" + s.slice(s.length - (max - 1));
+}
+function activityCell(b) {
+  if (b.pendingPrompt) return "\u25B2 prompt";
+  if (b.checkpointing) return "\u25C6 checkpoint";
+  if (b.state !== "running") return `[${b.state}]`;
+  switch (b.claudeActivity) {
+    case "working":
+      return "\u25CF working";
+    case "idle":
+      return "\u25CB idle";
+    case "waiting":
+      return "\u25D0 waiting";
+    default:
+      return "? unknown";
   }
-});
-var claudeStartCommand = new Command2("start").description(
+}
+var NEW_BOX_ID = "__agentbox_new__";
+var NEW_BOX_LABEL = "+ New box";
+var SIDEBAR_HEADER = "AgentBox";
+function topBorder(label, w) {
+  const lead = `\u256D\u2500\u2500\u2500 ${label} `;
+  if (lead.length >= w) return lead.slice(0, w);
+  return lead + "\u2500".repeat(w - lead.length);
+}
+function fit(s, w) {
+  if (s.length === w) return s;
+  if (s.length > w) return s.slice(0, w);
+  return s + " ".repeat(w - s.length);
+}
+function center(s, w) {
+  if (s.length >= w) return s.slice(0, w);
+  const pad = w - s.length;
+  const leftPad = Math.floor(pad / 2);
+  return " ".repeat(leftPad) + s + " ".repeat(pad - leftPad);
+}
+function projectLabel(project) {
+  if (!project) return "(no project)";
+  const parts = project.split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? project;
+}
+function stripTitleGlyph(s) {
+  const t = s.replace(/^[\s\p{S}*·]+/u, "");
+  return t.length > 0 ? t : s.trim();
+}
+function boxRow(b, marker, w) {
+  const numStr = b.index != null ? `${b.index} ` : "";
+  const status = activityCell(b);
+  const left = `${marker}${numStr}`;
+  const room = w - left.length - status.length - 1;
+  if (room <= 0) return fit(`${left}${status}`, w);
+  const middle = b.state === "running" && b.sessionTitle ? ellipsize(stripTitleGlyph(b.sessionTitle), room) : ellipsizeHead(b.name, room);
+  return fit(`${left}${middle}`, w - status.length) + status;
+}
+function sidebarLines(boxes, selectedId, w, h) {
+  const lines = [topBorder(SIDEBAR_HEADER, w), fit("", w)];
+  const rowOwner = [null, null];
+  const headerRows = [true, false];
+  const push = (line, owner, header) => {
+    lines.push(fit(line, w));
+    rowOwner.push(owner);
+    headerRows.push(header);
+  };
+  let prevProject;
+  let seenGroup = false;
+  for (const b of boxes) {
+    const marker = b.id === selectedId ? "\u25B8" : " ";
+    if (b.id === NEW_BOX_ID) {
+      push(`${marker}${NEW_BOX_LABEL}`, b.id, false);
+      continue;
+    }
+    if (!seenGroup || b.project !== prevProject) {
+      push(center(` \u2500\u2500 ${projectLabel(b.project)} \u2500\u2500 `, w), null, true);
+      prevProject = b.project;
+      seenGroup = true;
+    }
+    push(boxRow(b, marker, w), b.id, false);
+  }
+  if (boxes.length === 0) push(" (no boxes)", null, false);
+  while (lines.length < h) push("", null, false);
+  return {
+    lines: lines.slice(0, h),
+    rowOwner: rowOwner.slice(0, h),
+    headerRows: headerRows.slice(0, h)
+  };
+}
+function menuLines(boxName, w, h) {
+  const body = [
+    "",
+    `  No Claude session in ${boxName}.`,
+    "",
+    "   [c]  Start Claude here",
+    "   [s]  Open a shell",
+    "",
+    "  Ctrl+Option+\u2191/\u2193 switch \xB7 Ctrl-a then v/c/w/q (vnc/code/web/quit)"
+  ];
+  const top = Math.max(0, Math.floor((h - body.length) / 2));
+  const out = [];
+  for (let i = 0; i < h; i++) out.push(fit(body[i - top] ?? "", w));
+  return out;
+}
+function lifecycleMenuLines(boxName, state, confirmDestroy, w, h) {
+  const body = confirmDestroy ? [
+    "",
+    `  Destroy ${boxName}?`,
+    "  This removes the container and its volumes.",
+    "",
+    "   [y]  Yes, destroy",
+    "   [any other key]  Cancel"
+  ] : [
+    "",
+    `  Box ${boxName} is ${state}.`,
+    "",
+    state === "paused" ? "   [u]  Unpause" : "   [s]  Start",
+    "   [d]  Destroy",
+    "",
+    "  Ctrl+Option+\u2191/\u2193 switch \xB7 Ctrl-a then q quit"
+  ];
+  const top = Math.max(0, Math.floor((h - body.length) / 2));
+  const out = [];
+  for (let i = 0; i < h; i++) out.push(fit(body[i - top] ?? "", w));
+  return out;
+}
+function createMenuLines(where, w, h) {
+  const body = [
+    "",
+    "  Create a new box",
+    "",
+    "   [c]  Create + launch Claude",
+    "   [n]  Create only",
+    "",
+    `  in ${where}`,
+    "",
+    "  Ctrl+Option+\u2191/\u2193 switch \xB7 Ctrl-a then q quit"
+  ];
+  const top = Math.max(0, Math.floor((h - body.length) / 2));
+  const out = [];
+  for (let i = 0; i < h; i++) out.push(fit(body[i - top] ?? "", w));
+  return out;
+}
+var BAR_BG = "\x1B[48;2;48;48;48m";
+var BAR_BASE = BAR_BG + "\x1B[38;5;250m";
+var BAR_BRAND = "\x1B[48;5;39m\x1B[38;5;16m";
+var BRAND_BOLD = "\x1B[1m";
+var BRAND_NOBOLD = "\x1B[22m";
+var HINT_KEY = "\x1B[38;5;255m";
+var HINT_TXT = "\x1B[38;5;245m";
+var BAR_RESET = "\x1B[0m";
+var SWITCH_HINT = ["Control+Option+\u2191/\u2193", "switch"];
+var HINT_GROUPS = [
+  SWITCH_HINT,
+  ["Control+a c", "code"],
+  ["Control+a v", "vnc"],
+  ["Control+a w", "web"],
+  ["Control+a q", "quit"]
+];
+var COLLAPSED_HINT_GROUPS = [
+  SWITCH_HINT,
+  ["Control+a", "more"]
+];
+var ADVANCED_HINT_GROUPS = [
+  ["c", "code"],
+  ["v", "vnc"],
+  ["w", "web"],
+  ["s", "stop"],
+  ["p", "pause"],
+  ["d", "destroy"],
+  ["q", "quit"]
+];
+function statusLine(box, w, stateLabel, groups = HINT_GROUPS) {
+  const state = stateLabel ?? (box ? box.state === "running" ? box.claudeActivity ?? "unknown" : box.state : "");
+  const brandPrefix = box ? " agentbox \u25B8 " : " agentbox ";
+  const base = box ? `${box.name} (${state})` : "";
+  const coreMain = box ? `${base} ` : "";
+  const corePlain = brandPrefix + coreMain;
+  const SEP = "   \u2502   ";
+  const renderHints = (g) => ({
+    plain: g.map(([k, l]) => `${k}: ${l}`).join(SEP) + " ",
+    styled: g.map(([k, l]) => `${HINT_KEY}${k}${HINT_TXT}: ${l}`).join(`${HINT_TXT}${SEP}`) + " "
+  });
+  let hints = null;
+  for (const g of [groups, COLLAPSED_HINT_GROUPS]) {
+    const h = renderHints(g);
+    if (corePlain.length + h.plain.length + 1 <= w) {
+      hints = h;
+      break;
+    }
+  }
+  if (!hints) {
+    return BAR_BASE + BAR_BRAND + fit(corePlain, w) + BAR_RESET;
+  }
+  const room = w - corePlain.length - hints.plain.length - 1;
+  let titleSeg = "";
+  if (box?.sessionTitle && room >= 7) {
+    titleSeg = ` \u2014 ${ellipsize(box.sessionTitle, Math.min(40, room - 3))}`;
+  }
+  const leftPlain = brandPrefix + base + titleSeg + (box ? " " : "");
+  const leftStyled = BAR_BRAND + brandPrefix + BRAND_BOLD + base + titleSeg + (box ? " " : "") + BRAND_NOBOLD;
+  const gap = w - leftPlain.length - hints.plain.length;
+  return BAR_BASE + leftStyled + BAR_BASE + " ".repeat(gap) + hints.styled + BAR_RESET;
+}
+
+// src/wrapped-pty/footer.ts
+var SPINNER_FRAMES = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
+var URGENT = "\x1B[38;5;220m\x1B[1m";
+var TXT = "\x1B[38;5;250m";
+var SUBTLE = "\x1B[38;5;245m";
+var RESET = "\x1B[0m";
+var NOTICE_BG = "\x1B[48;5;220m";
+var NOTICE_FG = "\x1B[38;5;16m\x1B[1m";
+var CLAUDE_IDLE_HINTS = [
+  ["Control+a q", "detach"]
+];
+var SHELL_IDLE_HINTS = [];
+function padTo(visible, width) {
+  if (visible.length === width) return visible;
+  if (visible.length > width) {
+    if (width <= 1) return visible.slice(0, width);
+    return visible.slice(0, width - 1) + "\u2026";
+  }
+  return visible + " ".repeat(width - visible.length);
+}
+function renderFooter(state, cols) {
+  if (cols <= 0) return "";
+  if (state.kind === "idle") {
+    const sidebarBox = {
+      id: "",
+      // unused by statusLine
+      name: state.boxName,
+      state: "running",
+      // we're attached, so the container is up
+      claudeActivity: state.claudeActivity,
+      sessionTitle: state.sessionTitle
+    };
+    const hints = state.mode === "claude" ? CLAUDE_IDLE_HINTS : SHELL_IDLE_HINTS;
+    const stateLabel = state.mode === "shell" ? "shell" : void 0;
+    return statusLine(sidebarBox, cols, stateLabel, hints);
+  }
+  if (state.kind === "notice") {
+    const spinner5 = SPINNER_FRAMES[state.frame % SPINNER_FRAMES.length];
+    const prefix = ` ${spinner5} `;
+    const inner2 = Math.max(0, cols - prefix.length);
+    const message2 = padTo(state.message, inner2);
+    return `${NOTICE_BG}${NOTICE_FG}${prefix}${message2}${RESET}`;
+  }
+  const def = state.prompt.defaultAnswer ?? "n";
+  const yn = def === "y" ? "[Y/n]" : "[y/N]";
+  const tag2 = " [!] ";
+  const sep = "  ";
+  const hintW = ` ${yn} `.length;
+  const inner = Math.max(0, cols - tag2.length - hintW);
+  const detailRaw = state.prompt.detail ?? "";
+  let message = state.prompt.message;
+  let detail = detailRaw;
+  const messageBudget = Math.max(8, inner - (detail.length > 0 ? sep.length + 8 : 0));
+  if (message.length > messageBudget) {
+    message = message.slice(0, Math.max(0, messageBudget - 1)) + "\u2026";
+  }
+  const usedByMessage = message.length;
+  const detailBudget = Math.max(0, inner - usedByMessage - sep.length);
+  if (detail.length > detailBudget) {
+    detail = detailBudget <= 1 ? "" : detail.slice(0, detailBudget - 1) + "\u2026";
+  }
+  const middlePlain = detail.length > 0 ? `${message}${sep}${detail}` : message;
+  const padded = padTo(middlePlain, inner);
+  return `${BAR_BG}${URGENT}${tag2}${TXT}${padded}${SUBTLE} ${yn} ${RESET}`;
+}
+function cursorMoveTo(row2, col) {
+  return `\x1B[${String(row2)};${String(col)}H`;
+}
+var CURSOR_SAVE = "\x1B7";
+var CURSOR_RESTORE = "\x1B8";
+var SYNC_BEGIN = "\x1B[?2026h";
+var SYNC_END = "\x1B[?2026l";
+
+// src/wrapped-pty/prompt-client.ts
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+var INITIAL_BACKOFF_MS = 200;
+var MAX_BACKOFF_MS = 5e3;
+function subscribePrompts(opts) {
+  let closed = false;
+  let req = null;
+  let res = null;
+  let reconnectTimer = null;
+  let backoffMs = INITIAL_BACKOFF_MS;
+  let url;
+  try {
+    url = new URL(opts.relayBaseUrl);
+  } catch (err) {
+    if (opts.onError) opts.onError(err instanceof Error ? err : new Error(String(err)));
+    return { close: () => {
+    } };
+  }
+  const isHttps = url.protocol === "https:";
+  const transport = isHttps ? httpsRequest : httpRequest;
+  const port = url.port.length > 0 ? Number.parseInt(url.port, 10) : isHttps ? 443 : 80;
+  function scheduleReconnect() {
+    if (closed) return;
+    const delay = backoffMs;
+    backoffMs = Math.min(MAX_BACKOFF_MS, backoffMs * 2);
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      connect();
+    }, delay);
+    if (typeof reconnectTimer.unref === "function") reconnectTimer.unref();
+  }
+  let buffer = "";
+  function consumeMessages() {
+    let idx = buffer.indexOf("\n\n");
+    while (idx !== -1) {
+      const raw = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 2);
+      idx = buffer.indexOf("\n\n");
+      if (raw.startsWith(":")) continue;
+      let event = "";
+      let dataLine = "";
+      for (const line of raw.split("\n")) {
+        if (line.startsWith("event:")) event = line.slice("event:".length).trim();
+        else if (line.startsWith("data:")) dataLine = line.slice("data:".length).trim();
+      }
+      if (event === "prompt-ask" && dataLine.length > 0) {
+        try {
+          const ev = JSON.parse(dataLine);
+          if (ev && typeof ev.id === "string") opts.onPrompt(ev);
+        } catch {
+        }
+      } else if (event === "prompt-resolved" && dataLine.length > 0) {
+        try {
+          const payload = JSON.parse(dataLine);
+          if (payload && typeof payload.id === "string") opts.onResolved(payload.id);
+        } catch {
+        }
+      } else if (event === "notice-set" && dataLine.length > 0) {
+        try {
+          const ev = JSON.parse(dataLine);
+          if (ev && typeof ev.id === "string") opts.onNotice?.(ev);
+        } catch {
+        }
+      } else if (event === "notice-clear" && dataLine.length > 0) {
+        try {
+          const payload = JSON.parse(dataLine);
+          if (payload && typeof payload.id === "string") opts.onNoticeCleared?.(payload.id);
+        } catch {
+        }
+      }
+    }
+  }
+  function connect() {
+    if (closed) return;
+    req = transport({
+      host: url.hostname,
+      port,
+      method: "GET",
+      path: `${url.pathname.replace(/\/$/, "")}/admin/prompts/stream?boxId=${encodeURIComponent(opts.boxId)}`,
+      headers: { Accept: "text/event-stream" }
+    });
+    req.on("response", (r) => {
+      res = r;
+      if (r.statusCode !== 200) {
+        if (opts.onError) opts.onError(new Error(`SSE stream returned ${String(r.statusCode)}`));
+        r.resume();
+        close();
+        return;
+      }
+      backoffMs = INITIAL_BACKOFF_MS;
+      r.setEncoding("utf8");
+      r.on("data", (chunk) => {
+        buffer += chunk;
+        consumeMessages();
+      });
+      r.on("end", () => {
+        if (!closed) scheduleReconnect();
+      });
+      r.on("error", () => {
+        if (!closed) scheduleReconnect();
+      });
+    });
+    req.on("error", () => {
+      if (!closed) scheduleReconnect();
+    });
+    req.end();
+  }
+  function close() {
+    if (closed) return;
+    closed = true;
+    if (reconnectTimer) clearTimeout(reconnectTimer);
+    try {
+      res?.destroy();
+    } catch {
+    }
+    try {
+      req?.destroy();
+    } catch {
+    }
+  }
+  connect();
+  return { close };
+}
+function postAnswer(opts) {
+  return new Promise((resolve2) => {
+    let url;
+    try {
+      url = new URL(opts.relayBaseUrl);
+    } catch {
+      resolve2({ ok: false, status: 0 });
+      return;
+    }
+    const isHttps = url.protocol === "https:";
+    const transport = isHttps ? httpsRequest : httpRequest;
+    const port = url.port.length > 0 ? Number.parseInt(url.port, 10) : isHttps ? 443 : 80;
+    const json = JSON.stringify(opts.body);
+    const req = transport(
+      {
+        host: url.hostname,
+        port,
+        method: "POST",
+        path: `${url.pathname.replace(/\/$/, "")}/admin/prompts/answer`,
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(json).toString()
+        },
+        timeout: 3e3
+      },
+      (res) => {
+        res.resume();
+        const status = res.statusCode ?? 0;
+        resolve2({ ok: status === 204 || status === 404, status });
+      }
+    );
+    req.on("error", () => resolve2({ ok: false, status: 0 }));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve2({ ok: false, status: 0 });
+    });
+    req.write(json);
+    req.end();
+  });
+}
+
+// src/wrapped-pty/run.ts
+var FOOTER_ROWS = 1;
+var STATUS_POLL_INTERVAL_MS = 3e3;
+var SPINNER_INTERVAL_MS = 120;
+async function runWrappedAttach(opts) {
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    return runFallback(opts.dockerArgv);
+  }
+  const backend = await loadPtyBackend();
+  if (!backend) {
+    process.stderr.write(
+      "agentbox: permission prompts disabled (node-pty backend unavailable)\n"
+    );
+    return runFallback(opts.dockerArgv);
+  }
+  const cols = process.stdout.columns ?? 80;
+  const rows = process.stdout.rows ?? 24;
+  const innerRows = Math.max(1, rows - FOOTER_ROWS);
+  const pty = backend.ptySpawn("docker", opts.dockerArgv, {
+    name: "xterm-256color",
+    cols,
+    rows: innerRows,
+    env: process.env
+  });
+  const buildIdle = (sessionTitle, claudeActivity) => ({
+    kind: "idle",
+    boxName: opts.boxName,
+    sessionTitle,
+    claudeActivity,
+    mode: opts.mode
+  });
+  let footerState = buildIdle();
+  let lastSessionTitle;
+  let lastActivity;
+  let capturingPrompt = null;
+  let activeNotice = null;
+  let noticeFrame = 0;
+  let spinnerTimer = null;
+  const redrawFooter = () => {
+    const cs = process.stdout.columns ?? cols;
+    const rs = process.stdout.rows ?? rows;
+    const line = renderFooter(footerState, cs);
+    const payload = SYNC_BEGIN + CURSOR_SAVE + cursorMoveTo(rs, 1) + line + CURSOR_RESTORE + SYNC_END;
+    process.stdout.write(payload);
+  };
+  const recomputeFooter = () => {
+    if (capturingPrompt) {
+      footerState = { kind: "prompt", prompt: capturingPrompt };
+    } else if (activeNotice) {
+      footerState = { kind: "notice", message: activeNotice.message, frame: noticeFrame };
+    } else {
+      footerState = buildIdle(lastSessionTitle, lastActivity);
+    }
+  };
+  const startSpinner = () => {
+    if (spinnerTimer) return;
+    spinnerTimer = setInterval(() => {
+      noticeFrame++;
+      if (footerState.kind === "notice") {
+        recomputeFooter();
+        redrawFooter();
+      }
+    }, SPINNER_INTERVAL_MS);
+    if (typeof spinnerTimer.unref === "function") spinnerTimer.unref();
+  };
+  const stopSpinner = () => {
+    if (spinnerTimer) {
+      clearInterval(spinnerTimer);
+      spinnerTimer = null;
+    }
+  };
+  pty.onData((d) => {
+    process.stdout.write(d);
+    redrawFooter();
+  });
+  const router = createInputRouter({
+    onForward: (b) => {
+      pty.write(b.toString("utf8"));
+    },
+    onAnswer: (body) => {
+      void postAnswer({ relayBaseUrl: opts.relayBaseUrl, body });
+      capturingPrompt = null;
+      recomputeFooter();
+      redrawFooter();
+    }
+  });
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
+  process.stdin.resume();
+  const onStdinData = (chunk) => {
+    router.feed(chunk);
+  };
+  process.stdin.on("data", onStdinData);
+  const onResize = () => {
+    const cs = process.stdout.columns ?? cols;
+    const rs = process.stdout.rows ?? rows;
+    const inner = Math.max(1, rs - FOOTER_ROWS);
+    pty.resize(cs, inner);
+    process.stdout.write(`\x1B[1;${String(inner)}r`);
+    redrawFooter();
+  };
+  process.stdout.on("resize", onResize);
+  const stream = subscribePrompts({
+    relayBaseUrl: opts.relayBaseUrl,
+    boxId: opts.boxId,
+    onPrompt: (ev) => {
+      capturingPrompt = ev;
+      recomputeFooter();
+      redrawFooter();
+      router.capture(ev).catch(() => {
+      });
+    },
+    onResolved: (id) => {
+      if (capturingPrompt && capturingPrompt.id === id) {
+        capturingPrompt = null;
+        router.abort("resolved-elsewhere");
+        recomputeFooter();
+        redrawFooter();
+      }
+    },
+    onNotice: (ev) => {
+      activeNotice = ev;
+      startSpinner();
+      recomputeFooter();
+      redrawFooter();
+    },
+    onNoticeCleared: (id) => {
+      if (activeNotice && activeNotice.id === id) {
+        activeNotice = null;
+        stopSpinner();
+        recomputeFooter();
+        redrawFooter();
+      }
+    }
+  });
+  const pollStatus = async () => {
+    try {
+      const status = await readBoxStatus({
+        id: opts.boxId,
+        name: opts.boxName,
+        projectIndex: opts.projectIndex
+      });
+      const nextTitle = status?.claude?.sessionTitle?.trim() || void 0;
+      const nextActivity = status?.claude?.state || void 0;
+      if (nextTitle === lastSessionTitle && nextActivity === lastActivity) return;
+      lastSessionTitle = nextTitle;
+      lastActivity = nextActivity;
+      if (footerState.kind === "idle") {
+        recomputeFooter();
+        redrawFooter();
+      }
+    } catch {
+    }
+  };
+  void pollStatus();
+  const statusTimer = setInterval(() => {
+    void pollStatus();
+  }, STATUS_POLL_INTERVAL_MS);
+  if (typeof statusTimer.unref === "function") statusTimer.unref();
+  process.stdout.write(`\x1B[1;${String(innerRows)}r`);
+  if (opts.mode === "shell") {
+    process.stdout.write("\x1B[H\x1B[2J");
+  }
+  redrawFooter();
+  const exitCode = await new Promise((resolve2) => {
+    pty.onExit(({ exitCode: exitCode2 }) => resolve2(exitCode2));
+  });
+  process.stdin.off("data", onStdinData);
+  process.stdout.off("resize", onResize);
+  clearInterval(statusTimer);
+  stopSpinner();
+  if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  process.stdin.pause();
+  stream.close();
+  router.dispose();
+  const rsFinal = process.stdout.rows ?? rows;
+  const csFinal = process.stdout.columns ?? cols;
+  process.stdout.write(
+    "\x1B[r" + cursorMoveTo(rsFinal, 1) + `\x1B[2K` + cursorMoveTo(rsFinal, csFinal)
+  );
+  if (exitCode === 0 && opts.detachNotice) {
+    process.stdout.write("\x1B[1A\x1B[2K\r" + opts.detachNotice + "\n");
+  }
+  return exitCode;
+}
+function runFallback(argv) {
+  const child = spawnSync2("docker", argv, { stdio: "inherit" });
+  return child.status ?? 0;
+}
+
+// src/commands/claude.ts
+function reattachRef(r) {
+  return typeof r.projectIndex === "number" ? String(r.projectIndex) : r.name;
+}
+function logPrune(rebuild) {
+  if (rebuild.prunedBytes <= 0) return;
+  const mb = Math.round(rebuild.prunedBytes / 1024 / 1024);
+  const n = rebuild.pruned.length;
+  log5.info(`pruned ${String(n)} stale plugin cache${n === 1 ? "" : "s"} (${String(mb)} MB freed)`);
+}
+var RELAY_HOST_URL = `http://127.0.0.1:${String(DEFAULT_RELAY_PORT)}`;
+async function attachClaudeWrapped(box, sessionName, reattach) {
+  const code = await runWrappedAttach({
+    container: box.container,
+    dockerArgv: buildClaudeAttachArgv(box.container, sessionName),
+    relayBaseUrl: RELAY_HOST_URL,
+    boxId: box.id,
+    boxName: box.name,
+    projectIndex: box.projectIndex,
+    mode: "claude",
+    detachNotice: formatDetachNotice(reattach)
+  });
+  process.exit(code);
+}
+function buildClaudeCliOverrides(opts) {
+  const box = {};
+  if (opts.hostSnapshot !== void 0) box.hostSnapshot = opts.hostSnapshot;
+  if (opts.image !== void 0) box.image = opts.image;
+  if (opts.withPlaywright === true) box.withPlaywright = true;
+  if (opts.withEnv === true) box.withEnv = true;
+  if (opts.vnc === false) box.vnc = false;
+  if (opts.isolateClaudeConfig === true) box.isolateClaudeConfig = true;
+  if (opts.sharedDockerCache === true) box.dockerCacheShared = true;
+  const claude = {};
+  if (opts.sessionName !== void 0) claude.sessionName = opts.sessionName;
+  const out = {};
+  if (Object.keys(box).length > 0) out.box = box;
+  if (Object.keys(claude).length > 0) out.claude = claude;
+  return out;
+}
+async function runClaudeLoginContainer(image, extraArgs) {
+  const { exitCode } = runInteractiveClaudeLogin(
+    buildClaudeLoginRunArgv({ volume: SHARED_CLAUDE_VOLUME, image, extraArgs })
+  );
+  if (exitCode === 0) {
+    const s = spinner();
+    s.start("checking credentials");
+    const warm = await warmUpClaudeCredentials(SHARED_CLAUDE_VOLUME, image, {
+      onProgress: (line) => s.message(clampSpinnerLine(line))
+    });
+    s.stop(warm.warmed ? "credentials ready" : "credentials check incomplete \u2014 continuing");
+    await syncClaudeCredentials({ volume: SHARED_CLAUDE_VOLUME }, { image, isolate: false });
+  }
+  return exitCode;
+}
+async function maybeRunClaudeLogin(args) {
+  if (!process.stdin.isTTY || args.yes) return;
+  if (args.authSource === "host-env") return;
+  if (await hostBackupHasCredentials()) return;
+  const message = args.authSource === "auth-file" ? "You're on a legacy API token (shows as 'Claude API'). Sign in with your Claude subscription instead?" : "Sign in with your Claude subscription? (saved and reused by every box)";
+  const answer = await confirm2({ message, initialValue: true });
+  if (isCancel2(answer) || !answer) {
+    log5.info("Skipped sign-in \u2014 claude will prompt you to /login inside the box.");
+    return;
+  }
+  const s = spinner();
+  s.start("preparing sandbox image");
+  await ensureImage(args.image, { onProgress: (line) => s.message(clampSpinnerLine(line)) });
+  s.message("preparing claude config");
+  await ensureClaudeVolume(
+    { volume: SHARED_CLAUDE_VOLUME },
+    { syncFromHost: true, image: args.image, hostWorkspace: args.hostWorkspace }
+  );
+  s.stop("image ready");
+  const exitCode = await runClaudeLoginContainer(args.image, ["--claudeai"]);
+  if (exitCode !== 0) {
+    log5.warn("Claude login did not complete; continuing \u2014 run `agentbox claude login` to retry.");
+    return;
+  }
+  log5.success("Signed in with your Claude subscription \u2014 saved for future boxes.");
+}
+var claudeCommand = new Command2("claude").description("Create a sandboxed box and launch Claude Code in a detachable tmux session").option("-w, --workspace <path>", "host workspace to mount", process.cwd()).option("-n, --name <name>", "friendly box name (default: <workspace-basename>-<id>)").option("--host-snapshot", "APFS-clone the host workspace into a per-box scratch dir before seeding /workspace (stabilizes the tar-pipe source)").option("--no-host-snapshot", "tar-pipe directly from the live host workspace at create time").option(
+  "--snapshot <ref>",
+  "start from a project checkpoint (see `agentbox checkpoint`); overrides box.defaultCheckpoint"
+).option("--image <ref>", "override the box image").option("-y, --yes", "skip prompts, accept defaults").option(
+  "--isolate-claude-config",
+  "use a per-box ~/.claude volume instead of the shared agentbox-claude-config"
+).option("--with-playwright", "also install @playwright/cli@latest globally inside the box").option(
+  "--with-env",
+  "copy host env/config files (.env*, secrets.toml, agentbox.yaml, ...) into /workspace at create time (gitignore-bypassing)"
+).option("--no-vnc", "disable the per-box Xvnc + noVNC web client (on by default)").option(
+  "--shared-docker-cache",
+  "use the shared 'agentbox-docker-cache' volume for in-box docker images (preserved on destroy; only one box can run at a time when set)"
+).option("--session-name <name>", "tmux session name (default from config; built-in: claude)").option("--memory <size>", "memory ceiling (e.g. 512m, 2g); unset = unlimited").option("--cpus <n>", "CPU count cap (fractional ok, e.g. 1.5); unset = unlimited").option("--pids-limit <n>", "max process count (PIDs cgroup); unset = unlimited").option("--disk <size>", "best-effort writable-layer size (e.g. 10g); no-op on overlay2/macOS").argument(
+  "[claude-args...]",
+  "extra args passed to claude inside the box; place after `--`, e.g. `agentbox claude -- --model sonnet`"
+).action(async (claudeArgs, opts) => {
+  intro("Starting Claude in a box...");
+  const cfg = await loadEffectiveConfig(opts.workspace, {
+    cliOverrides: buildClaudeCliOverrides(opts)
+  });
+  const projectRoot = (await findProjectRoot(opts.workspace)).root;
+  const checkpointRef = opts.snapshot && opts.snapshot.length > 0 ? opts.snapshot : cfg.effective.box.defaultCheckpoint.length > 0 ? cfg.effective.box.defaultCheckpoint : void 0;
+  const resolved = await resolveClaudeAuth(process.env);
+  await maybeRunClaudeLogin({
+    image: cfg.effective.box.image,
+    authSource: resolved.source,
+    yes: !!opts.yes,
+    hostWorkspace: opts.workspace
+  });
+  const wiz = await maybeRunSetupWizard({
+    workspace: opts.workspace,
+    yes: !!opts.yes,
+    command: "claude",
+    checkpointRef,
+    withEnv: cfg.effective.box.withEnv
+  });
+  let effectiveClaudeArgs = claudeArgs;
+  if (wiz.action === "launch-with-prompt" && wiz.initialPrompt) {
+    effectiveClaudeArgs = resolveAgentLauncher("claude-code").buildArgs(
+      wiz.initialPrompt,
+      claudeArgs
+    );
+  }
+  const useSnapshot = opts.hostSnapshot === false ? false : opts.hostSnapshot === true ? true : cfg.effective.box.hostSnapshot ?? false;
+  const sessionName = cfg.effective.claude.sessionName;
+  const s = spinner();
+  s.start("creating box");
+  let containerName = "";
+  try {
+    const withPlaywright = cfg.effective.box.withPlaywright || cfg.effective.browser.default !== "agent-browser";
+    const result = await createBox({
+      workspacePath: opts.workspace,
+      name: opts.name,
+      useSnapshot,
+      checkpointRef,
+      image: cfg.effective.box.image,
+      claudeConfig: { isolate: cfg.effective.box.isolateClaudeConfig },
+      claudeEnv: resolved.env,
+      withPlaywright,
+      withEnv: cfg.effective.box.withEnv,
+      envFilesToImport: wiz.envFilesToImport,
+      vnc: { enabled: cfg.effective.box.vnc },
+      docker: { sharedCache: cfg.effective.box.dockerCacheShared },
+      limits: resolveLimits(cfg.effective.box, opts),
+      projectRoot,
+      onLog: (line) => s.message(clampSpinnerLine(line))
+    });
+    containerName = result.record.container;
+    s.message("checking plugin native deps");
+    const rebuild = await rebuildPluginNativeDeps(result.record.container, {
+      volume: result.record.claudeConfigVolume ?? SHARED_CLAUDE_VOLUME,
+      onProgress: (line) => s.message(clampSpinnerLine(line))
+    });
+    s.message("starting claude session");
+    await startClaudeSession({
+      container: result.record.container,
+      claudeArgs: effectiveClaudeArgs,
+      sessionName,
+      boxName: result.record.name
+    });
+    const nSuffix = typeof result.record.projectIndex === "number" ? `  \xB7  n ${String(result.record.projectIndex)}` : "";
+    s.stop(`box ${result.record.container} ready${nSuffix}`);
+    logPrune(rebuild);
+    for (const f of rebuild.failed) {
+      log5.warn(`plugin install failed for ${f.dir}; claude may still load it. stderr:
+${f.stderr.trim()}`);
+    }
+    outro("attaching \u2014 Control+a q to detach, leaves claude running");
+    await attachClaudeWrapped(result.record, sessionName, reattachRef(result.record));
+  } catch (err) {
+    s.stop("failed");
+    if (err instanceof ClaudeSessionError) {
+      log5.error(err.message);
+      if (containerName) {
+        log5.info(`The box ${containerName} is still running. Destroy it with:`);
+        log5.info(`  agentbox destroy ${containerName} -y`);
+      }
+      process.exit(1);
+    }
+    handleLifecycleError(err);
+  }
+});
+async function startOrAttachClaude(box, claudeArgs, opts) {
+  const cfg = await loadEffectiveConfig(box.workspacePath, {
+    cliOverrides: opts.sessionName ? { claude: { sessionName: opts.sessionName } } : {}
+  });
+  const sessionName = cfg.effective.claude.sessionName;
+  const resolved = await resolveClaudeAuth(process.env);
+  const insp = await inspectBox(box.id);
+  if (insp.state === "missing") {
+    throw new Error(`box ${box.name} has no container; was it destroyed?`);
+  }
+  const existing = await claudeSessionInfo(box.container, sessionName);
+  if (existing.running) {
+    outro(`session "${sessionName}" already running \u2014 attaching (Control+a q to detach)`);
+    await attachClaudeWrapped(box, sessionName, reattachRef(box));
+    return;
+  }
+  await maybeRunClaudeLogin({
+    image: box.image,
+    authSource: resolved.source,
+    yes: false,
+    hostWorkspace: box.workspacePath
+  });
+  const s = spinner();
+  s.start("preparing box");
+  if (insp.state === "paused") {
+    s.message("unpausing box");
+    await unpauseBox(box.id);
+  } else if (insp.state === "stopped") {
+    s.message("starting box");
+    await startBox(box.id);
+  }
+  const syncConfig = opts.syncConfig !== false;
+  if (syncConfig) {
+    s.message("syncing ~/.claude into box volume");
+    const volume = box.claudeConfigVolume ?? SHARED_CLAUDE_VOLUME;
+    await ensureClaudeVolume(
+      { volume },
+      {
+        syncFromHost: true,
+        image: box.image,
+        hostWorkspace: box.workspacePath
+      }
+    );
+  }
+  const claudeVolume = box.claudeConfigVolume ?? SHARED_CLAUDE_VOLUME;
+  await seedSetupSkillIntoVolume(claudeVolume, box.image);
+  await syncClaudeCredentials(
+    { volume: claudeVolume },
+    { image: box.image, isolate: claudeVolume !== SHARED_CLAUDE_VOLUME }
+  );
+  s.message("checking plugin native deps");
+  const rebuild = await rebuildPluginNativeDeps(box.container, {
+    volume: box.claudeConfigVolume ?? SHARED_CLAUDE_VOLUME,
+    onProgress: (line) => s.message(clampSpinnerLine(line))
+  });
+  s.message("starting claude session");
+  await startClaudeSession({
+    container: box.container,
+    claudeArgs,
+    sessionName,
+    boxName: box.name
+  });
+  s.stop(`box ${box.container} ready`);
+  logPrune(rebuild);
+  for (const f of rebuild.failed) {
+    log5.warn(`plugin install failed for ${f.dir}; claude may still load it. stderr:
+${f.stderr.trim()}`);
+  }
+  outro("attaching \u2014 Control+a q to detach, leaves claude running");
+  await attachClaudeWrapped(box, sessionName, reattachRef(box));
+}
+var claudeAttachCommand = new Command2("attach").description(
+  "Attach to a Claude Code tmux session in a box, starting one if none is running (auto-unpause/start; never re-syncs ~/.claude \u2014 use `claude start` for that)"
+).argument(
+  "[box]",
+  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
+).option("--session-name <name>", "tmux session name (default from config; built-in: claude)").action(async function(idOrName) {
+  const opts = this.optsWithGlobals();
+  intro("Attaching to Claude session...");
+  try {
+    const box = await resolveBoxOrExit(idOrName);
+    await startOrAttachClaude(box, [], { ...opts, syncConfig: false });
+  } catch (err) {
+    if (err instanceof ClaudeSessionError) {
+      log5.error(err.message);
+      process.exit(1);
+    }
+    handleLifecycleError(err);
+  }
+});
+var claudeStartCommand = new Command2("start").description(
   "Start a Claude Code tmux session in an already-existing box (auto-unpause/start). If a session is already running, just attach."
 ).argument(
   "[box]",
@@ -760,7 +1546,7 @@ var claudeStartCommand = new Command2("start").description(
   "extra args passed to claude when starting a new session; ignored if a session is already running. Place after `--`, e.g. `agentbox claude start 1 -- --model sonnet`"
 ).action(async function(idOrName, claudeArgs) {
   const opts = this.optsWithGlobals();
-  intro("agentbox claude start");
+  intro("Starting Claude in a box...");
   try {
     const { box, shifted } = await resolveBoxOrShift(idOrName);
     const effectiveClaudeArgs = shifted && idOrName ? [idOrName, ...claudeArgs] : claudeArgs;
@@ -773,19 +1559,53 @@ var claudeStartCommand = new Command2("start").description(
     handleLifecycleError(err);
   }
 });
+var claudeLoginCommand = new Command2("login").description(
+  "Sign in to Claude for use in sandboxes (forwards args to `claude auth login`, e.g. --sso, --console). Runs in a throwaway container against the shared claude-config volume \u2014 usable before the first `agentbox claude`."
+).argument(
+  "[args...]",
+  "extra args forwarded to `claude auth login`; place after `--`, e.g. `agentbox claude login -- --sso`"
+).action(async (args) => {
+  intro("Signing in to Claude...");
+  if (!process.stdin.isTTY) {
+    log5.error("`agentbox claude login` needs an interactive terminal.");
+    process.exit(1);
+  }
+  try {
+    const cfg = await loadEffectiveConfig(process.cwd());
+    const image = cfg.effective.box.image;
+    const s = spinner();
+    s.start("preparing sandbox image");
+    await ensureImage(image, { onProgress: (line) => s.message(clampSpinnerLine(line)) });
+    s.stop("image ready");
+    const exitCode = await runClaudeLoginContainer(image, args);
+    if (exitCode !== 0) {
+      log5.warn(`\`claude auth login\` exited with code ${String(exitCode)}`);
+      process.exit(exitCode);
+    }
+    outro("signed in \u2014 credentials saved for future boxes");
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
 claudeCommand.addCommand(claudeAttachCommand);
 claudeCommand.addCommand(claudeStartCommand);
+claudeCommand.addCommand(claudeLoginCommand);
 
 // src/commands/checkpoint.ts
 import { confirm as confirm3, isCancel as isCancel3, log as log6 } from "@clack/prompts";
 import { Command as Command3 } from "commander";
+var CHECKPOINT_NOTICE = "Checkpoint in progress \u2014 the box will be unresponsive for a moment";
+var CHECKPOINT_NOTICE_TTL_MS = 66e4;
 async function projectRootFor(cwd, recordRoot) {
   return recordRoot ?? (await findProjectRoot(cwd)).root;
 }
 var createSub = new Command3("create").description("Capture a box state as a project checkpoint (<box-name>-<n>)").argument(
   "[box]",
   "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
-).option("--name <name>", "checkpoint name (default: <box-name>-<next>)").option("--merged", "flatten lower+upper into one tree instead of a layered delta").option("--set-default", "mark this checkpoint as the project default for new boxes").action(async (idOrName, opts) => {
+).option("--name <name>", "checkpoint name (default: <box-name>-<next>)").option("--merged", "flatten lower+upper into one tree instead of a layered delta").option("--set-default", "mark this checkpoint as the project default for new boxes").option(
+  "--replace",
+  "if a checkpoint with the same name exists, rm it first (idempotent recapture; safe to retry when the previous run's stdout was lost)"
+).action(async (idOrName, opts) => {
   try {
     const box = await resolveBoxOrExit(idOrName);
     const insp = await inspectBox(box.id);
@@ -793,27 +1613,57 @@ var createSub = new Command3("create").description("Capture a box state as a pro
       log6.info("box is paused; unpausing");
       await unpauseBox(box.id);
     } else if (insp.state === "stopped") {
-      log6.info("box is stopped; starting (remounting overlay)");
+      log6.info("box is stopped; starting");
       await startBox(box.id);
     } else if (insp.state === "missing") {
       throw new Error(`box ${box.name} has no container; was it destroyed?`);
     }
     const projectRoot = await projectRootFor(box.workspacePath, box.projectRoot);
     const cfg = await loadEffectiveConfig(projectRoot);
-    const info = await createCheckpoint({
-      box,
-      projectRoot,
-      name: opts.name,
-      merged: opts.merged === true,
-      setDefault: opts.setDefault === true,
-      maxLayers: cfg.effective.checkpoint.maxLayers,
-      onLog: (line) => log6.info(line)
-    });
-    log6.success(
-      `checkpoint ${info.name} (${info.manifest.type}) -> ${info.dir}` + (opts.setDefault ? "  [project default]" : "")
+    const noticeId = await setRelayNotice(
+      box.id,
+      "checkpoint",
+      CHECKPOINT_NOTICE,
+      CHECKPOINT_NOTICE_TTL_MS
     );
-    if (!opts.setDefault) {
-      log6.info(`make it the default for new boxes: agentbox checkpoint set-default ${info.name}`);
+    let signalled = false;
+    const onSignal = () => {
+      if (signalled) return;
+      signalled = true;
+      void (async () => {
+        if (noticeId) await clearRelayNotice(box.id, noticeId);
+        process.exit(130);
+      })();
+    };
+    if (noticeId) {
+      process.once("SIGINT", onSignal);
+      process.once("SIGTERM", onSignal);
+    }
+    try {
+      const info = await createCheckpoint({
+        box,
+        projectRoot,
+        name: opts.name,
+        merged: opts.merged === true,
+        setDefault: opts.setDefault === true,
+        replace: opts.replace === true,
+        maxLayers: cfg.effective.checkpoint.maxLayers,
+        onLog: (line) => log6.info(line)
+      });
+      log6.success(
+        `checkpoint ${info.name} (${info.manifest.type}) -> ${info.dir}` + (opts.setDefault ? "  [project default]" : "")
+      );
+      if (!opts.setDefault) {
+        log6.info(
+          `make it the default for new boxes: agentbox checkpoint set-default ${info.name}`
+        );
+      }
+    } finally {
+      if (noticeId) {
+        await clearRelayNotice(box.id, noticeId);
+        process.removeListener("SIGINT", onSignal);
+        process.removeListener("SIGTERM", onSignal);
+      }
     }
   } catch (err) {
     handleLifecycleError(err);
@@ -897,7 +1747,7 @@ var rmSub = new Command3("rm").description("Delete a checkpoint").argument("<ref
     handleLifecycleError(err);
   }
 });
-var checkpointCommand = new Command3("checkpoint").description("Capture and manage project checkpoints (warm box state new boxes can start from)").addCommand(createSub, { isDefault: true }).addCommand(lsSub).addCommand(setDefaultSub).addCommand(rmSub);
+var checkpointCommand = new Command3("checkpoint").alias("checkpoints").description("List and manage project checkpoints (warm box state new boxes can start from)").addCommand(createSub).addCommand(lsSub, { isDefault: true }).addCommand(setDefaultSub).addCommand(rmSub);
 
 // src/commands/code.ts
 import { spawn } from "child_process";
@@ -944,7 +1794,7 @@ var codeCommand = new Command4("code").description("Open a box in VS Code or Cur
       log7.info(`box is paused; unpausing`);
       await unpauseBox(box.id);
     } else if (insp.state === "stopped") {
-      log7.info(`box is stopped; starting (remounting overlay)`);
+      log7.info(`box is stopped; starting`);
       await startBox(box.id);
     } else if (insp.state === "missing") {
       throw new Error(`box ${box.name} has no container; was it destroyed?`);
@@ -1040,10 +1890,10 @@ async function launchOne(flavor, folderUri) {
   return { code: fallback, flavor, via: "open" };
 }
 function spawnCommand(cmd, args) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const child = spawn(cmd, args, { stdio: "ignore" });
-    child.once("error", () => resolve(127));
-    child.once("exit", (code) => resolve(code ?? -1));
+    child.once("error", () => resolve2(127));
+    child.once("exit", (code) => resolve2(code ?? -1));
   });
 }
 async function fetchServiceNames(container) {
@@ -1121,9 +1971,9 @@ var getCommand = new Command5("get").description("Print the effective value of a
     const value = leafValue(loaded, key);
     const source = loaded.sources[key] ?? "default";
     if (opts.json) {
-      const layerView = (values, path) => ({
+      const layerView = (values, path2) => ({
         value: rawLeafFromValues(values, key) ?? null,
-        path
+        path: path2
       });
       process.stdout.write(
         JSON.stringify(
@@ -1272,9 +2122,9 @@ function pickFromScope(loaded, scope, key) {
 var pathCommand = new Command5("path").description("Print the file path for a config scope (default: --project)").option("--global", "~/.agentbox/config.yaml").option("--project", "~/.agentbox/projects/<hash>/config.yaml (default)").option("--workspace", "./agentbox.yaml (resolved by walking up to the nearest one)").option("--json", "machine-readable output").action(async (opts) => {
   try {
     const scope = resolveEditScope(opts);
-    const path = await configPathFor(scope, process.cwd());
-    if (opts.json) process.stdout.write(JSON.stringify({ scope, path }, null, 2) + "\n");
-    else process.stdout.write(`${path}
+    const path2 = await configPathFor(scope, process.cwd());
+    if (opts.json) process.stdout.write(JSON.stringify({ scope, path: path2 }, null, 2) + "\n");
+    else process.stdout.write(`${path2}
 `);
   } catch (err) {
     handleError(err);
@@ -1283,9 +2133,9 @@ var pathCommand = new Command5("path").description("Print the file path for a co
 var editCommand = new Command5("edit").description("Open a config file in $EDITOR (default: --project)").option("--global", "edit ~/.agentbox/config.yaml").option("--project", "edit ~/.agentbox/projects/<hash>/config.yaml (default)").option("--workspace", "edit ./agentbox.yaml (the resolved one \u2014 and remember to fill in the `defaults:` block)").action(async (opts) => {
   try {
     const scope = resolveEditScope(opts);
-    const path = await configPathFor(scope, process.cwd());
+    const path2 = await configPathFor(scope, process.cwd());
     const editor = process.env["EDITOR"] || process.env["VISUAL"] || "vi";
-    const child = spawnSync3(editor, [path], { stdio: "inherit" });
+    const child = spawnSync3(editor, [path2], { stdio: "inherit" });
     process.exit(child.status ?? 0);
   } catch (err) {
     handleError(err);
@@ -1309,25 +2159,236 @@ var listProjectsCommand = new Command5("list-projects").description("List direct
       );
     }
   } catch (err) {
-    handleError(err);
+    handleError(err);
+  }
+});
+function handleError(err) {
+  if (err instanceof UserConfigError) {
+    process.stderr.write(`error: ${err.message}
+`);
+    process.exit(2);
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`error: ${msg}
+`);
+  process.exit(1);
+}
+var configCommand = new Command5("config").description("Read / write layered config (global, per-project, workspace `defaults:` block)").addCommand(getCommand).addCommand(setCommand).addCommand(unsetCommand).addCommand(listCommand).addCommand(pathCommand).addCommand(editCommand).addCommand(listProjectsCommand);
+
+// src/commands/cp.ts
+import { existsSync, mkdirSync, renameSync, statSync } from "fs";
+import * as path from "path";
+import { log as log8 } from "@clack/prompts";
+import { Command as Command6 } from "commander";
+import { execa } from "execa";
+function parseBoxArg(arg) {
+  const idx = arg.indexOf(":");
+  if (idx === -1) return null;
+  const prefix = arg.slice(0, idx);
+  if (prefix.includes("/")) return null;
+  if (prefix.length === 0) return null;
+  const p = arg.slice(idx + 1);
+  if (p.length === 0) return null;
+  return { boxRef: prefix, path: p };
+}
+function parseArgs(src, dst) {
+  const srcBox = parseBoxArg(src);
+  const dstBox = dst === void 0 ? null : parseBoxArg(dst);
+  if (srcBox && dstBox) {
+    throw new Error(
+      "box-to-box copy is not supported; both arguments look like box paths (`name:/path`)."
+    );
+  }
+  if (!srcBox && !dstBox) {
+    throw new Error(
+      "one argument must be a box path of the form `<box>:/path` (e.g. `mybox:/workspace/foo`)."
+    );
+  }
+  if (srcBox) {
+    return {
+      direction: "download",
+      boxRef: srcBox.boxRef,
+      boxPath: srcBox.path,
+      hostPath: dst
+    };
+  }
+  if (dst === void 0) {
+    throw new Error("host -> box copy requires a destination, e.g. `agentbox cp ./foo box:/dst`.");
+  }
+  return {
+    direction: "upload",
+    boxRef: dstBox.boxRef,
+    boxPath: dstBox.path,
+    hostPath: src
+  };
+}
+function posixDirname(p) {
+  return path.posix.dirname(p) || "/";
+}
+function asText(s) {
+  if (s === void 0) return "";
+  if (typeof s === "string") return s;
+  return Buffer.from(s).toString("utf8");
+}
+async function uploadToBox(box, hostSrc, boxDst) {
+  const srcAbs = path.resolve(hostSrc);
+  if (!existsSync(srcAbs)) throw new Error(`source not found: ${hostSrc}`);
+  const srcBasename = path.basename(srcAbs);
+  const srcParent = path.dirname(srcAbs);
+  let boxParent;
+  let finalName;
+  if (boxDst.endsWith("/")) {
+    boxParent = boxDst.replace(/\/+$/, "") || "/";
+    finalName = srcBasename;
+  } else {
+    const isDir = await execa(
+      "docker",
+      ["exec", box.container, "test", "-d", boxDst],
+      { reject: false }
+    );
+    if (isDir.exitCode === 0) {
+      boxParent = boxDst.replace(/\/+$/, "") || "/";
+      finalName = srcBasename;
+    } else {
+      boxParent = posixDirname(boxDst);
+      finalName = path.posix.basename(boxDst);
+    }
+  }
+  const finalPath = boxParent === "/" ? `/${finalName}` : `${boxParent}/${finalName}`;
+  const mk = await execa(
+    "docker",
+    ["exec", "--user", "root", box.container, "mkdir", "-p", boxParent],
+    { reject: false }
+  );
+  if (mk.exitCode !== 0) {
+    throw new Error(`mkdir -p ${boxParent} in box failed: ${asText(mk.stderr).slice(0, 300)}`);
+  }
+  const packed = await execa("tar", ["-C", srcParent, "-cf", "-", srcBasename], {
+    encoding: "buffer",
+    reject: false,
+    env: { ...process.env, COPYFILE_DISABLE: "1" }
+  });
+  if (packed.exitCode !== 0) {
+    throw new Error(`tar pack failed: ${asText(packed.stderr).slice(0, 300)}`);
+  }
+  const extract = await execa(
+    "docker",
+    ["exec", "-i", "--user", "root", box.container, "tar", "-xf", "-", "-C", boxParent],
+    { input: packed.stdout, reject: false }
+  );
+  if (extract.exitCode !== 0) {
+    throw new Error(`tar extract in box failed: ${asText(extract.stderr).slice(0, 300)}`);
+  }
+  if (finalName !== srcBasename) {
+    const initial = boxParent === "/" ? `/${srcBasename}` : `${boxParent}/${srcBasename}`;
+    const mv = await execa(
+      "docker",
+      ["exec", "--user", "root", box.container, "mv", initial, finalPath],
+      { reject: false }
+    );
+    if (mv.exitCode !== 0) {
+      throw new Error(
+        `rename ${initial} -> ${finalPath} in box failed: ${asText(mv.stderr).slice(0, 300)}`
+      );
+    }
+  }
+  const chown = await execa(
+    "docker",
+    ["exec", "--user", "root", box.container, "chown", "-R", "1000:1000", finalPath],
+    { reject: false }
+  );
+  if (chown.exitCode !== 0) {
+    return {
+      finalPath,
+      warn: `chown ${finalPath} to vscode (uid 1000) failed; ownership inside the box may be root.`
+    };
+  }
+  return { finalPath, warn: null };
+}
+async function downloadFromBox(box, boxSrc, hostDst) {
+  const srcBasename = path.posix.basename(boxSrc);
+  const srcParent = posixDirname(boxSrc);
+  const dstAbs = path.resolve(hostDst);
+  let hostParent;
+  let finalName;
+  const dstExists = existsSync(dstAbs);
+  if (hostDst.endsWith("/") || dstExists && statSync(dstAbs).isDirectory()) {
+    hostParent = dstAbs;
+    finalName = srcBasename;
+  } else {
+    hostParent = path.dirname(dstAbs);
+    finalName = path.basename(dstAbs);
+  }
+  mkdirSync(hostParent, { recursive: true });
+  const finalPath = path.join(hostParent, finalName);
+  const packed = await execa(
+    "docker",
+    ["exec", box.container, "tar", "-C", srcParent, "-cf", "-", srcBasename],
+    { encoding: "buffer", reject: false }
+  );
+  if (packed.exitCode !== 0) {
+    throw new Error(`tar pack in box failed: ${asText(packed.stderr).slice(0, 300)}`);
+  }
+  const extract = await execa("tar", ["-xf", "-", "-C", hostParent], {
+    input: packed.stdout,
+    reject: false
+  });
+  if (extract.exitCode !== 0) {
+    throw new Error(`tar extract on host failed: ${asText(extract.stderr).slice(0, 300)}`);
+  }
+  if (finalName !== srcBasename) {
+    renameSync(path.join(hostParent, srcBasename), finalPath);
+  }
+  return { finalPath };
+}
+var cpCommand = new Command6("cp").description("Copy files between host and box (like `docker cp`; direction picked by `name:` prefix)").argument("<src>", "`box:/path` (download) or host path (upload)").argument(
+  "[dst]",
+  "`box:/path` (upload) or host path (download); defaults to cwd when downloading"
+).addHelpText(
+  "after",
+  [
+    "",
+    "Examples:",
+    "  agentbox cp mybox:/etc/foo ./foo            # download (host path optional)",
+    "  agentbox cp mybox:/workspace/.env           # download into cwd",
+    "  agentbox cp ./local.txt mybox:/workspace/   # upload (host path required)",
+    "  agentbox cp ./dir mybox:/workspace/         # upload directory (recursive)"
+  ].join("\n")
+).action(async (src, dst) => {
+  try {
+    const parsed = parseArgs(src, dst);
+    const box = await resolveBoxOrExit(parsed.boxRef);
+    const insp = await inspectBox(box.id);
+    if (insp.state === "paused") {
+      log8.info("box is paused; unpausing");
+      await unpauseBox(box.id);
+    } else if (insp.state === "stopped") {
+      log8.info("box is stopped; starting");
+      await startBox(box.id);
+    } else if (insp.state === "missing") {
+      throw new Error(`box ${box.name} has no container; was it destroyed?`);
+    }
+    if (parsed.direction === "upload") {
+      const result = await uploadToBox(box, parsed.hostPath, parsed.boxPath);
+      if (result.warn) {
+        log8.warn(`copied to ${box.name}:${result.finalPath}, but ${result.warn}`);
+      } else {
+        process.stdout.write(`copied to ${box.name}:${result.finalPath}
+`);
+      }
+    } else {
+      const result = await downloadFromBox(box, parsed.boxPath, parsed.hostPath ?? process.cwd());
+      process.stdout.write(`copied to ${result.finalPath}
+`);
+    }
+  } catch (err) {
+    handleLifecycleError(err);
   }
 });
-function handleError(err) {
-  if (err instanceof UserConfigError) {
-    process.stderr.write(`error: ${err.message}
-`);
-    process.exit(2);
-  }
-  const msg = err instanceof Error ? err.message : String(err);
-  process.stderr.write(`error: ${msg}
-`);
-  process.exit(1);
-}
-var configCommand = new Command5("config").description("Read / write layered config (global, per-project, workspace `defaults:` block)").addCommand(getCommand).addCommand(setCommand).addCommand(unsetCommand).addCommand(listCommand).addCommand(pathCommand).addCommand(editCommand).addCommand(listProjectsCommand);
 
 // src/commands/create.ts
-import { intro as intro2, log as log8, outro as outro2, spinner as spinner2 } from "@clack/prompts";
-import { Command as Command6 } from "commander";
+import { intro as intro2, log as log9, outro as outro2, spinner as spinner2 } from "@clack/prompts";
+import { Command as Command7 } from "commander";
 import { execSync, spawnSync as spawnSync4 } from "child_process";
 function buildCliOverrides(opts) {
   const box = {};
@@ -1342,19 +2403,31 @@ function buildCliOverrides(opts) {
 function resolveUseSnapshot(opts, configDefault) {
   if (opts.hostSnapshot === false) return false;
   if (opts.hostSnapshot === true) return true;
-  return configDefault ?? true;
+  return configDefault ?? false;
 }
 function resolveCheckpointRef(opts, configDefault) {
   if (opts.snapshot && opts.snapshot.length > 0) return opts.snapshot;
   return configDefault.length > 0 ? configDefault : void 0;
 }
-function attachShell(container) {
-  const child = spawnSync4("docker", ["exec", "-it", container, "bash"], {
-    stdio: "inherit"
+var RELAY_HOST_URL2 = `http://127.0.0.1:${String(DEFAULT_RELAY_PORT)}`;
+async function attachShell(record) {
+  const dockerArgv = ["exec", "-it", record.container, "bash"];
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    const child = spawnSync4("docker", dockerArgv, { stdio: "inherit" });
+    process.exit(child.status ?? 0);
+  }
+  const code = await runWrappedAttach({
+    container: record.container,
+    dockerArgv,
+    relayBaseUrl: RELAY_HOST_URL2,
+    boxId: record.id,
+    boxName: record.name,
+    projectIndex: record.projectIndex,
+    mode: "shell"
   });
-  process.exit(child.status ?? 0);
+  process.exit(code);
 }
-var createCommand = new Command6("create").description("Create and start a new agent box (Docker container with FUSE overlay)").option("-w, --workspace <path>", "host workspace to mount", process.cwd()).option("-n, --name <name>", "friendly box name (default: <workspace-basename>-<id>)").option("--host-snapshot", "use a frozen APFS clone of the host workspace as the overlay lower").option("--no-host-snapshot", "bind the live workspace directly (host edits leak into reads)").option(
+var createCommand = new Command7("create").description("Create and start a new agent box (Docker container with /workspace seeded via in-container git worktree)").option("-w, --workspace <path>", "host workspace to mount", process.cwd()).option("-n, --name <name>", "friendly box name (default: <workspace-basename>-<id>)").option("--host-snapshot", "APFS-clone the host workspace into a per-box scratch dir before seeding /workspace (stabilizes the tar-pipe source)").option("--no-host-snapshot", "bind the live workspace directly (host edits leak into reads)").option(
   "--snapshot <ref>",
   "start from a project checkpoint (see `agentbox checkpoint`); overrides box.defaultCheckpoint"
 ).option("--image <ref>", "override the box image", void 0).option("--attach", "drop into a shell inside the box after it is ready").option("--with-playwright", "also install @playwright/cli@latest globally inside the box").option(
@@ -1363,8 +2436,8 @@ var createCommand = new Command6("create").description("Create and start a new a
 ).option("--no-vnc", "disable the per-box Xvnc + noVNC web client (on by default)").option(
   "--shared-docker-cache",
   "use the shared 'agentbox-docker-cache' volume for in-box docker images (preserved on destroy; only one box can run at a time when set)"
-).option("--memory <size>", "memory ceiling (e.g. 512m, 2g); unset = unlimited").option("--cpus <n>", "CPU count cap (fractional ok, e.g. 1.5); unset = unlimited").option("--pids-limit <n>", "max process count (PIDs cgroup); unset = unlimited").option("--disk <size>", "best-effort writable-layer size (e.g. 10g); no-op on overlay2/macOS").option("-y, --yes", "skip prompts, accept defaults (host-snapshot=on)").action(async (opts) => {
-  intro2("agentbox create");
+).option("--memory <size>", "memory ceiling (e.g. 512m, 2g); unset = unlimited").option("--cpus <n>", "CPU count cap (fractional ok, e.g. 1.5); unset = unlimited").option("--pids-limit <n>", "max process count (PIDs cgroup); unset = unlimited").option("--disk <size>", "best-effort container writable-layer size (e.g. 10g); no-op on overlay2/macOS").option("-y, --yes", "skip prompts, accept defaults").action(async (opts) => {
+  intro2("Setting up a new box...");
   const cfg = await loadEffectiveConfig(opts.workspace, {
     cliOverrides: buildCliOverrides(opts)
   });
@@ -1374,14 +2447,18 @@ var createCommand = new Command6("create").description("Create and start a new a
     workspace: opts.workspace,
     yes: !!opts.yes,
     command: "create",
-    checkpointRef
+    checkpointRef,
+    withEnv: cfg.effective.box.withEnv
   });
   if (wiz.action === "switch-to-claude") {
     process.env[WIZARD_AUTOLAUNCH_ENV] = "1";
+    const serialized = serializeEnvFilesForEnv(wiz.envFilesToImport);
+    if (serialized !== void 0) process.env[WIZARD_ENV_FILES_ENV] = serialized;
     try {
       await claudeCommand.parseAsync(passthroughFlags(opts), { from: "user" });
     } finally {
       delete process.env[WIZARD_AUTOLAUNCH_ENV];
+      delete process.env[WIZARD_ENV_FILES_ENV];
     }
     return;
   }
@@ -1398,6 +2475,7 @@ var createCommand = new Command6("create").description("Create and start a new a
       image: cfg.effective.box.image,
       withPlaywright,
       withEnv: cfg.effective.box.withEnv,
+      envFilesToImport: wiz.envFilesToImport,
       vnc: { enabled: cfg.effective.box.vnc },
       docker: { sharedCache: cfg.effective.box.dockerCacheShared },
       limits: resolveLimits(cfg.effective.box, opts),
@@ -1405,26 +2483,21 @@ var createCommand = new Command6("create").description("Create and start a new a
       onLog: (line) => s.message(clampSpinnerLine(line))
     });
     s.stop(`box ${result.record.container} ready`);
-    log8.info(`id:        ${result.record.id}`);
+    log9.info(`id:        ${result.record.id}`);
     if (typeof result.record.projectIndex === "number") {
-      log8.info(`n:         ${String(result.record.projectIndex)}   (in ${projectRoot})`);
+      log9.info(`n:         ${String(result.record.projectIndex)}   (in ${projectRoot})`);
     }
-    log8.info(`container: ${result.record.container}`);
-    log8.info(`image:     ${result.record.image}${result.imageBuilt ? " (built just now)" : ""}`);
-    log8.info(`lower:     ${result.record.lowerPath}`);
-    log8.info(`upper:     ${result.record.upperVolume}`);
+    log9.info(`container: ${result.record.container}`);
+    log9.info(`image:     ${result.record.image}${result.imageBuilt ? " (built just now)" : ""}`);
     if (result.record.snapshotDir) {
-      log8.info(`snapshot:  ${result.record.snapshotDir}`);
+      log9.info(`snapshot:  ${result.record.snapshotDir}`);
     }
     if (result.record.checkpointSource) {
-      log8.info(
-        `checkpoint: ${result.record.checkpointSource.ref} (${result.record.checkpointSource.type})`
+      log9.info(
+        `checkpoint: ${result.record.checkpointSource.ref} (${result.record.checkpointSource.type}) \u2192 ${result.record.checkpointImage ?? "(missing)"}`
       );
     }
-    for (const check of result.overlayChecks) {
-      log8.success(`${check.name} \u2014 ${check.detail}`);
-    }
-    log8.message(
+    log9.message(
       [
         "",
         "Try it:",
@@ -1432,8 +2505,7 @@ var createCommand = new Command6("create").description("Create and start a new a
         `  docker exec ${result.record.container} ls /workspace`,
         "",
         "Destroy:",
-        `  docker rm -f ${result.record.container}`,
-        `  docker volume rm ${result.record.upperVolume}`
+        `  agentbox destroy ${result.record.name}`
       ].join("\n")
     );
     const m = cfg.effective.maintenance;
@@ -1445,7 +2517,7 @@ var createCommand = new Command6("create").description("Create and start a new a
           const protectedPaths = boxes.map((b) => b.projectRoot).filter((p) => typeof p === "string");
           const res = await pruneOrphanProjectConfigs({ protectedPaths });
           if (res.removed.length > 0) {
-            log8.info(
+            log9.info(
               `cleaned ${String(res.removed.length)} orphan project config dir(s): ` + res.removed.map((r) => r.originalPath).join(", ")
             );
           }
@@ -1455,19 +2527,19 @@ var createCommand = new Command6("create").description("Create and start a new a
     }
     outro2("done");
     if (opts.attach) {
-      attachShell(result.record.container);
+      await attachShell(result.record);
     }
   } catch (err) {
     s.stop("failed");
     const msg = err instanceof Error ? err.message : String(err);
-    log8.error(msg);
+    log9.error(msg);
     try {
       const running = execSync('docker ps --format "{{.Names}}"', {
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().split("\n").filter((n) => n.startsWith("agentbox-"));
       if (running.length > 0) {
-        log8.warn(`leftover containers: ${running.join(", ")}`);
-        log8.warn(`remove with: docker rm -f ${running.join(" ")}`);
+        log9.warn(`leftover containers: ${running.join(", ")}`);
+        log9.warn(`remove with: docker rm -f ${running.join(" ")}`);
       }
     } catch {
     }
@@ -1477,8 +2549,8 @@ var createCommand = new Command6("create").description("Create and start a new a
 
 // src/commands/dashboard.ts
 import { spawn as spawn2 } from "child_process";
-import { log as log9 } from "@clack/prompts";
-import { Command as Command7 } from "commander";
+import { log as log10 } from "@clack/prompts";
+import { Command as Command8 } from "commander";
 
 // src/dashboard/layout.ts
 var SIDEBAR_WIDTH = 32;
@@ -1503,7 +2575,7 @@ function computeLayout(cols, rows) {
 }
 
 // src/dashboard/renderer.ts
-var RESET = "\x1B[0m";
+var RESET2 = "\x1B[0m";
 function fgParams(c) {
   if (c.kind === "default") return "39";
   if (c.kind === "palette") {
@@ -1548,7 +2620,7 @@ function composeRow(snap, y) {
     }
     out += cell.chars === "" ? " " : cell.chars;
   }
-  return out + RESET;
+  return out + RESET2;
 }
 function cursorTo(row0, col0) {
   return `\x1B[${String(row0 + 1)};${String(col0 + 1)}H`;
@@ -1561,7 +2633,7 @@ function diffFrame(prev, snap, rect) {
     const payload = composeRow(snap, i);
     rows[i] = payload;
     if (prev && prev[i] === payload) continue;
-    out += cursorTo(rect.y + i, rect.x) + RESET + payload + RESET;
+    out += cursorTo(rect.y + i, rect.x) + RESET2 + payload + RESET2;
   }
   if (snap.cursor.visible) {
     const cy = Math.min(Math.max(snap.cursor.y, 0), h - 1);
@@ -1868,228 +2940,20 @@ var PtySession = class {
   }
 };
 
-// src/dashboard/sidebar.ts
-function ellipsize(s, max) {
-  if (max <= 0) return "";
-  if (s.length <= max) return s;
-  if (max === 1) return "\u2026";
-  return s.slice(0, max - 1) + "\u2026";
-}
-function ellipsizeHead(s, max) {
-  if (max <= 0) return "";
-  if (s.length <= max) return s;
-  if (max === 1) return "\u2026";
-  return "\u2026" + s.slice(s.length - (max - 1));
-}
-function activityCell(b) {
-  if (b.state !== "running") return `[${b.state}]`;
-  switch (b.claudeActivity) {
-    case "working":
-      return "\u25CF working";
-    case "idle":
-      return "\u25CB idle";
-    case "waiting":
-      return "\u25D0 waiting";
-    default:
-      return "? unknown";
-  }
-}
-var NEW_BOX_ID = "__agentbox_new__";
-var NEW_BOX_LABEL = "+ New box";
-var SIDEBAR_HEADER = "AgentBox";
-function topBorder(label, w) {
-  const lead = `\u256D\u2500\u2500\u2500 ${label} `;
-  if (lead.length >= w) return lead.slice(0, w);
-  return lead + "\u2500".repeat(w - lead.length);
-}
-function fit(s, w) {
-  if (s.length === w) return s;
-  if (s.length > w) return s.slice(0, w);
-  return s + " ".repeat(w - s.length);
-}
-function center(s, w) {
-  if (s.length >= w) return s.slice(0, w);
-  const pad = w - s.length;
-  const leftPad = Math.floor(pad / 2);
-  return " ".repeat(leftPad) + s + " ".repeat(pad - leftPad);
-}
-function projectLabel(project) {
-  if (!project) return "(no project)";
-  const parts = project.split("/").filter(Boolean);
-  return parts[parts.length - 1] ?? project;
-}
-function stripTitleGlyph(s) {
-  const t = s.replace(/^[\s\p{S}*·]+/u, "");
-  return t.length > 0 ? t : s.trim();
-}
-function boxRow(b, marker, w) {
-  const numStr = b.index != null ? `${b.index} ` : "";
-  const status = activityCell(b);
-  const left = `${marker}${numStr}`;
-  const room = w - left.length - status.length - 1;
-  if (room <= 0) return fit(`${left}${status}`, w);
-  const middle = b.state === "running" && b.sessionTitle ? ellipsize(stripTitleGlyph(b.sessionTitle), room) : ellipsizeHead(b.name, room);
-  return fit(`${left}${middle}`, w - status.length) + status;
-}
-function sidebarLines(boxes, selectedId, w, h) {
-  const lines = [topBorder(SIDEBAR_HEADER, w), fit("", w)];
-  const rowOwner = [null, null];
-  const headerRows = [true, false];
-  const push = (line, owner, header) => {
-    lines.push(fit(line, w));
-    rowOwner.push(owner);
-    headerRows.push(header);
-  };
-  let prevProject;
-  let seenGroup = false;
-  for (const b of boxes) {
-    const marker = b.id === selectedId ? "\u25B8" : " ";
-    if (b.id === NEW_BOX_ID) {
-      push(`${marker}${NEW_BOX_LABEL}`, b.id, false);
-      continue;
-    }
-    if (!seenGroup || b.project !== prevProject) {
-      push(center(` \u2500\u2500 ${projectLabel(b.project)} \u2500\u2500 `, w), null, true);
-      prevProject = b.project;
-      seenGroup = true;
-    }
-    push(boxRow(b, marker, w), b.id, false);
-  }
-  if (boxes.length === 0) push(" (no boxes)", null, false);
-  while (lines.length < h) push("", null, false);
-  return {
-    lines: lines.slice(0, h),
-    rowOwner: rowOwner.slice(0, h),
-    headerRows: headerRows.slice(0, h)
-  };
-}
-function menuLines(boxName, w, h) {
-  const body = [
-    "",
-    `  No Claude session in ${boxName}.`,
-    "",
-    "   [c]  Start Claude here",
-    "   [s]  Open a shell",
-    "",
-    "  Ctrl+Option+\u2191/\u2193 switch \xB7 Ctrl-a then v/c/w/q (vnc/code/web/quit)"
-  ];
-  const top = Math.max(0, Math.floor((h - body.length) / 2));
-  const out = [];
-  for (let i = 0; i < h; i++) out.push(fit(body[i - top] ?? "", w));
-  return out;
-}
-function lifecycleMenuLines(boxName, state, confirmDestroy, w, h) {
-  const body = confirmDestroy ? [
-    "",
-    `  Destroy ${boxName}?`,
-    "  This removes the container and its volumes.",
-    "",
-    "   [y]  Yes, destroy",
-    "   [any other key]  Cancel"
-  ] : [
-    "",
-    `  Box ${boxName} is ${state}.`,
-    "",
-    state === "paused" ? "   [u]  Unpause" : "   [s]  Start",
-    "   [d]  Destroy",
-    "",
-    "  Ctrl+Option+\u2191/\u2193 switch \xB7 Ctrl-a then q quit"
-  ];
-  const top = Math.max(0, Math.floor((h - body.length) / 2));
-  const out = [];
-  for (let i = 0; i < h; i++) out.push(fit(body[i - top] ?? "", w));
-  return out;
-}
-function createMenuLines(where, w, h) {
-  const body = [
-    "",
-    "  Create a new box",
-    "",
-    "   [c]  Create + launch Claude",
-    "   [n]  Create only",
-    "",
-    `  in ${where}`,
-    "",
-    "  Ctrl+Option+\u2191/\u2193 switch \xB7 Ctrl-a then q quit"
-  ];
-  const top = Math.max(0, Math.floor((h - body.length) / 2));
-  const out = [];
-  for (let i = 0; i < h; i++) out.push(fit(body[i - top] ?? "", w));
-  return out;
-}
-var BAR_BG = "\x1B[48;2;48;48;48m";
-var BAR_BASE = BAR_BG + "\x1B[38;5;250m";
-var BAR_BRAND = "\x1B[48;5;39m\x1B[38;5;16m";
-var BRAND_BOLD = "\x1B[1m";
-var BRAND_NOBOLD = "\x1B[22m";
-var HINT_KEY = "\x1B[38;5;255m";
-var HINT_TXT = "\x1B[38;5;245m";
-var BAR_RESET = "\x1B[0m";
-var SWITCH_HINT = ["Control+Option+\u2191/\u2193", "switch"];
-var HINT_GROUPS = [
-  SWITCH_HINT,
-  ["Control+a c", "code"],
-  ["Control+a v", "vnc"],
-  ["Control+a w", "web"],
-  ["Control+a q", "quit"]
-];
-var COLLAPSED_HINT_GROUPS = [
-  SWITCH_HINT,
-  ["Control+a", "more"]
-];
-var ADVANCED_HINT_GROUPS = [
-  ["c", "code"],
-  ["v", "vnc"],
-  ["w", "web"],
-  ["s", "stop"],
-  ["p", "pause"],
-  ["d", "destroy"],
-  ["q", "quit"]
-];
-function statusLine(box, w, stateLabel, groups = HINT_GROUPS) {
-  const state = stateLabel ?? (box ? box.state === "running" ? box.claudeActivity ?? "unknown" : box.state : "");
-  const brandPrefix = box ? " agentbox \u25B8 " : " agentbox ";
-  const base = box ? `${box.name} (${state})` : "";
-  const coreMain = box ? `${base} ` : "";
-  const corePlain = brandPrefix + coreMain;
-  const SEP = "   \u2502   ";
-  const renderHints = (g) => ({
-    plain: g.map(([k, l]) => `${k}: ${l}`).join(SEP) + " ",
-    styled: g.map(([k, l]) => `${HINT_KEY}${k}${HINT_TXT}: ${l}`).join(`${HINT_TXT}${SEP}`) + " "
-  });
-  let hints = null;
-  for (const g of [groups, COLLAPSED_HINT_GROUPS]) {
-    const h = renderHints(g);
-    if (corePlain.length + h.plain.length + 1 <= w) {
-      hints = h;
-      break;
-    }
-  }
-  if (!hints) {
-    return BAR_BASE + BAR_BRAND + fit(corePlain, w) + BAR_RESET;
-  }
-  const room = w - corePlain.length - hints.plain.length - 1;
-  let titleSeg = "";
-  if (box?.sessionTitle && room >= 7) {
-    titleSeg = ` \u2014 ${ellipsize(box.sessionTitle, Math.min(40, room - 3))}`;
-  }
-  const leftPlain = brandPrefix + base + titleSeg + (box ? " " : "");
-  const leftStyled = BAR_BRAND + brandPrefix + BRAND_BOLD + base + titleSeg + (box ? " " : "") + BRAND_NOBOLD;
-  const gap = w - leftPlain.length - hints.plain.length;
-  return BAR_BASE + leftStyled + BAR_BASE + " ".repeat(gap) + hints.styled + BAR_RESET;
-}
-
 // src/dashboard/compositor.ts
 var SB_BODY = BAR_BG + "\x1B[38;5;250m";
 var SB_HEADER = BAR_BG + "\x1B[38;5;39m\x1B[1m";
 var SB_SELECTED = BAR_BG + "\x1B[38;5;255m\x1B[1m";
+var SB_PROMPT = BAR_BG + "\x1B[38;5;220m\x1B[1m";
+var SB_AWAITING = BAR_BG + "\x1B[38;5;51m\x1B[1m";
 var SGR_RESET = "\x1B[0m";
 var POLL_MS = 1e3;
 var FRAME_MS = 16;
 var RESIZE_DEBOUNCE_MS = 120;
 var LEADER_LINGER_MS = 1500;
-var SYNC_BEGIN = "\x1B[?2026h";
-var SYNC_END = "\x1B[?2026l";
+var NOTICE_SPINNER_MS = 120;
+var SYNC_BEGIN2 = "\x1B[?2026h";
+var SYNC_END2 = "\x1B[?2026l";
 function cursorTo2(x, y) {
   return `\x1B[${String(y + 1)};${String(x + 1)}H`;
 }
@@ -2125,6 +2989,9 @@ var Compositor = class {
           this.pendingConfirm = null;
           this.drawChrome();
         }
+        if (e.type === "forward" && this.activePrompts.has(this.selectedId)) {
+          if (this.handlePromptKey(e.bytes)) return;
+        }
         if (e.type === "quit") this.onSig();
         else if (e.type === "switch") this.switchBox(e.dir);
         else if (e.type === "action") {
@@ -2168,6 +3035,26 @@ var Compositor = class {
   leaderLingerTimer = null;
   /** Set while a destroy confirm is pending in the status bar. */
   pendingConfirm = null;
+  /**
+   * Per-box relay-prompt state. Populated by SSE `prompt-ask` events,
+   * cleared by `prompt-resolved` events or by the local user answering.
+   * The sidebar reads it to mark rows; drawChrome's status-line picker
+   * reads it to swap to [!] mode when the SELECTED box is in this map.
+   * Subscriptions are tracked separately in {@link promptStreams} so
+   * we can dispose them when boxes disappear from the list.
+   */
+  activePrompts = /* @__PURE__ */ new Map();
+  /**
+   * Per-box active relay notice (currently: a checkpoint freezing the box).
+   * Drives the `◆ checkpoint` sidebar cell and the animated status-bar
+   * warning. Shares the SSE subscriptions in {@link promptStreams}.
+   */
+  activeNotices = /* @__PURE__ */ new Map();
+  /** Monotonic spinner counter for the notice status bar. */
+  noticeFrame = 0;
+  /** Drives the spinner animation while {@link activeNotices} is non-empty. */
+  noticeTimer = null;
+  promptStreams = /* @__PURE__ */ new Map();
   activeMode = "claude";
   flashMsg = null;
   flashTimer = null;
@@ -2209,18 +3096,98 @@ var Compositor = class {
     if (!this.boxes.some((b) => b.id === this.selectedId) && this.boxes[0]) {
       this.selectedId = this.boxes[0].id;
     }
-    await this.spawnActive();
-    this.drawChrome();
-    this.scheduleRender();
-    this.pollTimer = setInterval(() => void this.poll(), POLL_MS);
-    await new Promise((resolve) => {
-      this.resolveDone = resolve;
-    });
+    await this.spawnActive();
+    this.drawChrome();
+    this.scheduleRender();
+    this.pollTimer = setInterval(() => void this.poll(), POLL_MS);
+    await new Promise((resolve2) => {
+      this.resolveDone = resolve2;
+    });
+  }
+  async refreshBoxes() {
+    try {
+      this.boxes = await this.deps.listCandidates();
+    } catch {
+    }
+    this.syncPromptSubscriptions();
+  }
+  /**
+   * Diff the current box list against {@link promptStreams}: subscribe to
+   * any newcomer (skipping the synthetic + New box entry and pre-relay
+   * boxes), dispose any departed subscription. Idempotent — safe to call
+   * after every poll. Disposed boxes also clear their {@link activePrompts}
+   * entry so the sidebar marker doesn't linger.
+   */
+  syncPromptSubscriptions() {
+    if (this.tornDown) return;
+    const url = this.deps.relayBaseUrl;
+    if (!url) return;
+    const wanted = /* @__PURE__ */ new Set();
+    for (const b of this.boxes) {
+      if (b.id === NEW_BOX_ID) continue;
+      wanted.add(b.id);
+    }
+    for (const [boxId, stream] of this.promptStreams) {
+      if (!wanted.has(boxId)) {
+        stream.close();
+        this.promptStreams.delete(boxId);
+        let changed = this.activePrompts.delete(boxId);
+        if (this.activeNotices.delete(boxId)) changed = true;
+        if (this.activeNotices.size === 0) this.stopNoticeSpinner();
+        if (changed) this.drawChrome();
+      }
+    }
+    for (const boxId of wanted) {
+      if (this.promptStreams.has(boxId)) continue;
+      const stream = subscribePrompts({
+        relayBaseUrl: url,
+        boxId,
+        onPrompt: (ev) => {
+          if (this.tornDown) return;
+          this.activePrompts.set(boxId, ev);
+          this.drawChrome();
+        },
+        onResolved: (id) => {
+          if (this.tornDown) return;
+          const current = this.activePrompts.get(boxId);
+          if (current && current.id === id) {
+            this.activePrompts.delete(boxId);
+            this.drawChrome();
+          }
+        },
+        onNotice: (ev) => {
+          if (this.tornDown) return;
+          this.activeNotices.set(boxId, ev);
+          this.startNoticeSpinner();
+          this.drawChrome();
+        },
+        onNoticeCleared: (id) => {
+          if (this.tornDown) return;
+          const current = this.activeNotices.get(boxId);
+          if (current && current.id === id) {
+            this.activeNotices.delete(boxId);
+            if (this.activeNotices.size === 0) this.stopNoticeSpinner();
+            this.drawChrome();
+          }
+        },
+        onError: () => {
+        }
+      });
+      this.promptStreams.set(boxId, stream);
+    }
   }
-  async refreshBoxes() {
-    try {
-      this.boxes = await this.deps.listCandidates();
-    } catch {
+  startNoticeSpinner() {
+    if (this.noticeTimer) return;
+    this.noticeTimer = setInterval(() => {
+      this.noticeFrame++;
+      this.drawChrome();
+    }, NOTICE_SPINNER_MS);
+    if (typeof this.noticeTimer.unref === "function") this.noticeTimer.unref();
+  }
+  stopNoticeSpinner() {
+    if (this.noticeTimer) {
+      clearInterval(this.noticeTimer);
+      this.noticeTimer = null;
     }
   }
   selectedBox() {
@@ -2490,6 +3457,46 @@ var Compositor = class {
       this.busy = false;
     }
   }
+  /**
+   * Try to consume `bytes` as an answer to the selected box's active relay
+   * prompt. Returns true when the bytes were a recognized answer key (the
+   * caller stops further dispatch); false when the bytes should flow on to
+   * the pty / other handlers.
+   *
+   * Single-byte chunks only: y/Y/Enter accept, n/N deny, Esc/Ctrl-c deny
+   * with `cancelled: true`. Multi-byte chunks starting with ESC (mouse,
+   * arrows, focus events, etc.) are passed through — exact same rule the
+   * wrapped-pty input-router uses.
+   */
+  handlePromptKey(bytes) {
+    if (bytes.length > 1 && bytes[0] === 27) return false;
+    if (bytes.length === 0) return false;
+    const b = bytes[0];
+    let answer = null;
+    let cancelled = false;
+    if (b === 121 || b === 89) answer = "y";
+    else if (b === 110 || b === 78) answer = "n";
+    else if (b === 27 || b === 3) {
+      answer = "n";
+      cancelled = true;
+    } else if (b === 13 || b === 10) {
+      const ev2 = this.activePrompts.get(this.selectedId);
+      answer = ev2?.defaultAnswer ?? "n";
+    }
+    if (answer === null) return false;
+    const ev = this.activePrompts.get(this.selectedId);
+    if (!ev) return false;
+    this.activePrompts.delete(this.selectedId);
+    this.drawChrome();
+    const url = this.deps.relayBaseUrl;
+    if (url) {
+      void postAnswer({
+        relayBaseUrl: url,
+        body: { id: ev.id, answer, ...cancelled ? { cancelled: true } : {} }
+      });
+    }
+    return true;
+  }
   handleConfirmKey(bytes) {
     const c = this.pendingConfirm;
     if (!c) return;
@@ -2596,11 +3603,11 @@ var Compositor = class {
   /** Blank the right pane and drop the diff cache (next paint is full). */
   clearRightPane() {
     const r = this.layout.right;
-    let s = SYNC_BEGIN + "\x1B[?25l";
+    let s = SYNC_BEGIN2 + "\x1B[?25l";
     for (let i = 0; i < r.h; i++) {
       s += cursorTo2(r.x, r.y + i) + "\x1B[0m" + " ".repeat(r.w);
     }
-    this.out.write(s + SYNC_END);
+    this.out.write(s + SYNC_END2);
     this.prevRows = null;
   }
   scheduleRender() {
@@ -2620,12 +3627,12 @@ var Compositor = class {
     if (this.session) {
       const { out, rows } = diffFrame(this.prevRows, this.session.snapshot(), r);
       this.prevRows = rows;
-      if (out) this.out.write(SYNC_BEGIN + out + SYNC_END);
+      if (out) this.out.write(SYNC_BEGIN2 + out + SYNC_END2);
     } else if (this.menu) {
       const lines = menuLines(this.menu.boxName, r.w, r.h);
-      let s = SYNC_BEGIN + "\x1B[?25l";
+      let s = SYNC_BEGIN2 + "\x1B[?25l";
       for (let i = 0; i < r.h; i++) s += cursorTo2(r.x, r.y + i) + "\x1B[0m" + (lines[i] ?? "");
-      this.out.write(s + SYNC_END);
+      this.out.write(s + SYNC_END2);
     } else if (this.lifecycleMenu) {
       const lines = lifecycleMenuLines(
         this.lifecycleMenu.boxName,
@@ -2634,40 +3641,52 @@ var Compositor = class {
         r.w,
         r.h
       );
-      let s = SYNC_BEGIN + "\x1B[?25l";
+      let s = SYNC_BEGIN2 + "\x1B[?25l";
       for (let i = 0; i < r.h; i++) s += cursorTo2(r.x, r.y + i) + "\x1B[0m" + (lines[i] ?? "");
-      this.out.write(s + SYNC_END);
+      this.out.write(s + SYNC_END2);
     } else if (this.createMenu) {
       const lines = createMenuLines(this.createMenu.where, r.w, r.h);
-      let s = SYNC_BEGIN + "\x1B[?25l";
+      let s = SYNC_BEGIN2 + "\x1B[?25l";
       for (let i = 0; i < r.h; i++) s += cursorTo2(r.x, r.y + i) + "\x1B[0m" + (lines[i] ?? "");
-      this.out.write(s + SYNC_END);
+      this.out.write(s + SYNC_END2);
     } else if (this.placeholder) {
-      let s = SYNC_BEGIN + "\x1B[?25l";
+      let s = SYNC_BEGIN2 + "\x1B[?25l";
       for (let i = 0; i < r.h; i++) {
         const line = (this.placeholder[i] ?? "").slice(0, r.w);
         s += cursorTo2(r.x, r.y + i) + "\x1B[0m" + line + " ".repeat(Math.max(0, r.w - line.length));
       }
-      this.out.write(s + SYNC_END);
+      this.out.write(s + SYNC_END2);
     }
   }
   drawChrome() {
     if (this.tornDown || this.layout.tooSmall) return;
     const { sidebar, sepX, statusY } = this.layout;
+    const decorate = this.activePrompts.size > 0 || this.activeNotices.size > 0;
+    const boxesWithPrompt = decorate ? this.boxes.map((b) => {
+      const pendingPrompt = this.activePrompts.has(b.id);
+      const checkpointing = this.activeNotices.has(b.id);
+      return pendingPrompt || checkpointing ? { ...b, pendingPrompt, checkpointing } : b;
+    }) : this.boxes;
     const { lines, rowOwner, headerRows } = sidebarLines(
-      this.boxes,
+      boxesWithPrompt,
       this.selectedId,
       sidebar.w,
       sidebar.h
     );
-    let s = SYNC_BEGIN + "\x1B[0m";
+    let s = SYNC_BEGIN2 + "\x1B[0m";
     for (let i = 0; i < lines.length; i++) {
-      const style = headerRows[i] ? SB_HEADER : rowOwner[i] === this.selectedId ? SB_SELECTED : SB_BODY;
+      const owner = rowOwner[i] ?? null;
+      const isSelected = owner === this.selectedId;
+      const hasPrompt = owner !== null && this.activePrompts.has(owner);
+      const ownerBox = owner !== null ? boxesWithPrompt.find((b) => b.id === owner) : void 0;
+      const isAwaiting = ownerBox?.claudeActivity === "waiting";
+      const style = headerRows[i] ? SB_HEADER : isSelected ? SB_SELECTED : hasPrompt ? SB_PROMPT : isAwaiting ? SB_AWAITING : SB_BODY;
       s += cursorTo2(0, i) + style + lines[i] + SGR_RESET;
     }
     for (let y = 0; y < sidebar.h; y++)
       s += cursorTo2(sepX, y) + SB_HEADER + (y === 0 ? "\u256E" : "\u2502") + SGR_RESET;
     let status;
+    const activePromptForSelected = this.activePrompts.get(this.selectedId);
     if (this.pendingConfirm) {
       const w = this.layout.cols;
       const txt = ` Destroy ${this.pendingConfirm.name}?  y = confirm  \xB7  any other key = cancel `.slice(0, w).padEnd(w);
@@ -2676,6 +3695,17 @@ var Compositor = class {
       const w = this.layout.cols;
       const txt = ` ${this.flashMsg} `.slice(0, w).padEnd(w);
       status = `\x1B[7m${txt}\x1B[0m`;
+    } else if (activePromptForSelected) {
+      status = renderFooter(
+        { kind: "prompt", prompt: activePromptForSelected },
+        this.layout.cols
+      );
+    } else if (this.activeNotices.has(this.selectedId)) {
+      const notice = this.activeNotices.get(this.selectedId);
+      status = renderFooter(
+        { kind: "notice", message: notice.message, frame: this.noticeFrame },
+        this.layout.cols
+      );
     } else {
       const stateLabel = this.selectedId === NEW_BOX_ID ? "create" : this.menu ? "menu" : this.session && this.activeMode === "shell" ? "shell" : void 0;
       status = statusLine(
@@ -2686,7 +3716,7 @@ var Compositor = class {
       );
     }
     s += cursorTo2(0, statusY) + status;
-    this.out.write(s + SYNC_END);
+    this.out.write(s + SYNC_END2);
   }
   scheduleResize() {
     if (this.resizeTimer) clearTimeout(this.resizeTimer);
@@ -2698,7 +3728,7 @@ var Compositor = class {
       if (this.session && !this.layout.tooSmall) {
         this.session.resize(Math.max(1, r.w), Math.max(1, r.h));
       }
-      this.out.write(SYNC_BEGIN + "\x1B[2J" + SYNC_END);
+      this.out.write(SYNC_BEGIN2 + "\x1B[2J" + SYNC_END2);
       this.drawChrome();
       this.render();
     }, RESIZE_DEBOUNCE_MS);
@@ -2711,6 +3741,11 @@ var Compositor = class {
     if (this.resizeTimer) clearTimeout(this.resizeTimer);
     if (this.flashTimer) clearTimeout(this.flashTimer);
     if (this.leaderLingerTimer) clearTimeout(this.leaderLingerTimer);
+    if (this.noticeTimer) clearInterval(this.noticeTimer);
+    for (const stream of this.promptStreams.values()) stream.close();
+    this.promptStreams.clear();
+    this.activePrompts.clear();
+    this.activeNotices.clear();
     this.parser.dispose();
     this.disposeSession();
     this.inp.off("data", this.onData);
@@ -2748,29 +3783,23 @@ function toSidebar(b) {
     project: b.projectRoot
   };
 }
-var dashboardCommand = new Command7("dashboard").description("Box list + the selected box live Agent session").argument("[box]", "initial box (default: first running box; -p restricts to the cwd project)").option("-p, --project", "only this project's boxes (default: all boxes globally)").action(async (idOrName, opts) => {
+var dashboardCommand = new Command8("dashboard").description("Box list + the selected box live Agent session").argument("[box]", "initial box (default: first running box; -p restricts to the cwd project)").option("-p, --project", "only this project's boxes (default: all boxes globally)").action(async (idOrName, opts) => {
   try {
     if (!process.stdout.isTTY || !process.stdin.isTTY) {
-      log9.error("agentbox dashboard needs an interactive terminal");
+      log10.error("agentbox dashboard needs an interactive terminal");
       process.exit(2);
     }
+    const backend = await loadPtyBackend();
     let ptySpawn;
     let termCtor;
-    try {
-      const ptyMod = await import("@homebridge/node-pty-prebuilt-multiarch");
-      const xtermMod = await import("@xterm/headless");
-      const spawn5 = ptyMod["spawn"] ?? ptyMod["default"]?.["spawn"];
-      const Terminal = xtermMod["Terminal"] ?? xtermMod["default"]?.["Terminal"];
-      if (typeof spawn5 !== "function" || typeof Terminal !== "function") {
-        throw new Error("terminal backend missing expected exports");
-      }
-      ptySpawn = spawn5;
-      termCtor = Terminal;
-    } catch {
-      log9.error(
+    if (backend) {
+      ptySpawn = backend.ptySpawn;
+      termCtor = backend.termCtor;
+    } else {
+      log10.error(
         "agentbox dashboard is unavailable here (native terminal backend failed to load)"
       );
-      log9.info("use `agentbox claude` / `agentbox claude attach` instead");
+      log10.info("use `agentbox claude` / `agentbox claude attach` instead");
       process.exit(2);
     }
     const project = await findProjectRoot(process.cwd());
@@ -2829,6 +3858,11 @@ var dashboardCommand = new Command7("dashboard").description("Box list + the sel
       await rebuildPluginNativeDeps(box.container, {
         volume: box.claudeConfigVolume
       });
+      const claudeVolume = box.claudeConfigVolume ?? SHARED_CLAUDE_VOLUME;
+      await syncClaudeCredentials(
+        { volume: claudeVolume },
+        { image: box.image, isolate: claudeVolume !== SHARED_CLAUDE_VOLUME }
+      );
       await startClaudeSession({ container: box.container, claudeArgs: [], boxName: box.name });
       const info = await claudeSessionInfo(box.container);
       return {
@@ -2945,6 +3979,10 @@ var dashboardCommand = new Command7("dashboard").description("Box list + the sel
       {
         ptySpawn,
         termCtor,
+        // Host-side loopback URL the per-box SSE subscriptions connect to.
+        // The relay binds 0.0.0.0; loopback is the admin/* path's required
+        // source. Same constant the wrapped-pty wrappers use.
+        relayBaseUrl: `http://127.0.0.1:${String(DEFAULT_RELAY_PORT)}`,
         listCandidates,
         resolveTarget,
         startClaude,
@@ -2968,48 +4006,369 @@ var dashboardCommand = new Command7("dashboard").description("Box list + the sel
 });
 
 // src/commands/destroy.ts
-import { confirm as confirm4, isCancel as isCancel4, log as log10 } from "@clack/prompts";
-import { Command as Command8 } from "commander";
-var destroyCommand = new Command8("destroy").alias("rm").description("Destroy a box and discard its upper volume").argument(
+import { confirm as confirm4, isCancel as isCancel4, log as log11 } from "@clack/prompts";
+import { Command as Command9 } from "commander";
+var destroyCommand = new Command9("destroy").alias("rm").description("Destroy a box and discard its container writable layer (where /workspace lived)").argument(
   "[box]",
   "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
 ).option("-y, --yes", "skip the confirmation prompt").option("--keep-snapshot", "don't delete the snapshot dir under ~/.agentbox/snapshots/").action(async (idOrName, opts) => {
   try {
     const box = await resolveBoxOrExit(idOrName);
     if (!opts.yes) {
-      log10.warn(`This will discard the upper volume \u2014 agent work-in-progress is lost.`);
-      log10.info(`id:        ${box.id}`);
-      log10.info(`container: ${box.container}`);
-      log10.info(`upper:     ${box.upperVolume}`);
-      if (box.snapshotDir) {
-        log10.info(`snapshot:  ${box.snapshotDir}${opts.keepSnapshot ? " (will be kept)" : ""}`);
-      }
-      const ok = await confirm4({
-        message: "Destroy this box?",
+      log11.warn(
+        "This will wipe the container writable layer \u2014 /workspace contents and agent work-in-progress are lost."
+      );
+      log11.info(`id:        ${box.id}`);
+      log11.info(`container: ${box.container}`);
+      if (box.snapshotDir) {
+        log11.info(`snapshot:  ${box.snapshotDir}${opts.keepSnapshot ? " (will be kept)" : ""}`);
+      }
+      const ok = await confirm4({
+        message: "Destroy this box?",
+        initialValue: false
+      });
+      if (isCancel4(ok) || !ok) {
+        log11.info("cancelled");
+        return;
+      }
+    }
+    const result = await destroyBox(box.id, { keepSnapshot: opts.keepSnapshot });
+    const out = [`destroyed ${result.record.container}`];
+    if (result.removedContainer) out.push("  \u2713 container removed");
+    out.push(`  \u2713 volumes removed: ${result.removedVolumes.join(", ")}`);
+    if (result.removedSnapshot) out.push(`  \u2713 snapshot removed: ${result.removedSnapshot}`);
+    else if (box.snapshotDir && opts.keepSnapshot) {
+      out.push(`  \xB7 snapshot kept: ${box.snapshotDir}`);
+    }
+    process.stdout.write(out.join("\n") + "\n");
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+
+// src/commands/download.ts
+import { confirm as confirm8, isCancel as isCancel8, log as log15 } from "@clack/prompts";
+import { Command as Command13 } from "commander";
+
+// src/commands/download-claude.ts
+import { confirm as confirm5, isCancel as isCancel5, log as log12 } from "@clack/prompts";
+import { Command as Command10 } from "commander";
+function tag(item) {
+  const noun = item.category === "plugins" ? "plugin" : item.category.replace(/s$/, "");
+  return `  ${item.category}/${item.name} (new ${noun})`;
+}
+var downloadClaudeCommand = new Command10("claude").description(
+  "Download box-installed Claude skills/plugins/agents/commands back to host ~/.claude (additive)"
+).argument(
+  "[box]",
+  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
+).option("-y, --yes", "skip the confirmation prompt").option("--dry-run", "list new items and exit; don't write").action(async (idOrName, opts) => {
+  try {
+    const box = await resolveBoxOrExit(idOrName);
+    const volume = box.claudeConfigVolume ?? resolveClaudeVolume({ isolate: false, boxId: box.id }).volume;
+    if (volume === SHARED_CLAUDE_VOLUME) {
+      log12.warn(
+        `Reading the shared ${SHARED_CLAUDE_VOLUME} volume \u2014 it aggregates Claude extensions installed in ANY box, not just ${box.name}.`
+      );
+    }
+    const image = box.image || DEFAULT_BOX_IMAGE;
+    const preview = await pullClaudeExtras({ volume }, { image, dryRun: true });
+    if (preview.newItems.length === 0 && preview.mergedRegistries.length === 0) {
+      process.stdout.write("no new Claude extensions to download into ~/.claude\n");
+      return;
+    }
+    for (const item of preview.newItems) process.stdout.write(`${tag(item)}
+`);
+    for (const reg of preview.mergedRegistries) {
+      process.stdout.write(`  plugins/${reg} (merge new entries)
+`);
+    }
+    if (opts.dryRun) {
+      process.stdout.write(
+        `
+[dry-run] ${preview.newItems.length} item(s)${preview.mergedRegistries.length > 0 ? ` + ${preview.mergedRegistries.length} registry merge(s)` : ""} would be downloaded into ~/.claude
+`
+      );
+      return;
+    }
+    if (!opts.yes) {
+      const ok = await confirm5({
+        message: `Download ${preview.newItems.length} new Claude extension(s) into ~/.claude? (existing items are never overwritten)`,
+        initialValue: false
+      });
+      if (isCancel5(ok) || !ok) {
+        log12.info("cancelled");
+        return;
+      }
+    }
+    const result = await pullClaudeExtras({ volume }, { image, dryRun: false });
+    process.stdout.write(
+      `downloaded ${result.newItems.length} extension(s)${result.mergedRegistries.length > 0 ? `, merged ${result.mergedRegistries.join(", ")}` : ""} into ~/.claude
+`
+    );
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+
+// src/commands/download-config.ts
+import { confirm as confirm6, isCancel as isCancel6, log as log13 } from "@clack/prompts";
+import { Command as Command11 } from "commander";
+function tagChange(line) {
+  const sp = line.indexOf(" ");
+  const code = sp === -1 ? line : line.slice(0, sp);
+  const path2 = sp === -1 ? "" : line.slice(sp + 1);
+  const isNew = /^>f\++$/.test(code);
+  return `  ${path2} ${isNew ? "(new)" : "(overwrites host)"}`;
+}
+var CONFIG_PATTERNS = ["agentbox.yaml"];
+var downloadConfigCommand = new Command11("config").description("Download agentbox.yaml box -> host").argument(
+  "[box]",
+  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
+).option("-y, --yes", "skip the confirmation prompt").option("--dry-run", "list matched files and exit; don't write").option("--no-refresh", "skip the box->scratch-dir rsync step").action(async (idOrName, opts) => {
+  try {
+    const box = await resolveBoxOrExit(idOrName);
+    const insp = await inspectBox(box.id);
+    if (insp.state === "paused") {
+      log13.info("box is paused; unpausing");
+      await unpauseBox(box.id);
+    } else if (insp.state === "stopped") {
+      log13.info("box is stopped; starting");
+      await startBox(box.id);
+    } else if (insp.state === "missing") {
+      throw new Error(`box ${box.name} has no container; was it destroyed?`);
+    }
+    log13.info(`agentbox.yaml bypasses gitignore and copies directly into ${box.workspacePath}`);
+    const preview = await pullToHost(box, {
+      dryRun: true,
+      respectGitignore: false,
+      envPatterns: CONFIG_PATTERNS,
+      noRefresh: !opts.refresh
+    });
+    if (preview.changes.length === 0) {
+      process.stdout.write(`no config file to download into ${box.workspacePath}
+`);
+      return;
+    }
+    for (const line of preview.changes) process.stdout.write(`${tagChange(line)}
+`);
+    if (opts.dryRun) {
+      process.stdout.write(
+        `
+[dry-run] ${preview.changes.length} config file(s) would change in ${box.workspacePath}
+`
+      );
+      return;
+    }
+    if (!opts.yes) {
+      const ok = await confirm6({
+        message: `Download ${preview.changes.length} config file(s) into ${box.workspacePath}? (existing files will be overwritten)`,
+        initialValue: false
+      });
+      if (isCancel6(ok) || !ok) {
+        log13.info("cancelled");
+        return;
+      }
+    }
+    const result = await pullToHost(box, {
+      dryRun: false,
+      respectGitignore: false,
+      envPatterns: CONFIG_PATTERNS,
+      // The dry-run pass above already refreshed (or intentionally skipped)
+      // the scratch dir — don't rsync box->scratch a second time.
+      noRefresh: true
+    });
+    process.stdout.write(
+      `downloaded ${result.changes.length} config file(s) into ${result.hostPath}
+`
+    );
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+
+// src/commands/download-env.ts
+import { confirm as confirm7, isCancel as isCancel7, log as log14 } from "@clack/prompts";
+import { Command as Command12 } from "commander";
+function tagChange2(line) {
+  const sp = line.indexOf(" ");
+  const code = sp === -1 ? line : line.slice(0, sp);
+  const path2 = sp === -1 ? "" : line.slice(sp + 1);
+  const isNew = /^>f\++$/.test(code);
+  return `  ${path2} ${isNew ? "(new)" : "(overwrites host)"}`;
+}
+var downloadEnvCommand = new Command12("env").description(
+  "Download gitignored env/config files (.env*, .envrc, secrets.toml, agentbox.yaml, ...) box -> host"
+).argument(
+  "[box]",
+  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
+).option("-y, --yes", "skip the confirmation prompt").option("--dry-run", "list matched files and exit; don't write").option(
+  "--pattern <glob>",
+  "extra basename glob to match (repeatable, adds to defaults)",
+  (v, acc) => [...acc, v],
+  []
+).option("--no-refresh", "skip the box->scratch-dir rsync step").action(async (idOrName, opts) => {
+  try {
+    const box = await resolveBoxOrExit(idOrName);
+    const insp = await inspectBox(box.id);
+    if (insp.state === "paused") {
+      log14.info("box is paused; unpausing");
+      await unpauseBox(box.id);
+    } else if (insp.state === "stopped") {
+      log14.info("box is stopped; starting");
+      await startBox(box.id);
+    } else if (insp.state === "missing") {
+      throw new Error(`box ${box.name} has no container; was it destroyed?`);
+    }
+    log14.info(
+      `env/config files bypass gitignore and copy directly into ${box.workspacePath}`
+    );
+    const patterns = [...DEFAULT_ENV_PATTERNS, ...opts.pattern];
+    const preview = await pullToHost(box, {
+      dryRun: true,
+      respectGitignore: false,
+      envPatterns: patterns,
+      noRefresh: !opts.refresh
+    });
+    if (preview.changes.length === 0) {
+      process.stdout.write(`no env/config files to download into ${box.workspacePath}
+`);
+      return;
+    }
+    for (const line of preview.changes) process.stdout.write(`${tagChange2(line)}
+`);
+    if (opts.dryRun) {
+      process.stdout.write(
+        `
+[dry-run] ${preview.changes.length} env/config file(s) would change in ${box.workspacePath}
+`
+      );
+      return;
+    }
+    if (!opts.yes) {
+      const ok = await confirm7({
+        message: `Download ${preview.changes.length} env/config file(s) into ${box.workspacePath}? (existing files will be overwritten)`,
+        initialValue: false
+      });
+      if (isCancel7(ok) || !ok) {
+        log14.info("cancelled");
+        return;
+      }
+    }
+    const result = await pullToHost(box, {
+      dryRun: false,
+      respectGitignore: false,
+      envPatterns: patterns,
+      // The dry-run pass above already refreshed (or intentionally skipped)
+      // the scratch dir — don't rsync box->scratch a second time.
+      noRefresh: true
+    });
+    process.stdout.write(
+      `downloaded ${result.changes.length} env/config file(s) into ${result.hostPath}
+`
+    );
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+
+// src/commands/download.ts
+var downloadCommand = new Command13("download").enablePositionalOptions().description("Download a box's /workspace back into your host workspace dir (gitignore-aware)").argument(
+  "[box]",
+  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
+).option("-y, --yes", "skip the confirmation prompt").option("--dry-run", "print the change list and exit; don't write").option(
+  "--no-respect-gitignore",
+  "disable git ls-files mode; use --exclude=node_modules,.git instead"
+).option(
+  "--include-node-modules",
+  "do not exclude node_modules in fallback mode (no effect in gitignore mode)"
+).option("--no-refresh", "skip the box->scratch-dir rsync step (use whatever's already there)").option(
+  "--with-env",
+  "also download env/config files (.env*, .envrc, secrets.toml, agentbox.yaml, ...) ignoring gitignore"
+).option(
+  "--pattern <glob>",
+  "extra env basename glob; only effective with --with-env (repeatable)",
+  (v, acc) => [...acc, v],
+  []
+).action(async (idOrName, opts) => {
+  try {
+    const box = await resolveBoxOrExit(idOrName);
+    const insp = await inspectBox(box.id);
+    if (insp.state === "paused") {
+      log15.info("box is paused; unpausing");
+      await unpauseBox(box.id);
+    } else if (insp.state === "stopped") {
+      log15.info("box is stopped; starting");
+      await startBox(box.id);
+    } else if (insp.state === "missing") {
+      throw new Error(`box ${box.name} has no container; was it destroyed?`);
+    }
+    const rootWorktree = box.gitWorktrees?.find((w) => w.kind === "root");
+    if (rootWorktree) {
+      log15.warn(
+        `This box has been committing to branch \`${rootWorktree.branch}\` in a separate worktree.
+For a git-aware merge instead of a file copy, run from your checkout:
+  git merge ${rootWorktree.branch}
+Continuing with rsync into ${box.workspacePath}`
+      );
+    }
+    const envPatterns = opts.withEnv ? [...DEFAULT_ENV_PATTERNS, ...opts.pattern] : void 0;
+    const preview = await pullToHost(box, {
+      dryRun: true,
+      respectGitignore: opts.respectGitignore,
+      includeNodeModules: opts.includeNodeModules,
+      envPatterns,
+      noRefresh: !opts.refresh
+    });
+    if (preview.changes.length === 0) {
+      process.stdout.write(`no changes to download into ${box.workspacePath}
+`);
+      return;
+    }
+    if (opts.dryRun) {
+      for (const line of preview.changes) process.stdout.write(`${line}
+`);
+      process.stdout.write(
+        `
+[dry-run] ${preview.changes.length} file(s) would change in ${box.workspacePath}
+`
+      );
+      return;
+    }
+    if (!opts.yes) {
+      const ok = await confirm8({
+        message: `Download ${preview.changes.length} changed file(s)${opts.withEnv ? " (incl. env/config)" : ""} into ${box.workspacePath}?`,
         initialValue: false
       });
-      if (isCancel4(ok) || !ok) {
-        log10.info("cancelled");
+      if (isCancel8(ok) || !ok) {
+        log15.info("cancelled");
         return;
       }
     }
-    const result = await destroyBox(box.id, { keepSnapshot: opts.keepSnapshot });
-    const out = [`destroyed ${result.record.container}`];
-    if (result.removedContainer) out.push("  \u2713 container removed");
-    out.push(`  \u2713 volumes removed: ${result.removedVolumes.join(", ")}`);
-    if (result.removedSnapshot) out.push(`  \u2713 snapshot removed: ${result.removedSnapshot}`);
-    else if (box.snapshotDir && opts.keepSnapshot) {
-      out.push(`  \xB7 snapshot kept: ${box.snapshotDir}`);
-    }
-    process.stdout.write(out.join("\n") + "\n");
+    const result = await pullToHost(box, {
+      dryRun: false,
+      respectGitignore: opts.respectGitignore,
+      includeNodeModules: opts.includeNodeModules,
+      envPatterns,
+      // The dry-run pass above already refreshed (or intentionally skipped)
+      // the scratch dir — don't rsync box->scratch a second time.
+      noRefresh: true
+    });
+    process.stdout.write(
+      `updated ${result.changes.length} file(s) in ${result.hostPath}${result.usedGitignore ? "" : " (exclude-list mode)"}
+`
+    );
   } catch (err) {
     handleLifecycleError(err);
   }
 });
+downloadCommand.addCommand(downloadEnvCommand);
+downloadCommand.addCommand(downloadClaudeCommand);
+downloadCommand.addCommand(downloadConfigCommand);
 
 // src/commands/list.ts
-import { log as log11 } from "@clack/prompts";
-import { Command as Command9 } from "commander";
+import { log as log16 } from "@clack/prompts";
+import { Command as Command14 } from "commander";
 import { pathToFileURL } from "url";
 
 // src/hyperlink.ts
@@ -3094,11 +4453,11 @@ function urlCell(box, stream) {
     width: parts.reduce((a, p) => a + p.width, 0) + sep.length * (parts.length - 1)
   };
 }
-function workspaceCell(path, target, stream) {
-  const display = middleTruncate(path, target);
+function workspaceCell(path2, target, stream) {
+  const display = middleTruncate(path2, target);
   let url;
   try {
-    url = pathToFileURL(path).href;
+    url = pathToFileURL(path2).href;
   } catch {
     return { text: display, width: display.length };
   }
@@ -3136,579 +4495,332 @@ function renderTable(boxes, stream) {
   };
   return all.map(
     (row2) => row2.map((cell, i) => padCell(cell ?? plain(""), i)).join("  ").trimEnd()
-  ).join("\n");
-}
-async function scopedBoxes(all) {
-  const boxes = await listBoxes();
-  if (all) return { boxes, projectRoot: "", scoped: false };
-  const { root } = await findProjectRoot(process.cwd());
-  return { boxes: boxes.filter((b) => b.projectRoot === root), projectRoot: root, scoped: true };
-}
-async function buildListText(all) {
-  const { boxes, projectRoot, scoped: scoped2 } = await scopedBoxes(all);
-  if (boxes.length === 0) {
-    if (scoped2) {
-      return `no boxes in this project (${projectRoot}) \u2014 run \`agentbox create\`, or \`agentbox list --all\` to see all`;
-    }
-    return "no boxes \u2014 run `agentbox create` to make one";
-  }
-  return renderTable(boxes, process.stdout);
-}
-var listCommand2 = withWatchOptions(
-  new Command9("list").alias("ls").description("List agent boxes in the current project (-a for all)").option("-j, --json", "machine-readable JSON output").option("-a, --all", "include boxes from all projects")
-).action(async (opts) => {
-  if (opts.json && opts.watch) {
-    log11.error("cannot combine --json with --watch");
-    process.exit(2);
-  }
-  const all = opts.all ?? false;
-  if (opts.watch) {
-    await watchRender(() => buildListText(all), opts.interval);
-    return;
-  }
-  if (opts.json) {
-    const { boxes } = await scopedBoxes(all);
-    process.stdout.write(JSON.stringify(boxes, null, 2) + "\n");
-    return;
-  }
-  process.stdout.write(await buildListText(all) + "\n");
-});
-
-// src/commands/logs.ts
-import { log as log12 } from "@clack/prompts";
-import { Command as Command10 } from "commander";
-import { spawn as spawn3 } from "child_process";
-var logsCommand = new Command10("logs").description("Print recent log lines from a box service; -f to stream").argument(
-  "[box]",
-  "box ref (optional when cwd has exactly 1 box): project index, id, id prefix, name, or container"
-).argument("[service]", "service name from agentbox.yaml").option("-n, --tail <n>", "how many recent lines to print first", "200").option("-f, --follow", "keep the connection open and stream new lines").action(async (boxArg, serviceArg, opts) => {
-  try {
-    let idOrName;
-    let service;
-    if (serviceArg !== void 0) {
-      idOrName = boxArg;
-      service = serviceArg;
-    } else {
-      idOrName = void 0;
-      service = boxArg;
-    }
-    if (!service) {
-      log12.error("missing <service> argument");
-      log12.info("usage: agentbox logs [box] <service> [-n N] [-f]");
-      process.exit(2);
-    }
-    const box = await resolveBoxOrExit(idOrName);
-    const tail = String(Number.parseInt(opts.tail, 10) || 200);
-    const args = ["agentbox-ctl", "logs", service, "--tail", tail];
-    if (opts.follow) args.push("--follow");
-    if (!opts.follow) {
-      const proc = await execInBox(box.container, args, { user: "vscode" });
-      if (proc.exitCode !== 0) {
-        log12.error(`agentbox-ctl logs failed: ${proc.stderr || proc.stdout}`);
-        process.exit(1);
-      }
-      process.stdout.write(proc.stdout);
-      if (!proc.stdout.endsWith("\n")) process.stdout.write("\n");
-      return;
-    }
-    const child = spawn3("docker", ["exec", "--user", "vscode", box.container, ...args], {
-      stdio: ["ignore", "inherit", "inherit"]
-    });
-    child.on("exit", (code) => process.exit(code ?? 0));
-  } catch (err) {
-    handleLifecycleError(err);
-  }
-});
-
-// src/commands/open.ts
-import { log as log13 } from "@clack/prompts";
-import { Command as Command11 } from "commander";
-
-// src/commands/path.ts
-async function runPath(box, opts) {
-  try {
-    const layer = opts.upper ? "upper" : "merged";
-    const { record, paths } = await getBoxHostPaths(box.id);
-    if (opts.refresh) {
-      const refreshed = await refreshExport(record, {
-        layer,
-        includeNodeModules: opts.includeNodeModules
-      });
-      process.stdout.write(`${refreshed.hostPath}
-`);
-      return;
-    }
-    const path = layer === "upper" ? paths.upperLiveOnHost ?? paths.upperExport : paths.mergedExport;
-    process.stdout.write(`${path}
-`);
-  } catch (err) {
-    handleLifecycleError(err);
-  }
-}
-
-// src/commands/open.ts
-var openCommand = new Command11("open").description("Open a box's merged workspace in Finder (snapshot of the agent's view)").argument(
-  "[box]",
-  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
-).option("--upper", "open just the writes layer (live on OrbStack, snapshot on Docker Desktop)").option("--no-refresh", "skip the rsync; open whatever's already on disk").option(
-  "--include-node-modules",
-  "include /workspace/node_modules in the merged export (off by default)"
-).option("--path", "print the host workspace path instead of launching Finder").option("--print", "alias of --path").action(async (idOrName, opts) => {
-  try {
-    const box = await resolveBoxOrExit(idOrName);
-    if (opts.path || opts.print) {
-      await runPath(box, {
-        upper: opts.upper,
-        refresh: opts.refresh,
-        // print refreshes by default; --no-refresh skips
-        includeNodeModules: opts.includeNodeModules
-      });
-      return;
-    }
-    const layer = opts.upper ? "upper" : "merged";
-    const result = await openBoxInFinder(box.id, {
-      layer,
-      includeNodeModules: opts.includeNodeModules,
-      noRefresh: !opts.refresh,
-      noOpen: false
-    });
-    const liveNote = !result.copied ? " (live)" : result.usedFallback ? " (tar fallback)" : "";
-    process.stdout.write(`opened ${result.hostPath}${liveNote}
-`);
-    if (opts.upper && result.engine !== "orbstack" && result.copied) {
-      log13.info(
-        "Tip: live upper-layer browsing requires OrbStack. Re-run `agentbox open --upper` to refresh."
-      );
-    }
-  } catch (err) {
-    handleLifecycleError(err);
-  }
-});
-
-// src/commands/pause.ts
-import { Command as Command12 } from "commander";
-var pauseCommand = new Command12("pause").description("Freeze a box (docker pause \u2014 0 CPU, RAM stays mapped)").argument(
-  "[box]",
-  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
-).action(async (idOrName) => {
-  try {
-    const box = await resolveBoxOrExit(idOrName);
-    const record = await pauseBox(box.id);
-    process.stdout.write(`paused ${record.container}
-`);
-  } catch (err) {
-    handleLifecycleError(err);
-  }
-});
-
-// src/commands/prune.ts
-import { confirm as confirm5, isCancel as isCancel5, log as log14 } from "@clack/prompts";
-import { Command as Command13 } from "commander";
-function totalRemovals(r, projectConfigs) {
-  return r.removedRecords.length + r.removedContainers.length + r.removedVolumes.length + r.removedSnapshotDirs.length + r.removedBoxDirs.length + projectConfigs.length;
-}
-function summary(r, projectConfigs) {
-  const lines = [];
-  if (r.removedRecords.length > 0) {
-    lines.push(
-      `  state records (${String(r.removedRecords.length)}): ${r.removedRecords.join(", ")}`
-    );
-  }
-  if (r.removedContainers.length > 0) {
-    lines.push(
-      `  containers    (${String(r.removedContainers.length)}): ${r.removedContainers.join(", ")}`
-    );
-  }
-  if (r.removedVolumes.length > 0) {
-    lines.push(
-      `  volumes       (${String(r.removedVolumes.length)}): ${r.removedVolumes.join(", ")}`
-    );
-  }
-  if (r.removedSnapshotDirs.length > 0) {
-    lines.push(
-      `  snapshot dirs (${String(r.removedSnapshotDirs.length)}): ${r.removedSnapshotDirs.join(", ")}`
-    );
-  }
-  if (r.removedBoxDirs.length > 0) {
-    lines.push(
-      `  box dirs      (${String(r.removedBoxDirs.length)}): ${r.removedBoxDirs.join(", ")}`
-    );
-  }
-  if (projectConfigs.length > 0) {
-    lines.push(
-      `  project configs (${String(projectConfigs.length)}): ${projectConfigs.join(", ")}`
-    );
-  }
-  return lines.length > 0 ? lines.join("\n") : "  (nothing to remove)";
+  ).join("\n");
 }
-async function liveProjectRoots() {
-  try {
-    const boxes = await listBoxes();
-    return boxes.map((b) => b.projectRoot).filter((p) => typeof p === "string");
-  } catch {
-    return [];
-  }
+async function scopedBoxes(all) {
+  const boxes = await listBoxes();
+  if (all) return { boxes, projectRoot: "", scoped: false };
+  const { root } = await findProjectRoot(process.cwd());
+  return { boxes: boxes.filter((b) => b.projectRoot === root), projectRoot: root, scoped: true };
 }
-var pruneCommand = new Command13("prune").description("Clean up orphan state.json records (and with --all, orphan docker resources)").option("--dry-run", "show what would be removed, don't change anything").option(
-  "--all",
-  "also remove orphan agentbox-* containers, volumes, snapshot dirs, and orphan per-project config dirs"
-).option("-y, --yes", "skip the confirmation prompt").action(async (opts) => {
-  try {
-    const dryRun = opts.dryRun ?? false;
-    const protectedPaths = opts.all ? await liveProjectRoots() : [];
-    const preview = await pruneBoxes({ dryRun: true, all: opts.all });
-    const previewProjects = opts.all ? (await pruneOrphanProjectConfigs({ dryRun: true, protectedPaths })).removed.map(
-      (r) => r.originalPath
-    ) : [];
-    if (totalRemovals(preview, previewProjects) === 0) {
-      process.stdout.write("nothing to prune\n");
-      return;
-    }
-    log14.info(`would remove:
-${summary(preview, previewProjects)}`);
-    if (dryRun) return;
-    if (!opts.yes) {
-      const ok = await confirm5({ message: "Proceed with prune?", initialValue: true });
-      if (isCancel5(ok) || !ok) {
-        log14.info("cancelled");
-        return;
-      }
+async function buildListText(all) {
+  const { boxes, projectRoot, scoped: scoped2 } = await scopedBoxes(all);
+  if (boxes.length === 0) {
+    if (scoped2) {
+      return `no boxes in this project (${projectRoot}) \u2014 run \`agentbox create\`, or \`agentbox list --all\` to see all`;
     }
-    const result = await pruneBoxes({ all: opts.all });
-    const removedProjects = opts.all ? (await pruneOrphanProjectConfigs({ protectedPaths })).removed.map((r) => r.originalPath) : [];
-    process.stdout.write(`pruned:
-${summary(result, removedProjects)}
-`);
-  } catch (err) {
-    handleLifecycleError(err);
+    return "no boxes \u2014 run `agentbox create` to make one";
   }
-});
-
-// src/commands/pull.ts
-import { confirm as confirm9, isCancel as isCancel9, log as log18 } from "@clack/prompts";
-import { Command as Command17 } from "commander";
-
-// src/commands/pull-claude.ts
-import { confirm as confirm6, isCancel as isCancel6, log as log15 } from "@clack/prompts";
-import { Command as Command14 } from "commander";
-function tag(item) {
-  const noun = item.category === "plugins" ? "plugin" : item.category.replace(/s$/, "");
-  return `  ${item.category}/${item.name} (new ${noun})`;
+  const table = renderTable(boxes, process.stdout);
+  if (!scoped2) return table;
+  const name = projectRoot.split("/").filter(Boolean).pop() ?? projectRoot;
+  return `Project: ${name}
+${table}`;
 }
-var pullClaudeCommand = new Command14("claude").description(
-  "Pull box-installed Claude skills/plugins/agents/commands back to host ~/.claude (additive)"
-).argument(
-  "[box]",
-  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
-).option("-y, --yes", "skip the confirmation prompt").option("--dry-run", "list new items and exit; don't write").action(async (idOrName, opts) => {
-  try {
-    const box = await resolveBoxOrExit(idOrName);
-    const volume = box.claudeConfigVolume ?? resolveClaudeVolume({ isolate: false, boxId: box.id }).volume;
-    if (volume === SHARED_CLAUDE_VOLUME) {
-      log15.warn(
-        `Reading the shared ${SHARED_CLAUDE_VOLUME} volume \u2014 it aggregates Claude extensions installed in ANY box, not just ${box.name}.`
-      );
-    }
-    const image = box.image || DEFAULT_BOX_IMAGE;
-    const preview = await pullClaudeExtras({ volume }, { image, dryRun: true });
-    if (preview.newItems.length === 0 && preview.mergedRegistries.length === 0) {
-      process.stdout.write("no new Claude extensions to pull into ~/.claude\n");
-      return;
-    }
-    for (const item of preview.newItems) process.stdout.write(`${tag(item)}
-`);
-    for (const reg of preview.mergedRegistries) {
-      process.stdout.write(`  plugins/${reg} (merge new entries)
-`);
-    }
-    if (opts.dryRun) {
-      process.stdout.write(
-        `
-[dry-run] ${preview.newItems.length} item(s)${preview.mergedRegistries.length > 0 ? ` + ${preview.mergedRegistries.length} registry merge(s)` : ""} would be pulled into ~/.claude
-`
-      );
-      return;
-    }
-    if (!opts.yes) {
-      const ok = await confirm6({
-        message: `Pull ${preview.newItems.length} new Claude extension(s) into ~/.claude? (existing items are never overwritten)`,
-        initialValue: false
-      });
-      if (isCancel6(ok) || !ok) {
-        log15.info("cancelled");
-        return;
-      }
-    }
-    const result = await pullClaudeExtras({ volume }, { image, dryRun: false });
-    process.stdout.write(
-      `pulled ${result.newItems.length} extension(s)${result.mergedRegistries.length > 0 ? `, merged ${result.mergedRegistries.join(", ")}` : ""} into ~/.claude
-`
-    );
-  } catch (err) {
-    handleLifecycleError(err);
+var listCommand2 = withWatchOptions(
+  new Command14("list").alias("ls").description("List agent boxes in the current project (-a for all)").option("-j, --json", "machine-readable JSON output").option("-a, --all", "include boxes from all projects")
+).action(async (opts) => {
+  if (opts.json && opts.watch) {
+    log16.error("cannot combine --json with --watch");
+    process.exit(2);
+  }
+  const all = opts.all ?? false;
+  if (opts.watch) {
+    await watchRender(() => buildListText(all), opts.interval);
+    return;
+  }
+  if (opts.json) {
+    const { boxes } = await scopedBoxes(all);
+    process.stdout.write(JSON.stringify(boxes, null, 2) + "\n");
+    return;
   }
+  process.stdout.write(await buildListText(all) + "\n");
 });
 
-// src/commands/pull-config.ts
-import { confirm as confirm7, isCancel as isCancel7, log as log16 } from "@clack/prompts";
+// src/commands/logs.ts
+import { log as log17 } from "@clack/prompts";
 import { Command as Command15 } from "commander";
-function tagChange(line) {
-  const sp = line.indexOf(" ");
-  const code = sp === -1 ? line : line.slice(0, sp);
-  const path = sp === -1 ? "" : line.slice(sp + 1);
-  const isNew = /^>f\++$/.test(code);
-  return `  ${path} ${isNew ? "(new)" : "(overwrites host)"}`;
-}
-var CONFIG_PATTERNS = ["agentbox.yaml"];
-var pullConfigCommand = new Command15("config").description("Pull agentbox.yaml box -> host").argument(
+import { spawn as spawn3 } from "child_process";
+var logsCommand = new Command15("logs").description("Print recent log lines from a box service; -f to stream").argument(
   "[box]",
-  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
-).option("-y, --yes", "skip the confirmation prompt").option("--dry-run", "list matched files and exit; don't write").option("--no-refresh", "skip the box->scratch-dir rsync step").action(async (idOrName, opts) => {
+  "box ref (optional when cwd has exactly 1 box): project index, id, id prefix, name, or container"
+).argument("[service]", "service name from agentbox.yaml").option("-n, --tail <n>", "how many recent lines to print first", "200").option("-f, --follow", "keep the connection open and stream new lines").action(async (boxArg, serviceArg, opts) => {
   try {
-    const box = await resolveBoxOrExit(idOrName);
-    const insp = await inspectBox(box.id);
-    if (insp.state === "paused") {
-      log16.info("box is paused; unpausing");
-      await unpauseBox(box.id);
-    } else if (insp.state === "stopped") {
-      log16.info("box is stopped; starting (remounting overlay)");
-      await startBox(box.id);
-    } else if (insp.state === "missing") {
-      throw new Error(`box ${box.name} has no container; was it destroyed?`);
-    }
-    log16.info(`agentbox.yaml bypasses gitignore and copies directly into ${box.workspacePath}`);
-    const preview = await pullToHost(box, {
-      dryRun: true,
-      respectGitignore: false,
-      envPatterns: CONFIG_PATTERNS,
-      noRefresh: !opts.refresh
-    });
-    if (preview.changes.length === 0) {
-      process.stdout.write(`no config file to pull into ${box.workspacePath}
-`);
-      return;
+    let idOrName;
+    let service;
+    if (serviceArg !== void 0) {
+      idOrName = boxArg;
+      service = serviceArg;
+    } else {
+      idOrName = void 0;
+      service = boxArg;
     }
-    for (const line of preview.changes) process.stdout.write(`${tagChange(line)}
-`);
-    if (opts.dryRun) {
-      process.stdout.write(
-        `
-[dry-run] ${preview.changes.length} config file(s) would change in ${box.workspacePath}
-`
-      );
-      return;
+    if (!service) {
+      log17.error("missing <service> argument");
+      log17.info("usage: agentbox logs [box] <service> [-n N] [-f]");
+      process.exit(2);
     }
-    if (!opts.yes) {
-      const ok = await confirm7({
-        message: `Pull ${preview.changes.length} config file(s) into ${box.workspacePath}? (existing files will be overwritten)`,
-        initialValue: false
-      });
-      if (isCancel7(ok) || !ok) {
-        log16.info("cancelled");
-        return;
+    const box = await resolveBoxOrExit(idOrName);
+    const tail = String(Number.parseInt(opts.tail, 10) || 200);
+    const args = ["agentbox-ctl", "logs", service, "--tail", tail];
+    if (opts.follow) args.push("--follow");
+    if (!opts.follow) {
+      const proc = await execInBox(box.container, args, { user: "vscode" });
+      if (proc.exitCode !== 0) {
+        log17.error(`agentbox-ctl logs failed: ${proc.stderr || proc.stdout}`);
+        process.exit(1);
       }
+      process.stdout.write(proc.stdout);
+      if (!proc.stdout.endsWith("\n")) process.stdout.write("\n");
+      return;
     }
-    const result = await pullToHost(box, {
-      dryRun: false,
-      respectGitignore: false,
-      envPatterns: CONFIG_PATTERNS,
-      // The dry-run pass above already refreshed (or intentionally skipped)
-      // the scratch dir — don't rsync box->scratch a second time.
-      noRefresh: true
+    const child = spawn3("docker", ["exec", "--user", "vscode", box.container, ...args], {
+      stdio: ["ignore", "inherit", "inherit"]
     });
-    process.stdout.write(
-      `pulled ${result.changes.length} config file(s) into ${result.hostPath}
-`
-    );
+    child.on("exit", (code) => process.exit(code ?? 0));
   } catch (err) {
     handleLifecycleError(err);
   }
 });
 
-// src/commands/pull-env.ts
-import { confirm as confirm8, isCancel as isCancel8, log as log17 } from "@clack/prompts";
+// src/commands/open.ts
 import { Command as Command16 } from "commander";
-function tagChange2(line) {
-  const sp = line.indexOf(" ");
-  const code = sp === -1 ? line : line.slice(0, sp);
-  const path = sp === -1 ? "" : line.slice(sp + 1);
-  const isNew = /^>f\++$/.test(code);
-  return `  ${path} ${isNew ? "(new)" : "(overwrites host)"}`;
-}
-var pullEnvCommand = new Command16("env").description(
-  "Pull gitignored env/config files (.env*, .envrc, secrets.toml, agentbox.yaml, ...) box -> host"
-).argument(
-  "[box]",
-  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
-).option("-y, --yes", "skip the confirmation prompt").option("--dry-run", "list matched files and exit; don't write").option(
-  "--pattern <glob>",
-  "extra basename glob to match (repeatable, adds to defaults)",
-  (v, acc) => [...acc, v],
-  []
-).option("--no-refresh", "skip the box->scratch-dir rsync step").action(async (idOrName, opts) => {
+
+// src/commands/path.ts
+async function runPath(box, opts) {
   try {
-    const box = await resolveBoxOrExit(idOrName);
-    const insp = await inspectBox(box.id);
-    if (insp.state === "paused") {
-      log17.info("box is paused; unpausing");
-      await unpauseBox(box.id);
-    } else if (insp.state === "stopped") {
-      log17.info("box is stopped; starting (remounting overlay)");
-      await startBox(box.id);
-    } else if (insp.state === "missing") {
-      throw new Error(`box ${box.name} has no container; was it destroyed?`);
-    }
-    log17.info(
-      `env/config files bypass gitignore and copy directly into ${box.workspacePath}`
-    );
-    const patterns = [...DEFAULT_ENV_PATTERNS, ...opts.pattern];
-    const preview = await pullToHost(box, {
-      dryRun: true,
-      respectGitignore: false,
-      envPatterns: patterns,
-      noRefresh: !opts.refresh
-    });
-    if (preview.changes.length === 0) {
-      process.stdout.write(`no env/config files to pull into ${box.workspacePath}
-`);
-      return;
-    }
-    for (const line of preview.changes) process.stdout.write(`${tagChange2(line)}
+    const { record, paths } = await getBoxHostPaths(box.id);
+    if (opts.refresh) {
+      const refreshed = await refreshExport(record, {
+        includeNodeModules: opts.includeNodeModules
+      });
+      process.stdout.write(`${refreshed.hostPath}
 `);
-    if (opts.dryRun) {
-      process.stdout.write(
-        `
-[dry-run] ${preview.changes.length} env/config file(s) would change in ${box.workspacePath}
-`
-      );
       return;
     }
-    if (!opts.yes) {
-      const ok = await confirm8({
-        message: `Pull ${preview.changes.length} env/config file(s) into ${box.workspacePath}? (existing files will be overwritten)`,
-        initialValue: false
-      });
-      if (isCancel8(ok) || !ok) {
-        log17.info("cancelled");
-        return;
-      }
-    }
-    const result = await pullToHost(box, {
-      dryRun: false,
-      respectGitignore: false,
-      envPatterns: patterns,
-      // The dry-run pass above already refreshed (or intentionally skipped)
-      // the scratch dir — don't rsync box->scratch a second time.
-      noRefresh: true
-    });
-    process.stdout.write(
-      `pulled ${result.changes.length} env/config file(s) into ${result.hostPath}
-`
-    );
+    process.stdout.write(`${paths.mergedExport}
+`);
   } catch (err) {
     handleLifecycleError(err);
   }
-});
+}
 
-// src/commands/pull.ts
-var pullCommand = new Command17("pull").enablePositionalOptions().description("Pull a box's /workspace back into your host workspace dir (gitignore-aware)").argument(
+// src/commands/open.ts
+var openCommand = new Command16("open").description("Open a box's /workspace in Finder (rsync'd snapshot of the agent's view)").argument(
   "[box]",
   "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
-).option("-y, --yes", "skip the confirmation prompt").option("--dry-run", "print the change list and exit; don't write").option(
-  "--no-respect-gitignore",
-  "disable git ls-files mode; use --exclude=node_modules,.git instead"
-).option(
+).option("--no-refresh", "skip the rsync; open whatever's already on disk").option(
   "--include-node-modules",
-  "do not exclude node_modules in fallback mode (no effect in gitignore mode)"
-).option("--no-refresh", "skip the box->scratch-dir rsync step (use whatever's already there)").option(
-  "--with-env",
-  "also pull env/config files (.env*, .envrc, secrets.toml, agentbox.yaml, ...) ignoring gitignore"
-).option(
-  "--pattern <glob>",
-  "extra env basename glob; only effective with --with-env (repeatable)",
-  (v, acc) => [...acc, v],
-  []
-).action(async (idOrName, opts) => {
+  "include /workspace/node_modules in the merged export (off by default)"
+).option("--path", "print the host workspace path instead of launching Finder").option("--print", "alias of --path").action(async (idOrName, opts) => {
   try {
     const box = await resolveBoxOrExit(idOrName);
-    const insp = await inspectBox(box.id);
-    if (insp.state === "paused") {
-      log18.info("box is paused; unpausing");
-      await unpauseBox(box.id);
-    } else if (insp.state === "stopped") {
-      log18.info("box is stopped; starting (remounting overlay)");
-      await startBox(box.id);
-    } else if (insp.state === "missing") {
-      throw new Error(`box ${box.name} has no container; was it destroyed?`);
-    }
-    const rootWorktree = box.gitWorktrees?.find((w) => w.kind === "root");
-    if (rootWorktree) {
-      log18.warn(
-        `This box has been committing to branch \`${rootWorktree.branch}\` in a separate worktree.
-For a git-aware merge instead of a file copy, run from your checkout:
-  git merge ${rootWorktree.branch}
-Continuing with rsync into ${box.workspacePath}`
-      );
+    if (opts.path || opts.print) {
+      await runPath(box, {
+        refresh: opts.refresh,
+        // print refreshes by default; --no-refresh skips
+        includeNodeModules: opts.includeNodeModules
+      });
+      return;
     }
-    const envPatterns = opts.withEnv ? [...DEFAULT_ENV_PATTERNS, ...opts.pattern] : void 0;
-    const preview = await pullToHost(box, {
-      dryRun: true,
-      respectGitignore: opts.respectGitignore,
+    const result = await openBoxInFinder(box.id, {
       includeNodeModules: opts.includeNodeModules,
-      envPatterns,
-      noRefresh: !opts.refresh
+      noRefresh: !opts.refresh,
+      noOpen: false
     });
-    if (preview.changes.length === 0) {
-      process.stdout.write(`no changes to pull into ${box.workspacePath}
+    const liveNote = !result.copied ? " (live)" : result.usedFallback ? " (tar fallback)" : "";
+    process.stdout.write(`opened ${result.hostPath}${liveNote}
 `);
-      return;
-    }
-    if (opts.dryRun) {
-      for (const line of preview.changes) process.stdout.write(`${line}
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+
+// src/commands/pause.ts
+import { Command as Command17 } from "commander";
+var pauseCommand = new Command17("pause").description("Freeze a box (docker pause \u2014 0 CPU, RAM stays mapped)").argument(
+  "[box]",
+  "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
+).action(async (idOrName) => {
+  try {
+    const box = await resolveBoxOrExit(idOrName);
+    const record = await pauseBox(box.id);
+    process.stdout.write(`paused ${record.container}
 `);
-      process.stdout.write(
-        `
-[dry-run] ${preview.changes.length} file(s) would change in ${box.workspacePath}
-`
-      );
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+
+// src/commands/prune.ts
+import { confirm as confirm9, isCancel as isCancel9, log as log18 } from "@clack/prompts";
+import { Command as Command18 } from "commander";
+function totalRemovals(r, projectConfigs) {
+  return r.removedRecords.length + r.removedContainers.length + r.removedVolumes.length + r.removedSnapshotDirs.length + r.removedBoxDirs.length + projectConfigs.length;
+}
+function summary(r, projectConfigs) {
+  const lines = [];
+  if (r.removedRecords.length > 0) {
+    lines.push(
+      `  state records (${String(r.removedRecords.length)}): ${r.removedRecords.join(", ")}`
+    );
+  }
+  if (r.removedContainers.length > 0) {
+    lines.push(
+      `  containers    (${String(r.removedContainers.length)}): ${r.removedContainers.join(", ")}`
+    );
+  }
+  if (r.removedVolumes.length > 0) {
+    lines.push(
+      `  volumes       (${String(r.removedVolumes.length)}): ${r.removedVolumes.join(", ")}`
+    );
+  }
+  if (r.removedSnapshotDirs.length > 0) {
+    lines.push(
+      `  snapshot dirs (${String(r.removedSnapshotDirs.length)}): ${r.removedSnapshotDirs.join(", ")}`
+    );
+  }
+  if (r.removedBoxDirs.length > 0) {
+    lines.push(
+      `  box dirs      (${String(r.removedBoxDirs.length)}): ${r.removedBoxDirs.join(", ")}`
+    );
+  }
+  if (projectConfigs.length > 0) {
+    lines.push(
+      `  project configs (${String(projectConfigs.length)}): ${projectConfigs.join(", ")}`
+    );
+  }
+  return lines.length > 0 ? lines.join("\n") : "  (nothing to remove)";
+}
+async function liveProjectRoots() {
+  try {
+    const boxes = await listBoxes();
+    return boxes.map((b) => b.projectRoot).filter((p) => typeof p === "string");
+  } catch {
+    return [];
+  }
+}
+var pruneCommand = new Command18("prune").description("Clean up orphan state.json records (and with --all, orphan docker resources)").option("--dry-run", "show what would be removed, don't change anything").option(
+  "--all",
+  "also remove orphan agentbox-* containers, volumes, snapshot dirs, and orphan per-project config dirs"
+).option("-y, --yes", "skip the confirmation prompt").action(async (opts) => {
+  try {
+    const dryRun = opts.dryRun ?? false;
+    const protectedPaths = opts.all ? await liveProjectRoots() : [];
+    const preview = await pruneBoxes({ dryRun: true, all: opts.all });
+    const previewProjects = opts.all ? (await pruneOrphanProjectConfigs({ dryRun: true, protectedPaths })).removed.map(
+      (r) => r.originalPath
+    ) : [];
+    if (totalRemovals(preview, previewProjects) === 0) {
+      process.stdout.write("nothing to prune\n");
       return;
     }
+    log18.info(`would remove:
+${summary(preview, previewProjects)}`);
+    if (dryRun) return;
     if (!opts.yes) {
-      const ok = await confirm9({
-        message: `Pull ${preview.changes.length} changed file(s)${opts.withEnv ? " (incl. env/config)" : ""} into ${box.workspacePath}?`,
-        initialValue: false
-      });
+      const ok = await confirm9({ message: "Proceed with prune?", initialValue: true });
       if (isCancel9(ok) || !ok) {
         log18.info("cancelled");
         return;
       }
     }
-    const result = await pullToHost(box, {
-      dryRun: false,
-      respectGitignore: opts.respectGitignore,
-      includeNodeModules: opts.includeNodeModules,
-      envPatterns,
-      // The dry-run pass above already refreshed (or intentionally skipped)
-      // the scratch dir — don't rsync box->scratch a second time.
-      noRefresh: true
-    });
-    process.stdout.write(
-      `updated ${result.changes.length} file(s) in ${result.hostPath}${result.usedGitignore ? "" : " (exclude-list mode)"}
-`
+    const result = await pruneBoxes({ all: opts.all });
+    const removedProjects = opts.all ? (await pruneOrphanProjectConfigs({ protectedPaths })).removed.map((r) => r.originalPath) : [];
+    process.stdout.write(`pruned:
+${summary(result, removedProjects)}
+`);
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+
+// src/commands/relay.ts
+import { log as log19, spinner as spinner3 } from "@clack/prompts";
+import { Command as Command19 } from "commander";
+function renderStatus(s) {
+  if (s.running && s.health) {
+    return [
+      "relay: running",
+      `  pid:    ${s.pid === null ? "?" : String(s.pid)}`,
+      `  port:   ${String(s.port)}`,
+      `  url:    ${s.endpoint.hostUrl}`,
+      `  boxes:  ${String(s.health.boxes)}`,
+      `  events: ${String(s.health.events)}`,
+      `  log:    ${s.logFile}`
+    ].join("\n");
+  }
+  if (s.pidAlive) {
+    return [
+      `relay: not responding (pid ${String(s.pid)} alive but /healthz silent)`,
+      `  log:    ${s.logFile}`
+    ].join("\n");
+  }
+  return ["relay: not running", `  log:    ${s.logFile}`].join("\n");
+}
+var statusSub = new Command19("status").description("Show whether the host relay is running, with pid / port / box count").option("--json", "emit RelayStatus as JSON").action(async (opts) => {
+  try {
+    const s = await getRelayStatus();
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(s, null, 2) + "\n");
+      return;
+    }
+    process.stdout.write(renderStatus(s) + "\n");
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+var stopSub = new Command19("stop").description("Stop the host relay process (idempotent)").action(async () => {
+  try {
+    const s = spinner3();
+    s.start("stopping relay");
+    const result = await stopRelay();
+    s.stop(
+      result.stopped ? `stopped relay (pid ${String(result.pid)})` : "relay was not running"
+    );
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+var startSub = new Command19("start").description("Start the host relay if not already running (idempotent)").action(async () => {
+  try {
+    const s = spinner3();
+    s.start("starting relay");
+    const ep = await ensureRelay();
+    s.stop(`relay running on ${ep.hostUrl}`);
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+var restartSub = new Command19("restart").description("Stop then start the host relay").action(async () => {
+  try {
+    const s = spinner3();
+    s.start("stopping relay");
+    const stopped = await stopRelay();
+    s.stop(
+      stopped.stopped ? `stopped relay (pid ${String(stopped.pid)})` : "relay was not running"
     );
+    const s2 = spinner3();
+    s2.start("starting relay");
+    try {
+      const ep = await ensureRelay();
+      s2.stop(`relay running on ${ep.hostUrl}`);
+    } catch (err) {
+      s2.stop("relay start failed");
+      log19.warn(err instanceof Error ? err.message : String(err));
+      throw err;
+    }
   } catch (err) {
     handleLifecycleError(err);
   }
 });
-pullCommand.addCommand(pullEnvCommand);
-pullCommand.addCommand(pullClaudeCommand);
-pullCommand.addCommand(pullConfigCommand);
+var relayCommand = new Command19("relay").description("Manage the host relay process (status / stop / start / restart)").addCommand(statusSub, { isDefault: true }).addCommand(stopSub).addCommand(startSub).addCommand(restartSub);
 
 // src/commands/screen.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { log as log19 } from "@clack/prompts";
-import { Command as Command18 } from "commander";
-var screenCommand = new Command18("screen").description("Open a box's VNC (noVNC) viewer in the browser (auto-unpause/start)").argument(
+import { log as log20 } from "@clack/prompts";
+import { Command as Command20 } from "commander";
+var screenCommand = new Command20("screen").description("Open a box's VNC (noVNC) viewer in the browser (auto-unpause/start)").argument(
   "[box]",
   "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
 ).option("--print", "print the URL to stdout instead of launching the browser").option("--loopback", "use the 127.0.0.1 URL instead of the OrbStack .orb.local URL").action(async (idOrName, opts) => {
@@ -3719,17 +4831,27 @@ var screenCommand = new Command18("screen").description("Open a box's VNC (noVNC
     }
     const insp = await inspectBox(box.id);
     if (insp.state === "paused") {
-      log19.info("box is paused; unpausing");
+      log20.info("box is paused; unpausing");
       await unpauseBox(box.id);
     } else if (insp.state === "stopped") {
-      log19.info("box is stopped; starting (remounting overlay)");
+      log20.info("box is stopped; starting");
       await startBox(box.id);
     } else if (insp.state === "missing") {
       throw new Error(`box ${box.name} has no container; was it destroyed?`);
     }
-    const br = await ensureBoxBrowser(box.container);
-    if (br.up && !br.alreadyRunning) log19.info("started in-box browser");
-    else if (!br.up) log19.warn(`could not start in-box browser: ${br.reason ?? "unknown"}`);
+    const persisted = await readBoxStatus(box);
+    const exposePort = persisted?.services.find((s) => s.expose)?.expose?.port;
+    const inBoxUrl = exposePort !== void 0 ? `http://localhost:${String(exposePort)}` : "about:blank";
+    const br = await ensureBoxBrowser(box.container, void 0, inBoxUrl);
+    if (br.up && !br.alreadyRunning) {
+      log20.info(
+        exposePort !== void 0 ? `opened ${inBoxUrl} in the in-box browser (visible in the VNC view)` : "started in-box browser"
+      );
+    } else if (br.alreadyRunning) {
+      log20.info("in-box browser already running; left it untouched");
+    } else {
+      log20.warn(`could not start in-box browser: ${br.reason ?? "unknown"}`);
+    }
     const engine = await detectEngine();
     const urls = buildVncUrls(box, engine);
     const url = opts.loopback ? urls.loopbackUrl : urls.orbUrl ?? urls.loopbackUrl;
@@ -3749,21 +4871,6 @@ var screenCommand = new Command18("screen").description("Open a box's VNC (noVNC
     }
     process.stdout.write(`opened ${url}
 `);
-    try {
-      const { record } = await getBoxHostPaths(box.id);
-      const persisted = await readBoxStatus(box.id);
-      const eps = await getBoxEndpoints(record, engine, persisted);
-      const webEp = eps.endpoints.find((e) => e.kind === "web");
-      if (webEp?.reachable && webEp.url) {
-        const webUrl = engine === "orbstack" && !opts.loopback ? `http://${record.container}.orb.local` : webEp.url;
-        const w = spawnSync5("open", [webUrl], { stdio: "inherit" });
-        if (w.status === 0) process.stdout.write(`also opened ${webUrl}
-`);
-        else log19.warn(`could not open web app (${webUrl})`);
-      }
-    } catch (e) {
-      log19.warn(`could not open web app: ${e instanceof Error ? e.message : String(e)}`);
-    }
   } catch (err) {
     handleLifecycleError(err);
   }
@@ -3771,15 +4878,16 @@ var screenCommand = new Command18("screen").description("Open a box's VNC (noVNC
 
 // src/commands/shell.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { log as log20 } from "@clack/prompts";
-import { Command as Command19 } from "commander";
+import { log as log21 } from "@clack/prompts";
+import { Command as Command21 } from "commander";
+var RELAY_HOST_URL3 = `http://127.0.0.1:${String(DEFAULT_RELAY_PORT)}`;
 function buildShellCliOverrides(opts) {
   const shell = {};
   if (opts.user !== void 0) shell.user = opts.user;
   if (opts.login === false) shell.login = false;
   return Object.keys(shell).length > 0 ? { shell } : {};
 }
-var shellCommand = new Command19("shell").description("Open an interactive bash shell in a box (auto-unpause/start)").argument(
+var shellCommand = new Command21("shell").description("Open an interactive bash shell in a box (auto-unpause/start)").argument(
   "[box]",
   "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
 ).argument(
@@ -3796,10 +4904,10 @@ var shellCommand = new Command19("shell").description("Open an interactive bash
     const login = cfg.effective.shell.login;
     const insp = await inspectBox(box.id);
     if (insp.state === "paused") {
-      log20.info("box is paused; unpausing");
+      log21.info("box is paused; unpausing");
       await unpauseBox(box.id);
     } else if (insp.state === "stopped") {
-      log20.info("box is stopped; starting (remounting overlay)");
+      log21.info("box is stopped; starting");
       await startBox(box.id);
     } else if (insp.state === "missing") {
       throw new Error(`box ${box.name} has no container; was it destroyed?`);
@@ -3808,59 +4916,57 @@ var shellCommand = new Command19("shell").description("Open an interactive bash
     const bashArgs = [];
     if (login) bashArgs.push("-l");
     if (effectiveCmd.length > 0) bashArgs.push("-c", effectiveCmd.join(" "));
-    const ttyFlag = process.stdout.isTTY && process.stdin.isTTY ? "-it" : "-i";
-    const child = spawnSync6(
-      "docker",
-      [
-        "exec",
-        ttyFlag,
-        "-e",
-        `TERM=${term2}`,
-        "--user",
-        user,
-        box.container,
-        "bash",
-        ...bashArgs
-      ],
-      { stdio: "inherit" }
-    );
-    process.exit(child.status ?? 0);
+    const isInteractive = process.stdout.isTTY && process.stdin.isTTY;
+    const ttyFlag = isInteractive ? "-it" : "-i";
+    const dockerArgv = [
+      "exec",
+      ttyFlag,
+      "-e",
+      `TERM=${term2}`,
+      "--user",
+      user,
+      box.container,
+      "bash",
+      ...bashArgs
+    ];
+    if (!isInteractive || effectiveCmd.length > 0) {
+      const child = spawnSync6("docker", dockerArgv, { stdio: "inherit" });
+      process.exit(child.status ?? 0);
+    }
+    const code = await runWrappedAttach({
+      container: box.container,
+      dockerArgv,
+      relayBaseUrl: RELAY_HOST_URL3,
+      boxId: box.id,
+      boxName: box.name,
+      projectIndex: box.projectIndex,
+      mode: "shell"
+    });
+    process.exit(code);
   } catch (err) {
     handleLifecycleError(err);
   }
 });
 
 // src/commands/start.ts
-import { Command as Command20 } from "commander";
-var startCommand = new Command20("start").description("Start a stopped box (docker start + re-mount the FUSE overlay)").argument(
+import { Command as Command22 } from "commander";
+var startCommand = new Command22("start").description("Start a stopped box (docker start + relaunch ctl/dockerd/vnc daemons)").argument(
   "[box]",
   "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
 ).action(async (idOrName) => {
   try {
     const box = await resolveBoxOrExit(idOrName);
-    const { record, overlayChecks } = await startBox(box.id);
+    const { record } = await startBox(box.id);
     process.stdout.write(`started ${record.container}
 `);
-    const failed = overlayChecks.filter((c) => !c.ok);
-    if (failed.length > 0) {
-      for (const c of failed) {
-        process.stderr.write(`  \u2717 ${c.name}: ${c.detail}
-`);
-      }
-      process.exit(1);
-    }
-    for (const c of overlayChecks) {
-      process.stdout.write(`  \u2713 ${c.name}
-`);
-    }
   } catch (err) {
     handleLifecycleError(err);
   }
 });
 
 // src/commands/status.ts
-import { log as log22 } from "@clack/prompts";
-import { Command as Command21 } from "commander";
+import { log as log23 } from "@clack/prompts";
+import { Command as Command23 } from "commander";
 
 // src/endpoints-render.ts
 function renderEndpointLines(endpoints, stream) {
@@ -3923,27 +5029,24 @@ function fmtAgo(iso) {
 }
 
 // src/commands/inspect.ts
-import { log as log21 } from "@clack/prompts";
+import { log as log22 } from "@clack/prompts";
 function fmtLimit(n, unit) {
   return n && n > 0 ? `${String(n)}${unit}` : "unlimited";
 }
 async function renderText(i) {
   const lim = i.record.resourceLimits;
+  const ckptName = i.record.checkpointSource?.ref;
   const projectRoot = i.record.projectRoot ?? i.record.workspacePath;
-  const ckptBytes = await projectCheckpointVolumeBytes(projectRoot);
-  const upperHost = i.hostPaths.upperLiveOnHost ? `${i.hostPaths.upperLiveOnHost}  (live)` : `${i.hostPaths.upperExport}  (run \`agentbox open --upper\` to refresh)`;
+  const ckptBytes = ckptName ? await projectCheckpointImageBytes(projectRoot, ckptName) : null;
   const lines = [
     `id            ${i.record.id}`,
     `name          ${i.record.name}`,
     `container     ${i.record.container}`,
     `image         ${i.record.image}`,
     `state         ${i.state}`,
-    `overlay       ${i.overlayMounted ? "mounted at /workspace" : "not mounted"}`,
-    `workspace     ${i.record.workspacePath}`,
+    `workspace     ${i.record.workspacePath}  (container fs at /workspace)`,
     `project       ${i.record.projectRoot ?? "(unset \u2014 pre-feature box)"}`,
     `n             ${typeof i.record.projectIndex === "number" ? String(i.record.projectIndex) : "(none)"}`,
-    `lower         ${i.record.lowerPath}`,
-    `upper volume  ${i.upperVolume.name}${i.upperVolume.mountpoint ? `  (${i.upperVolume.mountpoint})` : ""}`,
     `claude config ${i.record.claudeConfigVolume ?? "(none)"}`,
     `claude session ${renderClaudeSession(i)}`,
     `claude activity ${renderClaudeActivity(i)}`,
@@ -3956,15 +5059,20 @@ async function renderText(i) {
     `cpu limit     ${fmtLimit(lim?.cpus, "")}`,
     `pids limit    ${fmtLimit(lim?.pidsLimit, "")}`,
     `disk limit    ${lim?.disk ? `${lim.disk} (best-effort; no-op on overlay2/macOS)` : "unlimited"}`,
-    `snapshot dir  ${i.record.snapshotDir ?? "(none \u2014 live workspace mount)"}`,
+    `snapshot dir  ${i.record.snapshotDir ?? "(none)"}`,
     `snapshot size ${fmtBytes(i.snapshotSizeBytes)}`,
-    `checkpoint vol ${ckptBytes === null ? "(none)" : fmtBytes(ckptBytes)}`,
+    `checkpoint    ${renderCheckpoint(i, ckptBytes)}`,
     `host export   ${i.hostPaths.mergedExport}  (run \`agentbox open\` to refresh)`,
-    `upper host    ${upperHost}`,
     `created       ${i.record.createdAt}`
   ];
   return lines.join("\n");
 }
+function renderCheckpoint(i, sizeBytes) {
+  const src = i.record.checkpointSource;
+  if (!src || !i.record.checkpointImage) return "(none)";
+  const sizePart = sizeBytes !== null ? ` ${fmtBytes(sizeBytes)}` : "";
+  return `${src.ref} (${src.type}, chain ${src.chain.length}) \u2192 ${i.record.checkpointImage}${sizePart}`;
+}
 function renderClaudeSession(i) {
   if (i.claudeSession === null) return "(n/a \u2014 box not running)";
   if (!i.claudeSession.running) return `not running ("${i.claudeSession.sessionName}")`;
@@ -3988,7 +5096,7 @@ function renderEndpoints(i) {
 async function runInspect(box, opts) {
   try {
     if (opts.json && opts.watch) {
-      log21.error("cannot combine --json with --watch");
+      log22.error("cannot combine --json with --watch");
       process.exit(2);
     }
     if (opts.watch) {
@@ -4008,14 +5116,14 @@ async function runInspect(box, opts) {
 
 // src/commands/status.ts
 var statusCommand = withWatchOptions(
-  new Command21("status").description("Show service + task status from a box's agentbox-ctl daemon").argument(
+  new Command23("status").description("Show service + task status from a box's agentbox-ctl daemon").argument(
     "[box]",
     "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
   ).option("-j, --json", "machine-readable JSON output").option("--inspect", "show detailed box info (volumes, limits, paths) instead of service/task status")
 ).action(async (idOrName, opts) => {
   try {
     if (opts.json && opts.watch) {
-      log22.error("cannot combine --json with --watch");
+      log23.error("cannot combine --json with --watch");
       process.exit(2);
     }
     const box = await resolveBoxOrExit(idOrName);
@@ -4170,8 +5278,8 @@ function renderPersisted2(s, state) {
 }
 
 // src/commands/stop.ts
-import { Command as Command22 } from "commander";
-var stopCommand = new Command22("stop").description("Stop a box (docker stop; preserves upper + node_modules volumes)").argument(
+import { Command as Command24 } from "commander";
+var stopCommand = new Command24("stop").description("Stop a box (docker stop; preserves upper + node_modules volumes)").argument(
   "[box]",
   "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
 ).action(async (idOrName) => {
@@ -4189,7 +5297,7 @@ restart with: agentbox start ${record.name}
 });
 
 // src/commands/top.ts
-import { Command as Command23 } from "commander";
+import { Command as Command25 } from "commander";
 var COLS = ["BOX", "STATE", "CPU%", "MEM USAGE / LIMIT", "MEM%", "PIDS", "DISK", "NET I/O"];
 function row(name, state, s) {
   const mem = `${fmtBytes(s.memUsedBytes)} / ${fmtBytes(s.memLimitBytes)}`;
@@ -4228,7 +5336,7 @@ async function snapshot(idOrName, opts) {
 async function renderProjectFooters() {
   const parts = [];
   const [ckpt, home] = await Promise.all([
-    allCheckpointVolumesBytes(),
+    allCheckpointImagesBytes(),
     agentboxHomeBytes()
   ]);
   if (home !== null) parts.push(`~/.agentbox: ${fmtBytes(home)}`);
@@ -4237,7 +5345,7 @@ async function renderProjectFooters() {
 
 SYSTEM: ${parts.join(" - ")}` : "";
 }
-var topCommand = new Command23("top").description("Live resource monitor (cpu/mem/pids/disk) for a box, the project, or every box").argument(
+var topCommand = new Command25("top").description("Live resource monitor (cpu/mem/pids/disk) for a box, the project, or every box").argument(
   "[box]",
   "box ref (default: every box on the host; --project narrows to the cwd's project)"
 ).option("-p, --project", "show only boxes in the cwd's project").option("--once", "print a single snapshot instead of watching").option("-j, --json", "machine-readable JSON (implies --once)").option("--interval <seconds>", "refresh interval", "2").action(async (idOrName, opts) => {
@@ -4270,8 +5378,8 @@ var topCommand = new Command23("top").description("Live resource monitor (cpu/me
 });
 
 // src/commands/unpause.ts
-import { Command as Command24 } from "commander";
-var unpauseCommand = new Command24("unpause").description("Resume a paused box (docker unpause \u2014 sub-second)").argument(
+import { Command as Command26 } from "commander";
+var unpauseCommand = new Command26("unpause").description("Resume a paused box (docker unpause \u2014 sub-second)").argument(
   "[box]",
   "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
 ).action(async (idOrName) => {
@@ -4287,8 +5395,8 @@ var unpauseCommand = new Command24("unpause").description("Resume a paused box (
 
 // src/commands/update.ts
 import { spawn as spawn4 } from "child_process";
-import { confirm as confirm10, intro as intro3, isCancel as isCancel10, log as log23, outro as outro3, spinner as spinner3 } from "@clack/prompts";
-import { Command as Command25 } from "commander";
+import { confirm as confirm10, intro as intro3, isCancel as isCancel10, log as log24, outro as outro3, spinner as spinner4 } from "@clack/prompts";
+import { Command as Command27 } from "commander";
 
 // src/exec-method.ts
 function detectExecutionMethod(input) {
@@ -4332,7 +5440,7 @@ function runInherit(cmd, args) {
     child.on("close", (code) => resolveP(code ?? 0));
   });
 }
-var updateCommand = new Command25("self-update").description(
+var updateCommand = new Command27("self-update").description(
   "Update agentbox: self-update via npm/pnpm (unless run via npx), wipe the box image so it rebuilds, and reload the relay"
 ).option("-y, --yes", "skip the confirmation prompt").option("--dry-run", "show what would happen, don't change anything").option("--skip-self", "skip the package self-update; only refresh the image + relay").action(async (opts) => {
   try {
@@ -4342,7 +5450,7 @@ var updateCommand = new Command25("self-update").description(
     });
     intro3("agentbox self-update");
     const selfStep = opts.skipSelf ? "self-update: skipped (--skip-self)" : describeSelfUpdate(method);
-    log23.info(
+    log24.info(
       [
         "plan:",
         `  ${selfStep}`,
@@ -4357,52 +5465,52 @@ var updateCommand = new Command25("self-update").description(
     if (!opts.yes) {
       const ok = await confirm10({ message: "Proceed with update?", initialValue: true });
       if (isCancel10(ok) || !ok) {
-        log23.info("cancelled");
+        log24.info("cancelled");
         return;
       }
     }
     let selfUpdated = false;
     if (opts.skipSelf) {
-      log23.info("skipping self-update (--skip-self)");
+      log24.info("skipping self-update (--skip-self)");
     } else {
       const cmd = selfUpdateCommand(method);
       if (cmd === null) {
-        log23.info(describeSelfUpdate(method));
+        log24.info(describeSelfUpdate(method));
       } else {
-        log23.info(`running: ${cmd.cmd} ${cmd.args.join(" ")}`);
+        log24.info(`running: ${cmd.cmd} ${cmd.args.join(" ")}`);
         const code = await runInherit(cmd.cmd, cmd.args);
         if (code !== 0) {
           throw new Error(`${cmd.cmd} exited with code ${String(code)}`);
         }
         selfUpdated = true;
-        log23.success(`updated ${PKG} via ${cmd.cmd}`);
+        log24.success(`updated ${PKG} via ${cmd.cmd}`);
       }
     }
-    const s = spinner3();
+    const s = spinner4();
     s.start(`removing image ${DEFAULT_BOX_IMAGE}`);
     const removed = await removeImage(DEFAULT_BOX_IMAGE);
     s.stop(
       removed ? `removed image ${DEFAULT_BOX_IMAGE} (rebuilds on next create/claude)` : `image ${DEFAULT_BOX_IMAGE} not present (nothing to remove)`
     );
-    const sr = spinner3();
+    const sr = spinner4();
     sr.start("stopping relay");
     const stop = await stopRelay();
     sr.stop(
       stop.stopped ? `stopped relay (pid ${String(stop.pid)})` : "relay was not running"
     );
     if (selfUpdated) {
-      log23.info(
+      log24.info(
         "relay will restart automatically (with the updated build) on your next `agentbox create` / `agentbox claude`"
       );
     } else {
-      const sr2 = spinner3();
+      const sr2 = spinner4();
       sr2.start("restarting relay");
       try {
         const ep = await ensureRelay();
         sr2.stop(`relay back up on ${ep.hostUrl}`);
       } catch (err) {
         sr2.stop("relay restart failed");
-        log23.warn(
+        log24.warn(
           `${err instanceof Error ? err.message : String(err)} \u2014 it will retry on the next box command`
         );
       }
@@ -4414,9 +5522,9 @@ var updateCommand = new Command25("self-update").description(
 });
 
 // src/commands/wait.ts
-import { log as log24 } from "@clack/prompts";
-import { Command as Command26 } from "commander";
-var waitCommand = new Command26("wait").description("Block until the box reports all autostart units ready").argument(
+import { log as log25 } from "@clack/prompts";
+import { Command as Command28 } from "commander";
+var waitCommand = new Command28("wait").description("Block until the box reports all autostart units ready").argument(
   "[box]",
   "box ref: project index, id, id prefix, name, or container (default: the only box in this project)"
 ).option("--timeout <ms>", "overall timeout in milliseconds", "120000").option("--units <names...>", "restrict to the named units").option("-j, --json", "machine-readable JSON output").action(async (idOrName, opts) => {
@@ -4431,7 +5539,7 @@ var waitCommand = new Command26("wait").description("Block until the box reports
     try {
       parsed = JSON.parse(proc.stdout);
     } catch {
-      log24.error(`agentbox-ctl wait-ready failed: ${proc.stderr || proc.stdout}`);
+      log25.error(`agentbox-ctl wait-ready failed: ${proc.stderr || proc.stdout}`);
       process.exit(1);
     }
     if (opts.json) {
@@ -4451,7 +5559,8 @@ var waitCommand = new Command26("wait").description("Block until the box reports
 });
 
 // src/index.ts
-var program = new Command27();
+process.env.DOCKER_CLI_HINTS ??= "false";
+var program = new Command29();
 program.name("agentbox").description("Launch coding agents in isolated sandboxes").version("0.0.0");
 program.enablePositionalOptions();
 program.addCommand(createCommand);
@@ -4462,7 +5571,8 @@ program.addCommand(listCommand2);
 program.addCommand(openCommand);
 program.addCommand(browserCommand);
 program.addCommand(screenCommand);
-program.addCommand(pullCommand);
+program.addCommand(downloadCommand);
+program.addCommand(cpCommand);
 program.addCommand(statusCommand);
 program.addCommand(topCommand);
 program.addCommand(dashboardCommand);
@@ -4476,6 +5586,7 @@ program.addCommand(destroyCommand);
 program.addCommand(pruneCommand);
 program.addCommand(checkpointCommand);
 program.addCommand(configCommand);
+program.addCommand(relayCommand);
 program.addCommand(updateCommand);
 program.configureHelp({ visibleCommands: () => [] });
 program.addHelpText("after", () => "\n" + buildGroupedHelp(program));