@madarco/agentbox 0.14.0 → 0.15.0

package/dist/index.js

@@ -8,6 +8,7 @@ import {
   clipboardCaptureAvailable,
   cloudAgentAttach,
   cloudAgentStartDetached,
+  cmuxBinary,
   createMenuLines,
   detectHostTerminal,
   getProvider,
@@ -26,10 +27,11 @@ import {
   runWrappedAttach,
   setTerminalTitle,
   sidebarLines,
+  spawnInNewTerminal,
   statusLine,
   stripTitleGlyph,
   subscribePrompts
-} from "./chunk-BYCLD6D6.js";
+} from "./chunk-43Q5GWP6.js";
 import {
   daytonaBackend,
   ensureDaytonaCredentials,
@@ -57,14 +59,14 @@ import {
   readPreparedState as readPreparedState2,
   readVercelCredStatus,
   secretsPath as secretsPath3
-} from "./chunk-VATTS2MR.js";
+} from "./chunk-72CJTXN6.js";
 import {
   ensureE2bCredentials,
   maskKey as maskKey4,
   readE2bCredStatus,
   readPreparedState as readPreparedState3,
   secretsPath as secretsPath4
-} from "./chunk-LDMYHWUS.js";
+} from "./chunk-MCOU6CZS.js";
 import {
   agentSpecsForCloud,
   currentCloudBaseFingerprint,
@@ -74,10 +76,11 @@ import {
   probeCloudCheckpoint,
   resolveCloudCheckpoint,
   seedAgentVolumesIfFresh
-} from "./chunk-TBSIJVSN.js";
+} from "./chunk-E7CHS7ZR.js";
 import {
   AmbiguousBoxError,
   BOX_STATUS_EVENT,
+  BUILT_IN_DEFAULTS,
   BoxNotFoundError,
   CODEX_CREDENTIALS_BACKUP_FILE,
   ClaudeSessionError,
@@ -229,7 +232,7 @@ import {
   waitForTmuxPaneContent,
   warmUpClaudeCredentials,
   writeJob
-} from "./chunk-TCS5HXJX.js";
+} from "./chunk-MLMFNN4T.js";
 import {
   DEFAULT_BOX_IMAGE,
   STATE_DIR,
@@ -246,8 +249,8 @@ import {
 import "./chunk-G3H2L3O2.js";
 
 // src/version.ts
-var AGENTBOX_VERSION = true ? "0.14.0" : "0.0.0-dev";
-var AGENTBOX_COMMIT = true ? "38f96cffd" : "dev";
+var AGENTBOX_VERSION = true ? "0.15.0" : "0.0.0-dev";
+var AGENTBOX_COMMIT = true ? "dfe136d17" : "dev";
 
 // src/index.ts
 import { Command as Command48 } from "commander";
@@ -430,6 +433,178 @@ function derivedAgentState(claude) {
   return claude.state;
 }
 
+// src/lib/agent-answer.ts
+import { createHash } from "crypto";
+var TUI_ID_PREFIX = "tui";
+function inTuiKind(claude) {
+  if (claude.state === "working" || claude.state === "compacting") return null;
+  if (claude.plan !== void 0) return "plan";
+  if (claude.question !== void 0) return "question";
+  if (claude.state === "waiting") return "permission";
+  return null;
+}
+function digestForBlock(claude, kind) {
+  let material;
+  if (kind === "plan") {
+    material = `plan|${claude.plan?.capturedAt ?? ""}|${claude.plan?.plan ?? ""}`;
+  } else if (kind === "question") {
+    material = `question|${claude.question?.capturedAt ?? ""}|${JSON.stringify(claude.question?.questions ?? [])}`;
+  } else {
+    material = `permission|${claude.updatedAt ?? ""}`;
+  }
+  return createHash("sha256").update(material).digest("hex").slice(0, 12);
+}
+function mintTuiId(boxId, claude) {
+  const kind = inTuiKind(claude);
+  if (kind === null) return null;
+  return { id: `${TUI_ID_PREFIX}:${boxId}:${kind}:${digestForBlock(claude, kind)}`, kind };
+}
+function parseTuiId(id) {
+  const parts = id.split(":");
+  if (parts.length !== 4 || parts[0] !== TUI_ID_PREFIX) return null;
+  const [, boxId, kind, digest] = parts;
+  if (!boxId || !digest) return null;
+  if (kind !== "plan" && kind !== "question" && kind !== "permission") return null;
+  return { boxId, kind, digest };
+}
+function isTuiId(id) {
+  return id.startsWith(`${TUI_ID_PREFIX}:`);
+}
+var OPTION_ENTER_DELAY_MS = 150;
+function answerKeystrokes(_agent, _kind, decision) {
+  if (decision.deny === true) {
+    return [{ type: "key", value: "Escape" }];
+  }
+  if (decision.option !== void 0) {
+    return [
+      { type: "literal", value: String(decision.option) },
+      { type: "delay", ms: OPTION_ENTER_DELAY_MS },
+      { type: "key", value: "Enter" }
+    ];
+  }
+  return [{ type: "key", value: "Enter" }];
+}
+function resolveQuestionOption(claude, raw) {
+  const options = claude.question?.questions?.[0]?.options ?? [];
+  const asNum = Number.parseInt(raw, 10);
+  if (Number.isFinite(asNum) && String(asNum) === raw.trim()) {
+    return asNum >= 1 && asNum <= options.length ? asNum : null;
+  }
+  const needle = raw.trim().toLowerCase();
+  const exact = options.findIndex((o) => o.label.toLowerCase() === needle);
+  if (exact !== -1) return exact + 1;
+  const prefix = options.findIndex((o) => o.label.toLowerCase().startsWith(needle));
+  return prefix !== -1 ? prefix + 1 : null;
+}
+
+// src/lib/drive/tmux.ts
+var TMUX_USER = "vscode";
+async function captureSession(provider, box, session, opts = {}) {
+  const argv2 = ["tmux", "capture-pane", opts.ansi ? "-pe" : "-p", "-t", session];
+  if (opts.rows) {
+    argv2.push("-S", String(opts.rows.from), "-E", String(opts.rows.to));
+  }
+  const res = await provider.exec(box, argv2, { user: TMUX_USER });
+  if (res.exitCode !== 0) {
+    throw new Error(failure("capture-pane", session, res.stderr || res.stdout));
+  }
+  return res.stdout.replace(/\n$/, "");
+}
+async function paneInfo(provider, box, session) {
+  const fmt = "#{pane_width},#{pane_height},#{cursor_x},#{cursor_y}";
+  const res = await provider.exec(box, ["tmux", "display-message", "-p", "-t", session, fmt], {
+    user: TMUX_USER
+  });
+  if (res.exitCode !== 0) {
+    throw new Error(failure("display-message", session, res.stderr || res.stdout));
+  }
+  const m = /^(\d+),(\d+),(\d+),(\d+)/.exec(res.stdout.trim());
+  if (!m) throw new Error(`tmux display-message returned unexpected output: ${res.stdout}`);
+  return {
+    cols: Number(m[1]),
+    rows: Number(m[2]),
+    cursor: { x: Number(m[3]), y: Number(m[4]) }
+  };
+}
+async function sendLiteral(provider, box, session, literal) {
+  if (literal.length === 0) return;
+  const res = await provider.exec(box, ["tmux", "send-keys", "-t", session, "-l", "--", literal], {
+    user: TMUX_USER
+  });
+  if (res.exitCode !== 0) {
+    throw new Error(failure("send-keys -l", session, res.stderr || res.stdout));
+  }
+}
+async function sendKey(provider, box, session, key) {
+  const res = await provider.exec(box, ["tmux", "send-keys", "-t", session, key], {
+    user: TMUX_USER
+  });
+  if (res.exitCode !== 0) {
+    throw new Error(failure("send-keys", session, res.stderr || res.stdout));
+  }
+}
+async function resizeWindow(provider, box, session, cols, rows) {
+  const res = await provider.exec(
+    box,
+    ["tmux", "resize-window", "-t", session, "-x", String(cols), "-y", String(rows)],
+    { user: TMUX_USER }
+  );
+  if (res.exitCode !== 0) {
+    throw new Error(failure("resize-window", session, res.stderr || res.stdout));
+  }
+}
+async function listSessions(provider, box) {
+  const res = await provider.exec(
+    box,
+    ["tmux", "list-sessions", "-F", "#{session_name}"],
+    { user: TMUX_USER }
+  );
+  if (res.exitCode !== 0) return [];
+  return res.stdout.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function failure(op, session, detail) {
+  const tail = detail.trim();
+  return `tmux ${op} failed for session '${session}'${tail ? `: ${tail}` : ""}`;
+}
+
+// src/lib/drive/session.ts
+var AGENT_SESSION_PRIORITY = ["claude", "codex", "opencode"];
+async function resolveDriveSession(provider, box, explicit) {
+  if (await provider.probeState(box) === "paused") {
+    process.stderr.write(`drive: box ${box.name} is paused; unpausing
+`);
+    await provider.resume(box);
+  }
+  const sessions = await listSessions(provider, box);
+  if (explicit !== void 0 && explicit !== "") {
+    if (!sessions.includes(explicit)) {
+      throw new SessionNotFoundError(explicit, sessions);
+    }
+    return { name: explicit, available: sessions };
+  }
+  for (const candidate of AGENT_SESSION_PRIORITY) {
+    if (sessions.includes(candidate)) {
+      return { name: candidate, available: sessions };
+    }
+  }
+  if (sessions.length === 1 && sessions[0]) {
+    return { name: sessions[0], available: sessions };
+  }
+  throw new SessionNotFoundError(void 0, sessions);
+}
+var SessionNotFoundError = class extends Error {
+  wanted;
+  available;
+  constructor(wanted, available) {
+    const head = wanted ? `no tmux session '${wanted}' in this box` : "no agent tmux session running in this box";
+    const tail = available.length ? ` (running: ${available.join(", ")})` : " (tmux server not running or no sessions)";
+    super(head + tail);
+    this.name = "SessionNotFoundError";
+    this.wanted = wanted;
+    this.available = available;
+  }
+};
+
 // src/lib/wait/events.ts
 var POLL_INTERVAL_MS = 500;
 var WaitTimeoutError = class extends Error {
@@ -606,9 +781,209 @@ var agentGetPlanQuestionCommand = new Command("get-plan-question").description("
     handleLifecycleError(err);
   }
 });
+var agentApprovalsCommand = new Command("approvals").description(
+  "List everything a box is blocked on: relay host-action approvals (git push, cp host<->box, gh PR writes, checkpoint) AND the agent's in-TUI prompts (plan approval, question, tool permission). Each row carries an id to pass to `agent approve`."
+).argument("[box]", "box ref (default: only box in this project)").option("--json", "emit the pending approvals as a JSON array").option(
+  "--wait <ms>",
+  "block until at least one approval is pending (or this wall-clock cap elapses), then print"
+).action(async (boxRef, opts) => {
+  try {
+    const box = await resolveBoxOrExit(boxRef);
+    const relayUrl = (await ensureRelay()).hostUrl;
+    const waitMs = opts.wait !== void 0 ? parsePositiveInt(opts.wait, "--wait") : void 0;
+    let rows = await gatherApprovals(relayUrl, box);
+    if (waitMs !== void 0 && rows.length === 0) {
+      const start = Date.now();
+      while (rows.length === 0 && Date.now() - start < waitMs) {
+        await sleep2(Math.min(500, waitMs - (Date.now() - start)));
+        rows = await gatherApprovals(relayUrl, box);
+      }
+    }
+    if (opts.json === true) {
+      process.stdout.write(JSON.stringify(rows) + "\n");
+      return;
+    }
+    if (rows.length === 0) {
+      log3.info("nothing pending for this box (no relay approvals, agent not parked on a prompt)");
+      return;
+    }
+    for (const row2 of rows) {
+      process.stdout.write(approvalDisplay(row2) + "\n");
+    }
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+var agentApproveCommand = new Command("approve").description(
+  "Answer a pending approval by id (see `agent approvals`). The id is a safety token: you answer the exact prompt you inspected, and if a different one has since taken its place the approve is refused. Works for both relay host-action approvals and the agent's in-TUI prompts (plan / question / tool permission). Approves by default; --deny rejects."
+).argument("<id>", "approval id from `agent approvals` (relay UUID or a tui:... id)").option("--deny", "reject instead of approving").option("--cancel", "relay approvals only: dismiss (treated as denied; marks it cancelled)").option(
+  "--option <n|label>",
+  "in-TUI question/permission: pick this 1-based option (or match its label) instead of the default"
+).action(async (id, opts) => {
+  try {
+    if (isTuiId(id)) {
+      await approveInTui(id, opts);
+      return;
+    }
+    await approveRelay(id, opts);
+  } catch (err) {
+    handleLifecycleError(err);
+  }
+});
+async function approveRelay(id, opts) {
+  const relayUrl = (await ensureRelay()).hostUrl;
+  const cancelled = opts.cancel === true;
+  const answer = opts.deny === true || cancelled ? "n" : "y";
+  const url = new URL("/admin/prompts/answer", relayUrl);
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ id, answer, cancelled: cancelled || void 0 })
+  });
+  if (res.status === 204) {
+    log3.success(`approval ${id}: ${answer === "y" ? "approved" : "denied"}`);
+    return;
+  }
+  if (res.status === 404) {
+    log3.info(`approval ${id} already resolved (or expired)`);
+    return;
+  }
+  log3.error(`relay /admin/prompts/answer: HTTP ${String(res.status)}`);
+  process.exit(1);
+}
+async function approveInTui(id, opts) {
+  const parsed = parseTuiId(id);
+  if (!parsed) {
+    log3.error(`malformed in-TUI approval id: ${id}`);
+    process.exit(2);
+  }
+  if (opts.cancel === true) {
+    log3.error("--cancel applies to relay approvals only; use --deny for in-TUI prompts");
+    process.exit(2);
+  }
+  const box = await resolveBoxOrExit(parsed.boxId);
+  const status = await readBoxStatus(box);
+  const claude = status?.claude;
+  const current = claude ? mintTuiId(box.id, claude) : null;
+  if (!current || current.id !== id) {
+    log3.error(
+      `approval ${id} is no longer the pending prompt for ${box.name} (it changed or was answered) \u2014 re-run \`agentbox agent approvals ${box.name}\``
+    );
+    process.exit(1);
+  }
+  let option;
+  if (opts.option !== void 0) {
+    if (parsed.kind === "question" && claude) {
+      const resolved = resolveQuestionOption(claude, opts.option);
+      if (resolved === null) {
+        const labels = (claude.question?.questions?.[0]?.options ?? []).map((o) => o.label);
+        log3.error(`--option '${opts.option}' did not match an option (have: ${labels.join(" | ")})`);
+        process.exit(2);
+      }
+      option = resolved;
+    } else {
+      const n = Number.parseInt(opts.option, 10);
+      if (!Number.isFinite(n) || n < 1) {
+        log3.error(`--option must be a 1-based number for a ${parsed.kind} prompt (got: ${opts.option})`);
+        process.exit(2);
+      }
+      option = n;
+    }
+  }
+  const provider = await providerForBox(box);
+  const session = await resolveDriveSession(provider, box, void 0);
+  const agent = agentKindForSession(session.name);
+  const steps = answerKeystrokes(agent, parsed.kind, { option, deny: opts.deny });
+  await runAnswerSteps(provider, box, session.name, steps);
+  const verb = opts.deny === true ? "denied" : option !== void 0 ? `answered (option ${String(option)})` : "approved";
+  log3.success(`${parsed.kind} prompt on ${box.name}: ${verb}`);
+}
+function agentKindForSession(session) {
+  if (session === "codex") return "codex";
+  if (session === "opencode") return "opencode";
+  return "claude";
+}
+async function runAnswerSteps(provider, box, session, steps) {
+  for (const step of steps) {
+    if (step.type === "literal") await sendLiteral(provider, box, session, step.value);
+    else if (step.type === "key") await sendKey(provider, box, session, step.value);
+    else await sleep2(step.ms);
+  }
+}
 agentCommand.addCommand(agentStateCommand);
 agentCommand.addCommand(agentWaitForCommand);
 agentCommand.addCommand(agentGetPlanQuestionCommand);
+agentCommand.addCommand(agentApprovalsCommand);
+agentCommand.addCommand(agentApproveCommand);
+async function gatherApprovals(relayUrl, box) {
+  const rows = [];
+  const relay = await fetchRelayApprovals(relayUrl, box.id);
+  for (const ev of relay) {
+    rows.push({
+      id: ev.id,
+      kind: "host-action",
+      command: ev.context?.command,
+      argv: ev.context?.argv,
+      cwd: ev.context?.cwd,
+      message: ev.message,
+      detail: ev.detail,
+      defaultAnswer: ev.defaultAnswer
+    });
+  }
+  const claude = (await readBoxStatus(box))?.claude;
+  const tui = claude ? mintTuiId(box.id, claude) : null;
+  if (claude && tui) {
+    if (tui.kind === "plan") {
+      rows.push({ id: tui.id, kind: "plan", message: "Approve plan?", plan: claude.plan?.plan ?? "" });
+    } else if (tui.kind === "question") {
+      const q = claude.question?.questions?.[0];
+      rows.push({
+        id: tui.id,
+        kind: "question",
+        message: q?.question ?? "Answer question?",
+        options: (q?.options ?? []).map((o) => o.label)
+      });
+    } else {
+      rows.push({
+        id: tui.id,
+        kind: "permission",
+        message: "Tool-permission prompt (screen-driven; inspect with `agentbox drive snapshot`)",
+        state: claude.state
+      });
+    }
+  }
+  return rows;
+}
+async function fetchRelayApprovals(relayUrl, boxId) {
+  const url = new URL("/admin/prompts", relayUrl);
+  url.searchParams.set("boxId", boxId);
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`relay /admin/prompts: HTTP ${String(res.status)}`);
+  const body = await res.json();
+  return body.prompts ?? [];
+}
+function approvalDisplay(row2) {
+  if (row2.kind === "host-action") {
+    const cmd = row2.command ?? row2.message;
+    const argv2 = row2.argv?.length ? `  ${row2.argv.join(" ")}` : "";
+    const detail = row2.detail ? `  (${row2.detail})` : "";
+    return `${row2.id}  [host-action] ${cmd}${argv2}${detail}`;
+  }
+  if (row2.kind === "plan") {
+    return `${row2.id}  [plan] ${firstLine(row2.plan)}`;
+  }
+  if (row2.kind === "question") {
+    return `${row2.id}  [question] ${row2.message}  {${row2.options.join(" | ")}}`;
+  }
+  return `${row2.id}  [permission] ${row2.message}`;
+}
+function firstLine(s) {
+  const line = s.split("\n", 1)[0] ?? "";
+  return line.length > 100 ? line.slice(0, 99) + "\u2026" : line;
+}
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
 function emitMatch(claude, asJson) {
   if (asJson) {
     process.stdout.write(JSON.stringify(claude) + "\n");
@@ -727,18 +1102,141 @@ function buildPromptArgs(agentKind, prompt, userArgs) {
 }
 
 // src/lib/carry-resync.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/lib/carry-resolve.ts
-import { realpath, stat as stat2 } from "fs/promises";
+import { realpath, stat as stat3 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { isAbsolute, join as join3, normalize, resolve } from "path";
-var DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
+import { isAbsolute, join as join4, normalize, relative, resolve } from "path";
+
+// src/lib/dir-breakdown.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import { join as join3 } from "path";
+var DEFAULT_CP_EXCLUDES = [
+  ".git",
+  "node_modules",
+  "bin",
+  "obj",
+  "packages",
+  "dist",
+  ".next",
+  "target"
+];
+function isBareName(token) {
+  return !token.includes("/") && !token.includes("*") && !token.includes("?");
+}
+function toTarExcludes(tokens) {
+  const out = [];
+  for (const t of tokens) {
+    if (isBareName(t)) {
+      out.push(`*/${t}`, t);
+    } else {
+      out.push(t);
+    }
+  }
+  return out;
+}
+function effectiveExcludes(userTokens, useDefaults) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const add = (t) => {
+    if (t && !seen.has(t)) {
+      seen.add(t);
+      out.push(t);
+    }
+  };
+  if (useDefaults) DEFAULT_CP_EXCLUDES.forEach(add);
+  userTokens.forEach(add);
+  return out;
+}
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`);
+}
+function isPathExcluded(relPath, tokens) {
+  const segs = relPath.split("/");
+  for (const t of tokens) {
+    if (isBareName(t)) {
+      if (segs.includes(t)) return true;
+    } else if (globToRegExp(t).test(relPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function buildNode(abs, rel, tokens, seen) {
+  let bytes = 0;
+  const children = [];
+  let entries;
+  try {
+    entries = await readdir(abs);
+  } catch {
+    return { path: rel || ".", bytes: 0, children };
+  }
+  for (const name of entries) {
+    const childRel = rel ? `${rel}/${name}` : name;
+    if (isPathExcluded(childRel, tokens)) continue;
+    const full = join3(abs, name);
+    let st;
+    try {
+      st = await stat2(full);
+    } catch {
+      continue;
+    }
+    const key = `${String(st.dev)}:${String(st.ino)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (st.isDirectory()) {
+      const child = await buildNode(full, childRel, tokens, seen);
+      bytes += child.bytes;
+      children.push(child);
+    } else if (st.isFile()) {
+      bytes += st.size;
+    }
+  }
+  return { path: rel || ".", bytes, children };
+}
+async function measureCopy(absSrc, tokens, opts = {}) {
+  const st = await stat2(absSrc);
+  if (!st.isDirectory()) {
+    return { totalBytes: st.size, isDir: false, treeLines: [], topChildren: [] };
+  }
+  const root = await buildNode(absSrc, "", tokens, /* @__PURE__ */ new Set());
+  const maxDepth = opts.maxDepth ?? 3;
+  const floor = opts.floorBytes ?? 10 * 1024 * 1024;
+  const perLevel = opts.perLevel ?? 8;
+  const lines = [];
+  const render = (node, depth, label) => {
+    const pad4 = "  ".repeat(depth);
+    lines.push(`  ${fmtBytes(node.bytes).padStart(8)}  ${pad4}${label}`);
+    if (depth >= maxDepth) return;
+    const kids = [...node.children].sort((a, b) => b.bytes - a.bytes).filter((c) => c.bytes >= floor).slice(0, perLevel);
+    for (const kid of kids) {
+      render(kid, depth + 1, `./${kid.path}`);
+    }
+  };
+  render(root, 0, "./");
+  const topChildren = [...root.children].sort((a, b) => b.bytes - a.bytes).map((c) => ({ path: c.path, bytes: c.bytes }));
+  return { totalBytes: root.bytes, isDir: true, treeLines: lines, topChildren };
+}
+function fmtBytes(n) {
+  if (n < 1024) return `${String(n)} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let v = n / 1024;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i += 1;
+  }
+  return `${v >= 10 || Number.isInteger(v) ? v.toFixed(0) : v.toFixed(1)} ${units[i]}`;
+}
+
+// src/lib/carry-resolve.ts
 var DENYLIST_DEST_PREFIXES = ["/proc", "/sys", "/dev"];
 var DENYLIST_DEST_EXACT = /* @__PURE__ */ new Set(["/etc/passwd", "/etc/shadow"]);
 async function resolveCarry(items, opts) {
   const home = opts.homeDir ?? homedir2();
-  const cap = opts.maxBytes ?? readMaxBytesFromEnv() ?? DEFAULT_MAX_BYTES;
+  const cap = opts.maxBytes ?? BUILT_IN_DEFAULTS.box.cpMaxBytes;
   const projectRoot = opts.projectRoot;
   const entries = [];
   const errors = [];
@@ -753,13 +1251,6 @@ async function resolveCarry(items, opts) {
   }
   return { entries, errors };
 }
-function readMaxBytesFromEnv() {
-  const raw = process.env.AGENTBOX_CARRY_MAX_BYTES;
-  if (!raw) return void 0;
-  const n = Number(raw);
-  if (!Number.isFinite(n) || n <= 0) return void 0;
-  return Math.floor(n);
-}
 async function resolveOne(item, ctx) {
   const absSrc = expandHostPath(item.src, ctx);
   if (containsDotDot(absSrc)) {
@@ -772,7 +1263,7 @@ async function resolveOne(item, ctx) {
   const absDest = item.dest;
   let st;
   try {
-    st = await stat2(absSrc);
+    st = await stat3(absSrc);
   } catch (err) {
     if (err.code === "ENOENT") {
       if (optional) {
@@ -806,10 +1297,12 @@ async function resolveOne(item, ctx) {
   } catch {
   }
   if (st.isDirectory()) {
-    const bytes = await dirSizeCapped(absSrc, ctx.cap);
+    const tokens = effectiveExcludes(item.exclude ?? [], true);
+    const tarPatterns = toTarExcludes(tokens);
+    const bytes = await dirSizeCapped(absSrc, ctx.cap, tokens);
     if (bytes > ctx.cap) {
       throw new Error(
-        `${ctx.where}: dir "${absSrc}" exceeds ${String(ctx.cap)} bytes (set AGENTBOX_CARRY_MAX_BYTES to raise the cap or narrow the path)`
+        `${ctx.where}: dir "${absSrc}" exceeds ${String(ctx.cap)} bytes after excludes (add carry exclude: patterns, raise box.cpMaxBytes, or narrow the path)`
       );
     }
     return {
@@ -821,6 +1314,7 @@ async function resolveOne(item, ctx) {
       bytes,
       ...item.mode !== void 0 ? { mode: item.mode } : {},
       ...item.user !== void 0 ? { user: item.user } : {},
+      ...tarPatterns.length > 0 ? { exclude: tarPatterns } : {},
       optional,
       ...symlinkInfo ? { symlinkInfo } : {}
     };
@@ -828,7 +1322,7 @@ async function resolveOne(item, ctx) {
   if (st.isFile()) {
     if (st.size > ctx.cap) {
       throw new Error(
-        `${ctx.where}: file "${absSrc}" is ${String(st.size)} bytes, exceeds cap ${String(ctx.cap)} (set AGENTBOX_CARRY_MAX_BYTES to raise)`
+        `${ctx.where}: file "${absSrc}" is ${String(st.size)} bytes, exceeds cap ${String(ctx.cap)} (raise box.cpMaxBytes)`
       );
     }
     return {
@@ -893,24 +1387,26 @@ async function realpathSafe(p) {
     return resolve(p);
   }
 }
-async function dirSizeCapped(dir, cap) {
+async function dirSizeCapped(dir, cap, exclude = []) {
   let total = 0;
   const seen = /* @__PURE__ */ new Set();
   async function walk(d) {
     if (total > cap) return;
-    const { readdir: readdir3 } = await import("fs/promises");
+    const { readdir: readdir4 } = await import("fs/promises");
     let names;
     try {
-      names = await readdir3(d);
+      names = await readdir4(d);
     } catch {
       return;
     }
     for (const name of names) {
       if (total > cap) return;
-      const full = join3(d, name);
+      const full = join4(d, name);
+      const rel = relative(dir, full).split(/[\\/]/).join("/");
+      if (exclude.length > 0 && isPathExcluded(rel, exclude)) continue;
       let st;
       try {
-        st = await stat2(full);
+        st = await stat3(full);
       } catch {
         continue;
       }
@@ -935,9 +1431,13 @@ async function resyncCarryFiles(args) {
   });
   const prior = args.box.carry?.entries ?? [];
   if (prior.length === 0) return { recopied: 0, skippedNew: 0 };
-  const items = await loadCarrySection(join4(args.projectRoot, "agentbox.yaml"));
+  const items = await loadCarrySection(join5(args.projectRoot, "agentbox.yaml"));
   if (items.length === 0) return { recopied: 0, skippedNew: 0 };
-  const resolved = await resolveCarry(items, { projectRoot: args.projectRoot });
+  const cfg = await loadEffectiveConfig(args.projectRoot);
+  const resolved = await resolveCarry(items, {
+    projectRoot: args.projectRoot,
+    maxBytes: cfg.effective.box.cpMaxBytes
+  });
   if (resolved.errors.length > 0) {
     log47(`carry: resync skipped (resolve errors: ${resolved.errors.length})`);
     return { recopied: 0, skippedNew: 0 };
@@ -1072,6 +1572,7 @@ async function submitQueueJob(input) {
     createOpts: input.createOpts,
     maxConcurrent: ceiling,
     ...maxWorking !== void 0 ? { maxWorking } : {},
+    ...input.openTerminal !== void 0 ? { openTerminal: input.openTerminal } : {},
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     logPath: queueLogPath(id)
   };
@@ -1126,6 +1627,58 @@ function postEnqueue(id) {
   });
 }
 
+// src/terminal/queue-open.ts
+function captureOpenTerminalContext(mode, env = process.env, cwd = process.cwd()) {
+  if (mode === "none") return void 0;
+  const host = detectHostTerminal(env);
+  if (host === "unknown") return void 0;
+  const base = { host, mode, cwd };
+  if (host === "tmux") {
+    return { ...base, host, tmuxSocket: env["TMUX"], tmuxPane: env["TMUX_PANE"] };
+  }
+  if (host === "cmux") {
+    return {
+      ...base,
+      host,
+      cmuxSocket: env["CMUX_SOCKET_PATH"],
+      cmuxBundledCli: cmuxBinary(env),
+      cmuxSurfaceId: env["CMUX_SURFACE_ID"],
+      cmuxWorkspaceId: env["CMUX_WORKSPACE_ID"]
+    };
+  }
+  return { ...base, host };
+}
+function spawnQueuedOpenTerminal(ctx, argv2, title) {
+  if (ctx.host === "tmux") {
+    return spawnInNewTerminal({
+      host: "tmux",
+      mode: ctx.mode,
+      argv: argv2,
+      cwd: ctx.cwd,
+      title,
+      env: ctx.tmuxSocket ? { ...process.env, TMUX: ctx.tmuxSocket } : process.env,
+      tmuxTarget: ctx.tmuxPane
+    });
+  }
+  if (ctx.host === "cmux") {
+    const env = { ...process.env };
+    if (ctx.cmuxSocket) env["CMUX_SOCKET_PATH"] = ctx.cmuxSocket;
+    if (ctx.cmuxBundledCli) env["CMUX_BUNDLED_CLI_PATH"] = ctx.cmuxBundledCli;
+    return spawnInNewTerminal({
+      host: "cmux",
+      mode: ctx.mode,
+      argv: argv2,
+      cwd: ctx.cwd,
+      title,
+      env,
+      cmuxTargetSurface: ctx.cmuxSurfaceId,
+      cmuxTargetWorkspace: ctx.cmuxWorkspaceId,
+      cmuxWorkspaceFallback: true
+    });
+  }
+  return spawnInNewTerminal({ host: "iterm2", mode: ctx.mode, argv: argv2, cwd: ctx.cwd, title });
+}
+
 // src/commands/_attach-in.ts
 var VALUES = ["split", "window", "tab", "same"];
 var ATTACH_IN_HELP = "where to open the attached session: split | window | tab | same (default from attach.openIn, built-in: split). Only effective when running inside tmux or iTerm2; falls back to inline attach otherwise.";
@@ -1366,14 +1919,14 @@ async function cloudAgentCreate(args) {
 }
 
 // src/lib/carry-gate.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { log as log5 } from "@clack/prompts";
 
 // src/carry-prompt.ts
 import { isCancel, log as log4, select } from "@clack/prompts";
 
 // src/fmt.ts
-function fmtBytes(n) {
+function fmtBytes2(n) {
   if (n === null || n === void 0) return "n/a";
   if (n < 1024) return `${String(n)} B`;
   if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KiB`;
@@ -1449,7 +2002,7 @@ function printSummary(entries) {
     if (e.mode !== void 0) flags.push(`mode ${e.mode.toString(8).padStart(4, "0")}`);
     if (e.user !== void 0 && e.user !== 1e3) flags.push(`user ${String(e.user)}`);
     if (e.symlinkInfo === "outside-home") flags.push("symlink \u2192 outside $HOME!");
-    const size = e.kind === "missing" ? "\u2014" : fmtBytes(e.bytes ?? 0);
+    const size = e.kind === "missing" ? "\u2014" : fmtBytes2(e.bytes ?? 0);
     rows.push(
       `  ${pad(e.rawSrc, srcW)}  \u2192  ${pad(e.rawDest, destW)}  ${pad(size, 9)}  ${flags.join(", ")}`
     );
@@ -1465,10 +2018,14 @@ function pad(s, w) {
 async function runCarryGate(args) {
   const emit = args.onLog ?? (() => {
   });
-  const yamlPath = join5(args.projectRoot, "agentbox.yaml");
+  const yamlPath = join6(args.projectRoot, "agentbox.yaml");
   const items = await loadCarrySection(yamlPath);
   if (items.length === 0) return { decision: "approve", entries: [] };
-  const resolved = await resolveCarry(items, { projectRoot: args.projectRoot });
+  const cfg = await loadEffectiveConfig(args.projectRoot);
+  const resolved = await resolveCarry(items, {
+    projectRoot: args.projectRoot,
+    maxBytes: cfg.effective.box.cpMaxBytes
+  });
   if (resolved.errors.length > 0) {
     const msg = ["carry: refused to proceed:", ...resolved.errors.map((e) => `  - ${e}`)].join("\n");
     throw new Error(msg);
@@ -1513,10 +2070,10 @@ async function runQueuedCarryGate(args) {
 }
 
 // src/session-teleport/claude.ts
-import { mkdir, mkdtemp, readdir, readFile as readFile2, stat as stat3, writeFile } from "fs/promises";
+import { mkdir, mkdtemp, readdir as readdir2, readFile as readFile2, stat as stat4, writeFile } from "fs/promises";
 import { existsSync } from "fs";
 import { homedir as homedir4, tmpdir } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/session-teleport/cwd-encoding.ts
 function encodeClaudeProjectsDir(absPath) {
@@ -1537,7 +2094,7 @@ var TeleportError = class extends Error {
 var BOX_CLAUDE_PROJECTS_DIR = `/home/vscode/.claude/projects/${BOX_WORKSPACE_ENCODED}`;
 async function resolveClaudeTeleport(opts) {
   const hostHome = opts.hostHome ?? homedir4();
-  const projectDir = join6(
+  const projectDir = join7(
     hostHome,
     ".claude",
     "projects",
@@ -1550,8 +2107,8 @@ async function resolveClaudeTeleport(opts) {
   }
   const sessionPath = await pickSessionFile(projectDir, opts.mode);
   const sessionId = sessionPath.replace(/\.jsonl$/u, "").split("/").pop() ?? "";
-  const stage = await mkdtemp(join6(tmpdir(), "agentbox-teleport-claude-"));
-  const stagedFile = join6(stage, `${sessionId}.jsonl`);
+  const stage = await mkdtemp(join7(tmpdir(), "agentbox-teleport-claude-"));
+  const stagedFile = join7(stage, `${sessionId}.jsonl`);
   await rewriteSessionFile(sessionPath, stagedFile, opts.hostCwd);
   opts.log?.(`teleport: claude session ${sessionId} staged for upload`);
   return {
@@ -1565,7 +2122,7 @@ async function resolveClaudeTeleport(opts) {
 }
 async function pickSessionFile(projectDir, mode) {
   if (mode.kind === "resume") {
-    const target = join6(projectDir, `${mode.id}.jsonl`);
+    const target = join7(projectDir, `${mode.id}.jsonl`);
     if (!existsSync(target)) {
       throw new TeleportError(
         `Claude session "${mode.id}" not found in ${projectDir}. List available sessions with: ls "${projectDir}"`
@@ -1573,7 +2130,7 @@ async function pickSessionFile(projectDir, mode) {
     }
     return target;
   }
-  const entries = await readdir(projectDir);
+  const entries = await readdir2(projectDir);
   const jsonl = entries.filter((e) => e.endsWith(".jsonl"));
   if (jsonl.length === 0) {
     throw new TeleportError(
@@ -1582,8 +2139,8 @@ async function pickSessionFile(projectDir, mode) {
   }
   const stats = await Promise.all(
     jsonl.map(async (name) => {
-      const full = join6(projectDir, name);
-      const s = await stat3(full);
+      const full = join7(projectDir, name);
+      const s = await stat4(full);
       return { full, mtimeMs: s.mtimeMs };
     })
   );
@@ -1616,18 +2173,18 @@ async function rewriteSessionFile(src, dst, hostCwd) {
     }
     out.push(line);
   }
-  await mkdir(join6(dst, ".."), { recursive: true });
+  await mkdir(join7(dst, ".."), { recursive: true });
   await writeFile(dst, out.join("\n"), "utf8");
 }
 
 // src/session-teleport/codex.ts
-import { mkdtemp as mkdtemp2, readdir as readdir2, readFile as readFile3, stat as stat4, writeFile as writeFile2 } from "fs/promises";
+import { mkdtemp as mkdtemp2, readdir as readdir3, readFile as readFile3, stat as stat5, writeFile as writeFile2 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 async function resolveCodexTeleport(opts) {
   const hostHome = opts.hostHome ?? homedir5();
-  const sessionsRoot = join7(hostHome, ".codex", "sessions");
+  const sessionsRoot = join8(hostHome, ".codex", "sessions");
   if (!existsSync2(sessionsRoot)) {
     throw new TeleportError(
       `no Codex session history found on the host (expected at ${sessionsRoot}). Run \`codex\` at least once before using -c / --resume.`
@@ -1669,8 +2226,8 @@ async function resolveCodexTeleport(opts) {
     matching.sort((a, b) => b.mtimeMs - a.mtimeMs);
     picked = matching[0];
   }
-  const stage = await mkdtemp2(join7(tmpdir2(), "agentbox-teleport-codex-"));
-  const stagedFile = join7(stage, posixBasename(picked.relPath));
+  const stage = await mkdtemp2(join8(tmpdir2(), "agentbox-teleport-codex-"));
+  const stagedFile = join8(stage, posixBasename(picked.relPath));
   await rewriteCodexSession(picked.hostPath, stagedFile, opts.hostCwd);
   opts.log?.(`teleport: codex session ${picked.uuid} staged for upload`);
   const boxParentDir = `/home/vscode/.codex/sessions/${posixDirname(picked.relPath)}`;
@@ -1696,24 +2253,24 @@ async function listCodexSessions(sessionsRoot) {
   const years = await safeReaddir(sessionsRoot);
   for (const y of years) {
     if (!/^\d{4}$/u.test(y)) continue;
-    const yDir = join7(sessionsRoot, y);
+    const yDir = join8(sessionsRoot, y);
     const months = await safeReaddir(yDir);
     for (const m of months) {
       if (!/^\d{2}$/u.test(m)) continue;
-      const mDir = join7(yDir, m);
+      const mDir = join8(yDir, m);
       const days = await safeReaddir(mDir);
       for (const d of days) {
         if (!/^\d{2}$/u.test(d)) continue;
-        const dDir = join7(mDir, d);
+        const dDir = join8(mDir, d);
         const files = await safeReaddir(dDir);
         for (const name of files) {
           if (!name.startsWith("rollout-") || !name.endsWith(".jsonl")) continue;
           const uuid = extractCodexUuid(name);
           if (uuid === null) continue;
-          const hostPath = join7(dDir, name);
+          const hostPath = join8(dDir, name);
           let mtimeMs = 0;
           try {
-            mtimeMs = (await stat4(hostPath)).mtimeMs;
+            mtimeMs = (await stat5(hostPath)).mtimeMs;
           } catch {
             continue;
           }
@@ -1733,7 +2290,7 @@ async function listCodexSessions(sessionsRoot) {
 }
 async function safeReaddir(dir) {
   try {
-    return await readdir2(dir);
+    return await readdir3(dir);
   } catch {
     return [];
   }
@@ -1745,16 +2302,16 @@ function extractCodexUuid(filename) {
   return m ? m[1] : null;
 }
 async function peekCodexCwd(file) {
-  let firstLine2;
+  let firstLine3;
   try {
     const buf = await readFile3(file, "utf8");
     const nl = buf.indexOf("\n");
-    firstLine2 = nl === -1 ? buf : buf.slice(0, nl);
+    firstLine3 = nl === -1 ? buf : buf.slice(0, nl);
   } catch {
     return null;
   }
   try {
-    const parsed = JSON.parse(firstLine2);
+    const parsed = JSON.parse(firstLine3);
     if (parsed.type === "session_meta" && typeof parsed.payload?.cwd === "string") {
       return parsed.payload.cwd;
     }
@@ -1836,11 +2393,11 @@ async function uploadTeleport(input) {
 import { mkdtemp as mkdtemp3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir6, tmpdir as tmpdir3 } from "os";
-import { basename, isAbsolute as isAbsolute2, join as join8, resolve as resolve2 } from "path";
+import { basename, isAbsolute as isAbsolute2, join as join9, resolve as resolve2 } from "path";
 var BOX_CLAUDE_PLANS_DIR = "/home/vscode/.claude/plans";
 function expandHome(p, hostHome) {
   if (p === "~") return hostHome;
-  if (p.startsWith("~/")) return join8(hostHome, p.slice(2));
+  if (p.startsWith("~/")) return join9(hostHome, p.slice(2));
   return isAbsolute2(p) ? p : resolve2(p);
 }
 async function resolvePlanTeleport(opts) {
@@ -1852,8 +2409,8 @@ async function resolvePlanTeleport(opts) {
     );
   }
   const name = basename(planFile);
-  const stage = await mkdtemp3(join8(tmpdir3(), "agentbox-teleport-plan-"));
-  const stagedFile = join8(stage, name);
+  const stage = await mkdtemp3(join9(tmpdir3(), "agentbox-teleport-plan-"));
+  const stagedFile = join9(stage, name);
   const raw = await readFile4(planFile, "utf8");
   const absCwd = opts.hostCwd ? resolve2(expandHome(opts.hostCwd, hostHome)) : "";
   const rewritten = absCwd ? raw.split(absCwd).join(BOX_WORKSPACE) : raw;
@@ -1873,14 +2430,14 @@ async function resolvePlanTeleport(opts) {
 import { log as log6 } from "@clack/prompts";
 import { existsSync as existsSync4, mkdirSync, writeFileSync } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function maybeShowInstallHint() {
   try {
-    const skill = join9(homedir7(), ".claude", "skills", "agentbox", "SKILL.md");
+    const skill = join10(homedir7(), ".claude", "skills", "agentbox", "SKILL.md");
     if (existsSync4(skill)) return;
-    const marker = join9(homedir7(), ".agentbox", "install-hint-shown");
+    const marker = join10(homedir7(), ".agentbox", "install-hint-shown");
     if (existsSync4(marker)) return;
-    mkdirSync(join9(homedir7(), ".agentbox"), { recursive: true });
+    mkdirSync(join10(homedir7(), ".agentbox"), { recursive: true });
     writeFileSync(marker, "");
     log6.info("tip: run 'agentbox install' to enable the /agentbox fork command in host Claude");
   } catch {
@@ -1890,18 +2447,18 @@ function maybeShowInstallHint() {
 // src/lib/log-file.ts
 import { closeSync, mkdirSync as mkdirSync2, openSync, renameSync, symlinkSync, unlinkSync, writeFileSync as writeFileSync2, writeSync } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function stateDir() {
-  return process.env.AGENTBOX_HOME ?? join10(homedir8(), ".agentbox");
+  return process.env.AGENTBOX_HOME ?? join11(homedir8(), ".agentbox");
 }
 function logsDir() {
-  return join10(stateDir(), "logs");
+  return join11(stateDir(), "logs");
 }
 function openCommandLog(command) {
   const dir = logsDir();
   mkdirSync2(dir, { recursive: true });
-  const path = join10(dir, `${command}.log`);
-  const prev = join10(dir, `${command}.log.prev`);
+  const path = join11(dir, `${command}.log`);
+  const prev = join11(dir, `${command}.log.prev`);
   try {
     renameSync(path, prev);
   } catch {
@@ -1961,7 +2518,7 @@ function openCommandLog(command) {
   };
 }
 function updateLatestSymlink(dir, target) {
-  const link = join10(dir, "latest.log");
+  const link = join11(dir, "latest.log");
   try {
     unlinkSync(link);
   } catch {
@@ -2075,13 +2632,13 @@ import { basename as basename2 } from "path";
 async function cloudBackendForProvider(provider) {
   switch (provider) {
     case "daytona":
-      return (await import("./dist-3IMQNTTV.js")).daytonaBackend;
+      return (await import("./dist-FIFEFKJ7.js")).daytonaBackend;
     case "hetzner":
-      return (await import("./dist-J2IHD5T7.js")).hetznerBackend;
+      return (await import("./dist-AGTIA7AD.js")).hetznerBackend;
     case "vercel":
-      return (await import("./dist-57M6ZA7H.js")).vercelBackend;
+      return (await import("./dist-S4XR4ACV.js")).vercelBackend;
     case "e2b":
-      return (await import("./dist-34RKQ74M.js")).e2bBackend;
+      return (await import("./dist-JZ3XO6EB.js")).e2bBackend;
     default:
       return null;
   }
@@ -2089,13 +2646,13 @@ async function cloudBackendForProvider(provider) {
 async function currentCloudBaseFingerprintLive(provider) {
   switch (provider) {
     case "daytona":
-      return (await import("./dist-3IMQNTTV.js")).currentDaytonaBaseFingerprintLive();
+      return (await import("./dist-FIFEFKJ7.js")).currentDaytonaBaseFingerprintLive();
     case "hetzner":
-      return (await import("./dist-J2IHD5T7.js")).currentHetznerBaseFingerprintLive();
+      return (await import("./dist-AGTIA7AD.js")).currentHetznerBaseFingerprintLive();
     case "vercel":
-      return (await import("./dist-57M6ZA7H.js")).currentVercelBaseFingerprintLive();
+      return (await import("./dist-S4XR4ACV.js")).currentVercelBaseFingerprintLive();
     case "e2b":
-      return (await import("./dist-34RKQ74M.js")).currentE2bBaseFingerprintLive();
+      return (await import("./dist-JZ3XO6EB.js")).currentE2bBaseFingerprintLive();
     default:
       return void 0;
   }
@@ -2173,18 +2730,30 @@ async function evaluateBaseFreshness(provider) {
 
 // src/wizard.ts
 var IN_BOX_SETUP_GUIDE_PATH = "/usr/local/share/agentbox/setup-guide.md";
-function buildSetupInitialPrompt(workspace) {
+function buildSetupInitialPrompt(workspace, hasAgentboxYaml = false) {
   const name = basename2(workspace);
+  if (hasAgentboxYaml) {
+    return `The user reopened the agentbox sandbox for "${name}". The workspace already has a /workspace/agentbox.yaml, but the previous snapshot was stale so the box was rebuilt from a fresh base image \u2014 its dependencies and system setup are NOT installed yet. Please run the /agentbox-setup skill (or read ${IN_BOX_SETUP_GUIDE_PATH} if the skill is not loaded), then reuse the existing /workspace/agentbox.yaml: verify the declared tasks and services still fit the project, (re)install dependencies and any system packages the setup needs on this fresh base, and update agentbox.yaml only if something is missing or wrong \u2014 do not regenerate it from scratch. Then run \`agentbox-ctl reload\` from inside the box so the already-running supervisor re-applies the config and immediately runs the declared tasks and autostarts the services (no box restart needed). When the box is warm, capture it with \`agentbox checkpoint --set-default\` so future boxes skip this rebuild. Finally, summarise what you verified and changed, and remind the user how to land any agentbox.yaml change on the host (commit through the bind-mounted .git, or "agentbox download 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_RECREATE_ENV = "AGENTBOX_WIZARD_RECREATE";
 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" };
     const envFiles = parseEnvFilesFromEnv(process.env[WIZARD_ENV_FILES_ENV]);
     const proj2 = await findProjectRoot(args.workspace);
+    if (process.env[WIZARD_RECREATE_ENV] === "1") {
+      return {
+        action: "launch-with-prompt",
+        initialPrompt: buildSetupInitialPrompt(proj2.root, proj2.hasAgentboxYaml),
+        envFilesToImport: envFiles,
+        discardCheckpoint: true
+      };
+    }
     return nonInteractiveOutcome(args, proj2, await checkpointStatus(args, proj2.root), envFiles);
   }
   const proj = await findProjectRoot(args.workspace);
@@ -2218,13 +2787,6 @@ async function maybeRunSetupWizard(args) {
       };
     }
   }
-  if (proj.hasAgentboxYaml) {
-    return { action: "proceed", discardCheckpoint: discardOnMissing(status, fromDefault) };
-  }
-  if (!rebuildBase && (status.state === "fresh" || status.state === "stale" && !fromDefault)) {
-    log8.info(`starting from checkpoint "${args.checkpointRef}"; skipping agentbox.yaml setup`);
-    return { action: "proceed" };
-  }
   let discardCheckpoint = rebuildBase;
   let recreateChosen = rebuildBase;
   if (!rebuildBase && status.state === "stale" && fromDefault) {
@@ -2237,7 +2799,15 @@ async function maybeRunSetupWizard(args) {
     }
     discardCheckpoint = true;
     recreateChosen = true;
-  } else if (!rebuildBase && status.state === "missing") {
+  }
+  if (proj.hasAgentboxYaml && !recreateChosen) {
+    return { action: "proceed", discardCheckpoint: discardOnMissing(status, fromDefault) };
+  }
+  if (!rebuildBase && !recreateChosen && (status.state === "fresh" || status.state === "stale" && !fromDefault)) {
+    log8.info(`starting from checkpoint "${args.checkpointRef}"; skipping agentbox.yaml setup`);
+    return { action: "proceed" };
+  }
+  if (!rebuildBase && !recreateChosen && status.state === "missing") {
     discardCheckpoint = discardOnMissing(status, fromDefault) ?? false;
   }
   let envFilesToImport;
@@ -2274,15 +2844,17 @@ async function maybeRunSetupWizard(args) {
       action: "switch-to-claude",
       envFilesToImport,
       discardCheckpoint: discardCheckpoint || void 0,
-      rebuildBase: rebuildBase || void 0
+      rebuildBase: rebuildBase || void 0,
+      recreate: recreateChosen || void 0
     };
   }
   return {
     action: "launch-with-prompt",
-    initialPrompt: buildSetupInitialPrompt(proj.root),
+    initialPrompt: buildSetupInitialPrompt(proj.root, proj.hasAgentboxYaml),
     envFilesToImport,
     discardCheckpoint: discardCheckpoint || void 0,
-    rebuildBase: rebuildBase || void 0
+    rebuildBase: rebuildBase || void 0,
+    recreate: recreateChosen || void 0
   };
 }
 function rebuildMinutesFor(provider) {
@@ -2323,7 +2895,7 @@ function nonInteractiveOutcome(args, proj, status, envFilesToImport) {
   if (args.command === "claude") {
     return {
       action: "launch-with-prompt",
-      initialPrompt: buildSetupInitialPrompt(proj.root),
+      initialPrompt: buildSetupInitialPrompt(proj.root, proj.hasAgentboxYaml),
       envFilesToImport,
       discardCheckpoint
     };
@@ -2419,7 +2991,7 @@ async function renderDocker(status) {
 }
 async function daytonaStatus() {
   try {
-    const mod = await import("./dist-3IMQNTTV.js");
+    const mod = await import("./dist-FIFEFKJ7.js");
     return await mod.getDaytonaStatus();
   } catch (err) {
     return {
@@ -2430,7 +3002,7 @@ async function daytonaStatus() {
 }
 async function e2bStatus() {
   try {
-    const mod = await import("./dist-34RKQ74M.js");
+    const mod = await import("./dist-JZ3XO6EB.js");
     const cred = mod.readE2bCredStatus();
     if (cred.auth === "none") {
       return { configured: false, reason: "not configured \u2014 run `agentbox e2b login`" };
@@ -2944,7 +3516,8 @@ var claudeCommand = new Command3("claude").description("Create a sandboxed box a
       agentArgs: claudeArgs,
       createOpts: { ...pickCreateOpts(opts), carry: carryForQueue },
       maxRunningOverride,
-      maxWorkingOverride
+      maxWorkingOverride,
+      openTerminal: captureOpenTerminalContext(cfg.effective.queue.openIn)
     });
     outro(
       `job ${result.job.id} queued (${String(result.runningCount)}/${String(result.maxConcurrent)} running); log: ${result.job.logPath}`
@@ -3572,13 +4145,13 @@ var CLOUD_BACKENDS = ["daytona", "hetzner", "vercel", "e2b"];
 async function cloudProviderFor(backend) {
   switch (backend) {
     case "daytona":
-      return (await import("./dist-3IMQNTTV.js")).daytonaProvider;
+      return (await import("./dist-FIFEFKJ7.js")).daytonaProvider;
     case "hetzner":
-      return (await import("./dist-J2IHD5T7.js")).hetznerProvider;
+      return (await import("./dist-AGTIA7AD.js")).hetznerProvider;
     case "vercel":
-      return (await import("./dist-57M6ZA7H.js")).vercelProvider;
+      return (await import("./dist-S4XR4ACV.js")).vercelProvider;
     case "e2b":
-      return (await import("./dist-34RKQ74M.js")).e2bProvider;
+      return (await import("./dist-JZ3XO6EB.js")).e2bProvider;
   }
 }
 var CHECKPOINT_NOTICE = "Checkpoint in progress \u2014 the box will be unresponsive for a moment";
@@ -3948,9 +4521,9 @@ import { Command as Command5, InvalidArgumentError } from "commander";
 // src/ssh-config.ts
 import { promises as fs } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function sshConfigPath() {
-  return join11(homedir9(), ".ssh", "config");
+  return join12(homedir9(), ".ssh", "config");
 }
 function beginMarker(alias) {
   return `# BEGIN agentbox cloud box ${alias}`;
@@ -4001,7 +4574,7 @@ function buildBlock(opts) {
 }
 async function writeAgentboxSshAlias(opts) {
   const path = sshConfigPath();
-  await fs.mkdir(join11(homedir9(), ".ssh"), { recursive: true, mode: 448 });
+  await fs.mkdir(join12(homedir9(), ".ssh"), { recursive: true, mode: 448 });
   const existing = await readConfig();
   const stripped = stripBlock(existing, opts.alias);
   const separator = stripped.length === 0 || stripped.endsWith("\n") ? "" : "\n";
@@ -4231,10 +4804,10 @@ async function launchOne(flavor, folderUri) {
   return { code: fallback, flavor, via: "open" };
 }
 function spawnCommand(cmd, args) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const child = spawn(cmd, args, { stdio: "ignore" });
-    child.once("error", () => resolve4(127));
-    child.once("exit", (code) => resolve4(code ?? -1));
+    child.once("error", () => resolve5(127));
+    child.once("exit", (code) => resolve5(code ?? -1));
   });
 }
 async function fetchServiceNamesDocker(container) {
@@ -4253,7 +4826,7 @@ async function fetchServiceNamesDocker(container) {
 // src/commands/codex.ts
 import { access } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { confirm as confirm5, intro as intro3, isCancel as isCancel6, log as log13, outro as outro2, spinner as spinner5 } from "@clack/prompts";
 import { Command as Command6 } from "commander";
 function reattachRef2(r) {
@@ -4350,7 +4923,7 @@ async function maybeRunCodexLogin(args) {
 }
 async function cloudCodexCredAvailable(env = process.env) {
   if ((env["OPENAI_API_KEY"] ?? "").length > 0) return true;
-  for (const p of [CODEX_CREDENTIALS_BACKUP_FILE, join12(homedir10(), ".codex", "auth.json")]) {
+  for (const p of [CODEX_CREDENTIALS_BACKUP_FILE, join13(homedir10(), ".codex", "auth.json")]) {
     try {
       await access(p);
       return true;
@@ -4518,7 +5091,8 @@ var codexCommand = new Command6("codex").description("Create a sandboxed box and
       agentArgs: codexArgs,
       createOpts: { ...pickCodexCreateOpts(opts), carry: carryForQueue },
       maxRunningOverride,
-      maxWorkingOverride
+      maxWorkingOverride,
+      openTerminal: captureOpenTerminalContext(cfg.effective.queue.openIn)
     });
     outro2(
       `job ${result.job.id} queued (${String(result.runningCount)}/${String(result.maxConcurrent)} running); log: ${result.job.logPath}`
@@ -5008,7 +5582,7 @@ codexCommand.addCommand(codexLoginCommand);
 // src/commands/opencode.ts
 import { access as access2 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { confirm as confirm6, intro as intro4, isCancel as isCancel7, log as log14, outro as outro3, spinner as spinner6 } from "@clack/prompts";
 import { Command as Command7 } from "commander";
 function reattachRef3(r) {
@@ -5107,7 +5681,7 @@ async function cloudOpencodeCredAvailable(env = process.env) {
   for (const k of OPENCODE_FORWARDED_ENV_KEYS) {
     if ((env[k] ?? "").length > 0) return true;
   }
-  for (const p of [OPENCODE_CREDENTIALS_BACKUP_FILE, join13(homedir11(), ".local", "share", "opencode", "auth.json")]) {
+  for (const p of [OPENCODE_CREDENTIALS_BACKUP_FILE, join14(homedir11(), ".local", "share", "opencode", "auth.json")]) {
     try {
       await access2(p);
       return true;
@@ -5257,7 +5831,8 @@ var opencodeCommand = new Command7("opencode").description("Create a sandboxed b
       agentArgs: opencodeArgs,
       createOpts: { ...pickOpencodeCreateOpts(opts), carry: carryForQueue },
       maxRunningOverride,
-      maxWorkingOverride
+      maxWorkingOverride,
+      openTerminal: captureOpenTerminalContext(cfg.effective.queue.openIn)
     });
     outro3(
       `job ${result.job.id} queued (${String(result.runningCount)}/${String(result.maxConcurrent)} running); log: ${result.job.logPath}`
@@ -5756,11 +6331,19 @@ var setCommand = new Command8("set").description("Set a config key in the global
     } else {
       process.stdout.write(`${key} = ${fmtValue(r.coerced)}   (wrote ${r.path})
 `);
+      warnOnSet(key, r.coerced);
     }
   } catch (err) {
     handleError(err);
   }
 });
+function warnOnSet(key, value) {
+  if (key === "queue.openIn" && value !== "none") {
+    process.stderr.write(
+      "note: queue.openIn only opens a terminal when you submit the `-i` job from inside tmux, cmux, or iTerm2.\n      cmux: the box is opened by the relay's queue worker, a cmux-external process, so cmux's default\n      `socketControlMode: cmuxOnly` blocks it. Set `socketControlMode` to `automation` (or `password`)\n      in ~/.config/cmux/cmux.json and run `cmux reload-config` for cmux opens to work.\n"
+    );
+  }
+}
 var unsetCommand = new Command8("unset").description("Remove a config key from the global or per-project file (default: --project)").argument("<key>", "dot-path key (e.g. box.hostSnapshot)").option("--global", "edit ~/.agentbox/config.yaml").option("--project", "edit ~/.agentbox/projects/<hash>/config.yaml (default)").action(async (key, opts) => {
   const scope = resolveWriteScope(opts);
   try {
@@ -5898,8 +6481,51 @@ function handleError(err) {
 var configCommand = new Command8("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 { resolve as resolve3 } from "path";
 import { log as log15 } from "@clack/prompts";
 import { Command as Command9 } from "commander";
+function collectExclude(val, acc) {
+  acc.push(val);
+  return acc;
+}
+async function guardUploadSize(hostSrc, boxDst, opts) {
+  const tokens = effectiveExcludes(opts.exclude, opts.defaultExcludes);
+  const tarPatterns = toTarExcludes(tokens);
+  const cfg = await loadEffectiveConfig(process.cwd());
+  const maxBytes = cfg.effective.box.cpMaxBytes;
+  const absSrc = resolve3(hostSrc);
+  const measured = await measureCopy(absSrc, tokens);
+  if (opts.yes || measured.totalBytes <= maxBytes) {
+    return tarPatterns;
+  }
+  const dropped = measured.isDir && opts.defaultExcludes ? ` after default excludes (${effectiveExcludes([], true).join(", ")})` : "";
+  const lines = [
+    `${hostSrc} is ${fmtBytes(measured.totalBytes)}${dropped}, over the ${fmtBytes(maxBytes)} per-copy limit.`
+  ];
+  if (measured.isDir) {
+    lines.push(
+      "Biggest remaining folders/subfolders:",
+      ...measured.treeLines,
+      "Each copy must be under the limit. To proceed, EITHER:",
+      "  - copy the heavy folders one at a time, e.g.:"
+    );
+    for (const child of measured.topChildren.slice(0, 3)) {
+      lines.push(`      agentbox cp ${hostSrc}/${child.path} ${boxDst}`);
+    }
+    lines.push(
+      "  - or drop what you do not need:",
+      `      agentbox cp ${hostSrc} ${boxDst} --exclude=<dir>`,
+      "  - or copy the whole thing anyway:",
+      `      agentbox cp ${hostSrc} ${boxDst} --yes`
+    );
+  } else {
+    lines.push(
+      "A single file cannot be split or trimmed. To copy it anyway:",
+      `      agentbox cp ${hostSrc} ${boxDst} --yes`
+    );
+  }
+  throw new Error(lines.join("\n"));
+}
 function parseBoxArg(arg) {
   const idx = arg.indexOf(":");
   if (idx === -1) return null;
@@ -5944,7 +6570,15 @@ function parseArgs(src, dst) {
 var cpCommand = new Command9("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(
+).option(
+  "--exclude <pattern>",
+  'exclude paths matching <pattern> (repeatable; tar glob like "*/foo" or a bare dir name)',
+  collectExclude,
+  []
+).option(
+  "--no-default-excludes",
+  `keep the heavy dirs cp drops by default (${effectiveExcludes([], true).join(", ")})`
+).option("-y, --yes", "copy even if the source is over the box.cpMaxBytes size limit").addHelpText(
   "after",
   [
     "",
@@ -5952,27 +6586,30 @@ var cpCommand = new Command9("cp").description("Copy files between host and box
     "  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)"
+    "  agentbox cp ./dir mybox:/workspace/         # upload directory (recursive)",
+    '  agentbox cp ./dir mybox:/workspace/ --exclude=.git --exclude="*/cache"'
   ].join("\n")
-).action(async (src, dst) => {
+).action(async (src, dst, opts) => {
   try {
     const parsed = parseArgs(src, dst);
     const box = await resolveBoxOrExit(parsed.boxRef);
     const isCloud = (box.provider ?? "docker") !== "docker";
+    const tarPatterns = parsed.direction === "upload" ? await guardUploadSize(parsed.hostPath, `${parsed.boxRef}:${parsed.boxPath}`, opts) : toTarExcludes(effectiveExcludes(opts.exclude, opts.defaultExcludes));
     if (isCloud) {
       const provider = await providerForBox(box);
       if (!provider.uploadPath || !provider.downloadPath) {
         throw new Error(`provider '${provider.name}' does not support cp`);
       }
       if (parsed.direction === "upload") {
-        const result = await provider.uploadPath(box, parsed.hostPath, parsed.boxPath);
+        const result = await provider.uploadPath(box, parsed.hostPath, parsed.boxPath, tarPatterns);
         process.stdout.write(`copied to ${box.name}:${result.finalPath}
 `);
       } else {
         const result = await provider.downloadPath(
           box,
           parsed.boxPath,
-          parsed.hostPath ?? process.cwd()
+          parsed.hostPath ?? process.cwd(),
+          tarPatterns
         );
         process.stdout.write(`copied to ${result.finalPath}
 `);
@@ -5990,7 +6627,7 @@ var cpCommand = new Command9("cp").description("Copy files between host and box
       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);
+      const result = await uploadToBox(box, parsed.hostPath, parsed.boxPath, tarPatterns);
       if (result.warn) {
         log15.warn(`copied to ${box.name}:${result.finalPath}, but ${result.warn}`);
       } else {
@@ -5998,7 +6635,12 @@ var cpCommand = new Command9("cp").description("Copy files between host and box
 `);
       }
     } else {
-      const result = await downloadFromBox(box, parsed.boxPath, parsed.hostPath ?? process.cwd());
+      const result = await downloadFromBox(
+        box,
+        parsed.boxPath,
+        parsed.hostPath ?? process.cwd(),
+        tarPatterns
+      );
       process.stdout.write(`copied to ${result.finalPath}
 `);
     }
@@ -6189,12 +6831,14 @@ var createCommand = new Command10("create").description(
   const effectiveCheckpointRef = wiz.discardCheckpoint ? void 0 : checkpointRef;
   if (wiz.action === "switch-to-claude" && isDocker) {
     process.env[WIZARD_AUTOLAUNCH_ENV] = "1";
+    if (wiz.recreate) process.env[WIZARD_RECREATE_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_RECREATE_ENV];
       delete process.env[WIZARD_ENV_FILES_ENV];
     }
     return;
@@ -6320,7 +6964,7 @@ var createCommand = new Command10("create").description(
     }
     outro4("done");
     if (attachClaudeAfter) {
-      const { cloudAgentAttach: cloudAgentAttach2 } = await import("./_cloud-attach-GUBB5RH2.js");
+      const { cloudAgentAttach: cloudAgentAttach2 } = await import("./_cloud-attach-R6TRWG5L.js");
       await cloudAgentAttach2({
         box: result.record,
         binary: "claude",
@@ -6953,8 +7597,8 @@ var Compositor = class {
     this.drawChrome();
     this.scheduleRender();
     this.pollTimer = setInterval(() => void this.poll(), POLL_MS);
-    await new Promise((resolve4) => {
-      this.resolveDone = resolve4;
+    await new Promise((resolve5) => {
+      this.resolveDone = resolve5;
     });
   }
   async refreshBoxes() {
@@ -9332,114 +9976,6 @@ function resolveToken(raw) {
   return `<${raw}>`;
 }
 
-// src/lib/drive/tmux.ts
-var TMUX_USER = "vscode";
-async function captureSession(provider, box, session, opts = {}) {
-  const argv2 = ["tmux", "capture-pane", opts.ansi ? "-pe" : "-p", "-t", session];
-  if (opts.rows) {
-    argv2.push("-S", String(opts.rows.from), "-E", String(opts.rows.to));
-  }
-  const res = await provider.exec(box, argv2, { user: TMUX_USER });
-  if (res.exitCode !== 0) {
-    throw new Error(failure("capture-pane", session, res.stderr || res.stdout));
-  }
-  return res.stdout.replace(/\n$/, "");
-}
-async function paneInfo(provider, box, session) {
-  const fmt = "#{pane_width},#{pane_height},#{cursor_x},#{cursor_y}";
-  const res = await provider.exec(box, ["tmux", "display-message", "-p", "-t", session, fmt], {
-    user: TMUX_USER
-  });
-  if (res.exitCode !== 0) {
-    throw new Error(failure("display-message", session, res.stderr || res.stdout));
-  }
-  const m = /^(\d+),(\d+),(\d+),(\d+)/.exec(res.stdout.trim());
-  if (!m) throw new Error(`tmux display-message returned unexpected output: ${res.stdout}`);
-  return {
-    cols: Number(m[1]),
-    rows: Number(m[2]),
-    cursor: { x: Number(m[3]), y: Number(m[4]) }
-  };
-}
-async function sendLiteral(provider, box, session, literal) {
-  if (literal.length === 0) return;
-  const res = await provider.exec(box, ["tmux", "send-keys", "-t", session, "-l", "--", literal], {
-    user: TMUX_USER
-  });
-  if (res.exitCode !== 0) {
-    throw new Error(failure("send-keys -l", session, res.stderr || res.stdout));
-  }
-}
-async function sendKey(provider, box, session, key) {
-  const res = await provider.exec(box, ["tmux", "send-keys", "-t", session, key], {
-    user: TMUX_USER
-  });
-  if (res.exitCode !== 0) {
-    throw new Error(failure("send-keys", session, res.stderr || res.stdout));
-  }
-}
-async function resizeWindow(provider, box, session, cols, rows) {
-  const res = await provider.exec(
-    box,
-    ["tmux", "resize-window", "-t", session, "-x", String(cols), "-y", String(rows)],
-    { user: TMUX_USER }
-  );
-  if (res.exitCode !== 0) {
-    throw new Error(failure("resize-window", session, res.stderr || res.stdout));
-  }
-}
-async function listSessions(provider, box) {
-  const res = await provider.exec(
-    box,
-    ["tmux", "list-sessions", "-F", "#{session_name}"],
-    { user: TMUX_USER }
-  );
-  if (res.exitCode !== 0) return [];
-  return res.stdout.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
-}
-function failure(op, session, detail) {
-  const tail = detail.trim();
-  return `tmux ${op} failed for session '${session}'${tail ? `: ${tail}` : ""}`;
-}
-
-// src/lib/drive/session.ts
-var AGENT_SESSION_PRIORITY = ["claude", "codex", "opencode"];
-async function resolveDriveSession(provider, box, explicit) {
-  if (await provider.probeState(box) === "paused") {
-    process.stderr.write(`drive: box ${box.name} is paused; unpausing
-`);
-    await provider.resume(box);
-  }
-  const sessions = await listSessions(provider, box);
-  if (explicit !== void 0 && explicit !== "") {
-    if (!sessions.includes(explicit)) {
-      throw new SessionNotFoundError(explicit, sessions);
-    }
-    return { name: explicit, available: sessions };
-  }
-  for (const candidate of AGENT_SESSION_PRIORITY) {
-    if (sessions.includes(candidate)) {
-      return { name: candidate, available: sessions };
-    }
-  }
-  if (sessions.length === 1 && sessions[0]) {
-    return { name: sessions[0], available: sessions };
-  }
-  throw new SessionNotFoundError(void 0, sessions);
-}
-var SessionNotFoundError = class extends Error {
-  wanted;
-  available;
-  constructor(wanted, available) {
-    const head = wanted ? `no tmux session '${wanted}' in this box` : "no agent tmux session running in this box";
-    const tail = available.length ? ` (running: ${available.join(", ")})` : " (tmux server not running or no sessions)";
-    super(head + tail);
-    this.name = "SessionNotFoundError";
-    this.wanted = wanted;
-    this.available = available;
-  }
-};
-
 // src/commands/drive.ts
 var PROMPT_ENTER_DELAY_MS = 200;
 var POLL_INTERVAL_MS2 = 250;
@@ -9507,7 +10043,7 @@ var drivePromptCommand = new Command24("prompt").description('Type text into the
     const session = await resolveDriveSession(provider, box, opts.session);
     const delay = opts.delay !== void 0 ? parsePositiveInt2(opts.delay, "--delay") : PROMPT_ENTER_DELAY_MS;
     await sendLiteral(provider, box, session.name, text);
-    if (delay > 0) await sleep2(delay);
+    if (delay > 0) await sleep3(delay);
     await sendKey(provider, box, session.name, "Enter");
   } catch (err) {
     handleDriveError(err);
@@ -9533,7 +10069,7 @@ var driveWaitCommand = new Command24("wait").description("Block until --text app
         }
         return;
       }
-      await sleep2(POLL_INTERVAL_MS2);
+      await sleep3(POLL_INTERVAL_MS2);
     }
     const elapsedMs = Date.now() - start;
     if (opts.json === true) {
@@ -9593,7 +10129,7 @@ function parsePositiveInt2(raw, label) {
   }
   return n;
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
@@ -9602,7 +10138,7 @@ import { log as log30 } from "@clack/prompts";
 import { Command as Command25 } from "commander";
 import { existsSync as existsSync5, readdirSync, statSync } from "fs";
 import { homedir as homedir12 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var FORK_AGENTS = ["claude", "codex", "opencode"];
 var AGENT_COMMAND = {
   claude: claudeCommand,
@@ -9622,12 +10158,12 @@ function resolveSessionArgs(agent, opts) {
   }
   if (opts.session) return ["--resume", opts.session];
   if (agent === "codex") return ["--continue"];
-  const dir = join14(homedir12(), ".claude", "projects", encodeClaudeProjectsDir(opts.workspace));
+  const dir = join15(homedir12(), ".claude", "projects", encodeClaudeProjectsDir(opts.workspace));
   if (!existsSync5(dir)) return ["--continue"];
   const now = Date.now();
   const recent = readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
     try {
-      return statSync(join14(dir, f)).mtimeMs;
+      return statSync(join15(dir, f)).mtimeMs;
     } catch {
       return 0;
     }
@@ -9738,13 +10274,13 @@ import {
   writeFileSync as writeFileSync5
 } from "fs";
 import { homedir as homedir16 } from "os";
-import { dirname as dirname3, join as join18, resolve as resolve3, sep } from "path";
+import { dirname as dirname3, join as join19, resolve as resolve4, sep } from "path";
 import { fileURLToPath } from "url";
 
 // src/lib/doctor-checks.ts
 import { accessSync, constants as fsConstants, mkdirSync as mkdirSync3 } from "fs";
 import { homedir as homedir13 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { execa as execa3 } from "execa";
 var ALL_PROVIDERS = ["docker", "daytona", "hetzner", "vercel", "e2b"];
 var NODE_MIN_MAJOR = 20;
@@ -9764,12 +10300,12 @@ function parseNodeMajorMinor(v) {
   if (!m) return [0, 0];
   return [Number(m[1]), Number(m[2])];
 }
-function firstLine(s) {
+function firstLine2(s) {
   const i = s.indexOf("\n");
   return i === -1 ? s : s.slice(0, i);
 }
 function errSummary(err) {
-  return err instanceof Error ? firstLine(err.message) : String(err);
+  return err instanceof Error ? firstLine2(err.message) : String(err);
 }
 function checkNode() {
   const v = process.versions.node;
@@ -9792,7 +10328,7 @@ function checkPlatform() {
   };
 }
 function checkAgentboxHome() {
-  const dir = join15(homedir13(), ".agentbox");
+  const dir = join16(homedir13(), ".agentbox");
   try {
     mkdirSync3(dir, { recursive: true });
     accessSync(dir, fsConstants.W_OK);
@@ -9864,7 +10400,7 @@ async function dockerChecks() {
     ];
   }
   const daemonRes = { label: "docker daemon", status: "ok", detail: "reachable" };
-  const mod = await import("./dist-4DPOL5A7.js");
+  const mod = await import("./dist-OGJGZETZ.js");
   let imgRes;
   try {
     const img = await mod.imageInfo(mod.DEFAULT_BOX_IMAGE);
@@ -9895,7 +10431,7 @@ async function dockerChecks() {
 }
 async function daytonaChecks() {
   try {
-    const mod = await import("./dist-3IMQNTTV.js");
+    const mod = await import("./dist-FIFEFKJ7.js");
     const status = await mod.getDaytonaStatus();
     if (!status.configured) {
       return [
@@ -9931,7 +10467,7 @@ async function daytonaChecks() {
 }
 async function hetznerChecks() {
   try {
-    const mod = await import("./dist-J2IHD5T7.js");
+    const mod = await import("./dist-AGTIA7AD.js");
     const cred = mod.readHetznerCredStatus();
     const credRes = cred.source === "none" ? {
       label: "credentials",
@@ -9963,7 +10499,7 @@ async function hetznerChecks() {
 }
 async function vercelChecks() {
   try {
-    const mod = await import("./dist-57M6ZA7H.js");
+    const mod = await import("./dist-S4XR4ACV.js");
     const cred = mod.readVercelCredStatus();
     const credRes = cred.auth === "none" ? {
       label: "credentials",
@@ -9999,7 +10535,7 @@ async function vercelChecks() {
 }
 async function e2bChecks() {
   try {
-    const mod = await import("./dist-34RKQ74M.js");
+    const mod = await import("./dist-JZ3XO6EB.js");
     const cred = mod.readE2bCredStatus();
     const credRes = cred.auth === "none" ? {
       label: "credentials",
@@ -10130,10 +10666,10 @@ function formatDetailed(groups) {
 // src/lib/first-run.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir14 } from "os";
-import { dirname, join as join16 } from "path";
+import { dirname, join as join17 } from "path";
 var MARKER_VERSION = 1;
 function setupMarkerPath() {
-  return join16(homedir14(), ".agentbox", "setup-complete.json");
+  return join17(homedir14(), ".agentbox", "setup-complete.json");
 }
 function isFirstRun() {
   return !existsSync6(setupMarkerPath());
@@ -10154,12 +10690,12 @@ import { intro as intro6, log as log31, note as note2, outro as outro5 } from "@
 import { Command as Command26 } from "commander";
 import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir15 } from "os";
-import { dirname as dirname2, join as join17 } from "path";
+import { dirname as dirname2, join as join18 } from "path";
 var CONTROL_ID = "agentbox";
 function cmuxDockPath(env = process.env) {
   const xdg = env["XDG_CONFIG_HOME"];
-  const base = xdg && xdg.length > 0 ? xdg : join17(homedir15(), ".config");
-  return join17(base, "cmux", "dock.json");
+  const base = xdg && xdg.length > 0 ? xdg : join18(homedir15(), ".config");
+  return join18(base, "cmux", "dock.json");
 }
 function upsertAgentboxControl(doc, opts) {
   const controls = Array.isArray(doc.controls) ? doc.controls : [];
@@ -10251,7 +10787,7 @@ var SYNC_END2 = "\x1B[?2026l";
 var HIDE_CURSOR = "\x1B[?25l";
 var SHOW_CURSOR = "\x1B[?25h";
 var SPIN = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep4 = (ms) => new Promise((r) => setTimeout(r, ms));
 function shineColor(dist) {
   const d = Math.abs(dist);
   if (d === 0) return 231;
@@ -10301,11 +10837,11 @@ ${HIDE_CURSOR}`);
     statusLine2(spin) + "\x1B[3A\r" + // back up to the logo's first row
     SYNC_END2;
     process.stdout.write(frame);
-    await sleep3(frameMs);
+    await sleep4(frameMs);
   }
   process.stdout.write(SYNC_BEGIN2 + `\x1B[38;5;39m${LOGO_L1}
 ${LOGO_L2}\x1B[0m` + SYNC_END2);
-  await sleep3(250);
+  await sleep4(250);
   process.stdout.write(SYNC_BEGIN2 + "\n\x1B[2K\n\x1B[2K" + SHOW_CURSOR + SYNC_END2);
   process.removeListener("exit", restoreCursor);
   process.removeListener("SIGINT", onSigint);
@@ -10313,30 +10849,30 @@ ${LOGO_L2}\x1B[0m` + SYNC_END2);
 var LEGACY_INFO_MARKER = "Drive AgentBox from the host:";
 function installTargets() {
   const home = homedir16();
-  const claudeSkills = join18(home, ".claude", "skills");
+  const claudeSkills = join19(home, ".claude", "skills");
   return [
-    { src: join18("agentbox", "SKILL.md"), dest: join18(claudeSkills, "agentbox", "SKILL.md") },
+    { src: join19("agentbox", "SKILL.md"), dest: join19(claudeSkills, "agentbox", "SKILL.md") },
     {
-      src: join18("agentbox-info", "SKILL.md"),
-      dest: join18(claudeSkills, "agentbox-info", "SKILL.md")
+      src: join19("agentbox-info", "SKILL.md"),
+      dest: join19(claudeSkills, "agentbox-info", "SKILL.md")
     },
     {
-      src: join18("codex", "agentbox.md"),
-      dest: join18(home, ".codex", "prompts", "agentbox.md"),
-      gateDir: join18(home, ".codex")
+      src: join19("codex", "agentbox.md"),
+      dest: join19(home, ".codex", "prompts", "agentbox.md"),
+      gateDir: join19(home, ".codex")
     },
     {
-      src: join18("opencode", "agentbox.md"),
-      dest: join18(home, ".config", "opencode", "commands", "agentbox.md"),
-      gateDir: join18(home, ".config", "opencode")
+      src: join19("opencode", "agentbox.md"),
+      dest: join19(home, ".config", "opencode", "commands", "agentbox.md"),
+      gateDir: join19(home, ".config", "opencode")
     }
   ];
 }
 function resolveHostSkillsDir() {
   const here = dirname3(fileURLToPath(import.meta.url));
   const candidates = [
-    resolve3(here, "..", "share", "host-skills"),
-    resolve3(here, "..", "..", "share", "host-skills")
+    resolve4(here, "..", "share", "host-skills"),
+    resolve4(here, "..", "..", "share", "host-skills")
   ];
   for (const c of candidates) {
     if (existsSync8(c)) return c;
@@ -10375,7 +10911,7 @@ function installHostSkills(opts = {}) {
   const blocked = [];
   let skipped = 0;
   for (const t of installTargets()) {
-    const src = join18(srcDir, t.src);
+    const src = join19(srcDir, t.src);
     if (!existsSync8(src)) {
       if (!quiet) log32.warn(`bundled file missing (skipped): ${src}`);
       skipped++;
@@ -10397,7 +10933,7 @@ function installHostSkills(opts = {}) {
     mkdirSync6(dirname3(t.dest), { recursive: true });
     if (link) {
       rmSync(t.dest, { force: true });
-      symlinkSync2(resolve3(srcDir, t.src), t.dest);
+      symlinkSync2(resolve4(srcDir, t.src), t.dest);
     } else {
       if (isSymlink(t.dest)) rmSync(t.dest, { force: true });
       writeFileSync5(t.dest, readFileSync2(src, "utf8"));
@@ -10430,7 +10966,7 @@ function ensureTty() {
 async function runProviderLogin(name) {
   if (name === "docker") return true;
   if (name === "daytona") {
-    const mod2 = await import("./dist-3IMQNTTV.js");
+    const mod2 = await import("./dist-FIFEFKJ7.js");
     const status2 = await mod2.getDaytonaStatus();
     if (status2.configured) {
       log32.info("daytona: already configured");
@@ -10443,7 +10979,7 @@ async function runProviderLogin(name) {
     return true;
   }
   if (name === "hetzner") {
-    const mod2 = await import("./dist-J2IHD5T7.js");
+    const mod2 = await import("./dist-AGTIA7AD.js");
     const status2 = mod2.readHetznerCredStatus();
     if (status2.source !== "none") {
       log32.info("hetzner: already configured");
@@ -10456,7 +10992,7 @@ async function runProviderLogin(name) {
     return true;
   }
   if (name === "vercel") {
-    const mod2 = await import("./dist-57M6ZA7H.js");
+    const mod2 = await import("./dist-S4XR4ACV.js");
     const status2 = mod2.readVercelCredStatus();
     if (status2.auth !== "none") {
       log32.info(`vercel: already configured (${status2.auth})`);
@@ -10468,7 +11004,7 @@ async function runProviderLogin(name) {
     await mod2.ensureVercelCredentials();
     return true;
   }
-  const mod = await import("./dist-34RKQ74M.js");
+  const mod = await import("./dist-JZ3XO6EB.js");
   const status = mod.readE2bCredStatus();
   if (status.auth !== "none") {
     log32.info(`e2b: already configured (${status.auth})`);
@@ -10868,17 +11404,17 @@ async function applyLiveCloudStates(boxes) {
   );
 }
 function withTimeout(p, ms) {
-  return new Promise((resolve4) => {
-    const t = setTimeout(() => resolve4(null), ms);
+  return new Promise((resolve5) => {
+    const t = setTimeout(() => resolve5(null), ms);
     if (typeof t.unref === "function") t.unref();
     p.then(
       (v) => {
         clearTimeout(t);
-        resolve4(v);
+        resolve5(v);
       },
       () => {
         clearTimeout(t);
-        resolve4(null);
+        resolve5(null);
       }
     );
   });
@@ -10932,7 +11468,7 @@ async function watchRender(produce, rawInterval, opts = {}) {
     process.once("SIGINT", () => process.exit(0));
   }
   const hint = interactive ? "q or Ctrl-C to exit" : "Ctrl-C to exit";
-  const sleep5 = (d) => new Promise((r) => {
+  const sleep6 = (d) => new Promise((r) => {
     const t = setTimeout(() => {
       wake = null;
       r();
@@ -10963,7 +11499,7 @@ async function watchRender(produce, rawInterval, opts = {}) {
 ${trimmed}
 `);
     }
-    await sleep5(ms);
+    await sleep6(ms);
     if (exiting) {
       restore();
       process.exit(0);
@@ -11338,7 +11874,7 @@ import { log as log35 } from "@clack/prompts";
 import { execa as execa4 } from "execa";
 import { existsSync as existsSync9, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir17 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 import { Command as Command32 } from "commander";
 
 // src/commands/path.ts
@@ -11400,7 +11936,7 @@ var openCommand = new Command32("open").description("Open a box's /workspace in
   }
 });
 async function runCloudOpen(box, provider, opts) {
-  const mountRoot = join19(homedir17(), ".agentbox", "mounts", box.name);
+  const mountRoot = join20(homedir17(), ".agentbox", "mounts", box.name);
   if (opts.unmount) {
     const ok = await tryUnmount(mountRoot);
     if (ok) process.stdout.write(`unmounted ${mountRoot}
@@ -11674,7 +12210,7 @@ async function pruneCloud(provider, opts) {
 }
 
 // src/commands/queue.ts
-import { readFile as readFile5, stat as stat5 } from "fs/promises";
+import { readFile as readFile5, stat as stat6 } from "fs/promises";
 import { intro as intro8, log as log37, outro as outro7 } from "@clack/prompts";
 import { Command as Command35 } from "commander";
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["done", "failed", "cancelled"]);
@@ -11721,7 +12257,7 @@ var queueShowCommand = new Command35("show").description("Dump a job manifest an
   process.stdout.write(JSON.stringify(job, null, 2) + "\n");
   const tailN = Number.parseInt(opts.tail, 10) || 50;
   try {
-    await stat5(job.logPath);
+    await stat6(job.logPath);
     const text = await readFile5(job.logPath, "utf8");
     const lines = text.split(/\r?\n/);
     const slice = lines.slice(Math.max(0, lines.length - tailN - 1));
@@ -11873,11 +12409,11 @@ async function pollUntil(deadline, probe) {
     if (result !== void 0) return result;
     const remaining = deadline - Date.now();
     if (remaining <= 0) break;
-    await sleep4(Math.min(QUEUE_POLL_INTERVAL_MS, remaining));
+    await sleep5(Math.min(QUEUE_POLL_INTERVAL_MS, remaining));
   }
   throw new QueueWaitTimeout();
 }
-function sleep4(ms) {
+function sleep5(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 function parsePositiveInt3(raw, label) {
@@ -11927,7 +12463,8 @@ async function rehydrateFromState() {
       cloudBackend: b.cloud?.backend,
       relayPreviewUrl: b.cloud?.relayPreviewUrl,
       relayPreviewToken: b.cloud?.relayPreviewToken,
-      bridgeToken: b.cloud?.bridgeToken
+      bridgeToken: b.cloud?.bridgeToken,
+      autoApproveHostActions: b.autoApproveHostActions
     }))
   );
 }
@@ -12149,6 +12686,36 @@ async function runDockerJob(job, log47, onBoxCreated) {
   } else {
     throw new Error(`unknown agent kind: ${String(job.agent)}`);
   }
+  await maybeOpenQueuedTerminal(job, result.record.name, log47);
+}
+function agentBinaryName(agent) {
+  return agent === "claude-code" ? "claude" : agent;
+}
+async function maybeOpenQueuedTerminal(job, boxName, log47) {
+  const ctx = job.openTerminal;
+  if (!ctx) return;
+  const cliEntry = process.env["AGENTBOX_CLI_ENTRY"];
+  if (!cliEntry) {
+    log47.write("queue.openIn: AGENTBOX_CLI_ENTRY unset; cannot open terminal");
+    return;
+  }
+  const argv2 = [
+    process.execPath,
+    cliEntry,
+    agentBinaryName(job.agent),
+    "attach",
+    boxName,
+    "--attach-in",
+    "same"
+  ];
+  try {
+    const r = await spawnQueuedOpenTerminal(ctx, argv2, boxName);
+    log47.write(
+      r.launched ? `queue.openIn: ${r.note}` : `queue.openIn: open failed: ${r.error ?? ""}`
+    );
+  } catch (err) {
+    log47.write(`queue.openIn: open threw: ${err instanceof Error ? err.message : String(err)}`);
+  }
 }
 async function runCloudJob(job, log47, onBoxCreated) {
   const opts = job.createOpts;
@@ -12206,6 +12773,7 @@ async function runCloudJob(job, log47, onBoxCreated) {
     sessionName,
     extraArgs
   });
+  await maybeOpenQueuedTerminal(job, result.record.name, log47);
 }
 function buildOverridesFromJob(job) {
   const opts = job.createOpts;
@@ -12757,12 +13325,12 @@ async function renderText(i) {
     `env files     ${i.record.withEnv ? "yes" : "no"}`,
     "endpoints",
     ...renderEndpoints(i),
-    `mem limit     ${lim?.memoryBytes ? fmtBytes(lim.memoryBytes) : "unlimited"}`,
+    `mem limit     ${lim?.memoryBytes ? fmtBytes2(lim.memoryBytes) : "unlimited"}`,
     `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)"}`,
-    `snapshot size ${fmtBytes(i.snapshotSizeBytes)}`,
+    `snapshot size ${fmtBytes2(i.snapshotSizeBytes)}`,
     `checkpoint    ${renderCheckpoint(i, ckptBytes)}`,
     `host export   ${i.hostPaths.mergedExport}  (run \`agentbox open\` to refresh)`,
     `created       ${i.record.createdAt}`
@@ -12772,7 +13340,7 @@ async function renderText(i) {
 function renderCheckpoint(i, sizeBytes) {
   const src = i.record.checkpointSource;
   if (!src || !i.record.checkpointImage) return "(none)";
-  const sizePart = sizeBytes !== null ? ` ${fmtBytes(sizeBytes)}` : "";
+  const sizePart = sizeBytes !== null ? ` ${fmtBytes2(sizeBytes)}` : "";
   return `${src.ref} (${src.type}, chain ${src.chain.length}) \u2192 ${i.record.checkpointImage}${sizePart}`;
 }
 function renderClaudeSession(i) {
@@ -12843,7 +13411,7 @@ async function renderCloudText(box) {
     `bridge token  ${box.cloud?.bridgeToken ? "(set)" : "(unset)"}`,
     `playwright    ${box.withPlaywright ? "yes" : "no"}`,
     `env files     ${box.withEnv ? "yes" : "no"}`,
-    `mem limit     ${lim?.memoryBytes ? fmtBytes(lim.memoryBytes) : "unlimited"}`,
+    `mem limit     ${lim?.memoryBytes ? fmtBytes2(lim.memoryBytes) : "unlimited"}`,
     `cpu limit     ${fmtLimit(lim?.cpus, "")}`,
     `pids limit    ${fmtLimit(lim?.pidsLimit, "")}`,
     `persisted     ${persisted ? `${persisted.timestamp} (${String(persisted.services.length)} svc, ${String(persisted.tasks.length)} tasks, ${String(persisted.ports.length)} ports)` : "(none)"}`,
@@ -13004,20 +13572,20 @@ function renderResources(s) {
   if (s.live) {
     seg.push(`cpu ${fmtPercent(s.cpuPercent)}${lim(s.limits.cpus)}`);
     seg.push(
-      `mem ${fmtBytes(s.memUsedBytes)} / ${fmtBytes(s.memLimitBytes)} (${fmtPercent(s.memPercent)})${lim(s.limits.memoryBytes ? fmtBytes(s.limits.memoryBytes) : null)}`
+      `mem ${fmtBytes2(s.memUsedBytes)} / ${fmtBytes2(s.memLimitBytes)} (${fmtPercent(s.memPercent)})${lim(s.limits.memoryBytes ? fmtBytes2(s.limits.memoryBytes) : null)}`
     );
     seg.push(`pids ${s.pids === null ? "\u2014" : String(s.pids)}${lim(s.limits.pidsLimit)}`);
   } else {
     seg.push("not running");
-    if (s.limits.memoryBytes) seg.push(`mem limit ${fmtBytes(s.limits.memoryBytes)}`);
+    if (s.limits.memoryBytes) seg.push(`mem limit ${fmtBytes2(s.limits.memoryBytes)}`);
     if (s.limits.cpus) seg.push(`cpu limit ${String(s.limits.cpus)}`);
     if (s.limits.pidsLimit) seg.push(`pids limit ${String(s.limits.pidsLimit)}`);
   }
   seg.push(
-    `disk ${fmtBytes(s.diskUsedBytes)}${s.limits.disk ? ` (limit ${s.limits.disk}, no-op on overlay2/macOS)` : ""}`
+    `disk ${fmtBytes2(s.diskUsedBytes)}${s.limits.disk ? ` (limit ${s.limits.disk}, no-op on overlay2/macOS)` : ""}`
   );
-  if (s.snapshotDiskBytes !== null) seg.push(`snapshot ${fmtBytes(s.snapshotDiskBytes)}`);
-  if (s.checkpointVolumeBytes !== null) seg.push(`ckpt ${fmtBytes(s.checkpointVolumeBytes)}`);
+  if (s.snapshotDiskBytes !== null) seg.push(`snapshot ${fmtBytes2(s.snapshotDiskBytes)}`);
+  if (s.checkpointVolumeBytes !== null) seg.push(`ckpt ${fmtBytes2(s.checkpointVolumeBytes)}`);
   let line = `  ${seg.join("  ")}`;
   for (const w of s.warnings) line += `
   note: ${w}`;
@@ -13114,8 +13682,8 @@ restart with: agentbox start ${box.name}
 import { Command as Command43 } 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)}`;
-  const net = s.netRxBytes === null && s.netTxBytes === null ? "\u2014" : `${fmtBytes(s.netRxBytes)} / ${fmtBytes(s.netTxBytes)}`;
+  const mem = `${fmtBytes2(s.memUsedBytes)} / ${fmtBytes2(s.memLimitBytes)}`;
+  const net = s.netRxBytes === null && s.netTxBytes === null ? "\u2014" : `${fmtBytes2(s.netRxBytes)} / ${fmtBytes2(s.netTxBytes)}`;
   return [
     name,
     state,
@@ -13123,7 +13691,7 @@ function row(name, state, s) {
     s.live ? mem : "\u2014",
     fmtPercent(s.memPercent),
     s.pids === null ? "\u2014" : String(s.pids),
-    fmtBytes(s.diskUsedBytes),
+    fmtBytes2(s.diskUsedBytes),
     s.live ? net : "\u2014"
   ];
 }
@@ -13179,8 +13747,8 @@ async function renderProjectFooters() {
     allCheckpointImagesBytes(),
     agentboxHomeBytes()
   ]);
-  if (home !== null) parts.push(`~/.agentbox: ${fmtBytes(home)}`);
-  if (ckpt !== null) parts.push(`checkpoints: ${fmtBytes(ckpt)}`);
+  if (home !== null) parts.push(`~/.agentbox: ${fmtBytes2(home)}`);
+  if (ckpt !== null) parts.push(`checkpoints: ${fmtBytes2(ckpt)}`);
   return parts.length > 0 ? `
 
 SYSTEM: ${parts.join(" - ")}` : "";