@madarco/agentbox 0.15.0 → 0.16.0

package/dist/{chunk-MLMFNN4T.js → chunk-GXJNJUEV.js}

@@ -1,15 +1,21 @@
 #!/usr/bin/env node
 import {
+  AmbiguousBoxError,
+  BoxNotFoundError,
   DEFAULT_BOX_IMAGE,
   GitWorktreeError,
+  ReplaceError,
   STATE_DIR,
   STATE_FILE,
   computeDockerContextFingerprint,
   detectGitRepos,
   ensureImage,
   findBox,
+  generateBoxId,
   hostOpenCommand,
   imageExists,
+  parseReplaceRules,
+  parseReplacements,
   pickFreshBranch,
   preparedMatches,
   pullOrBuild,
@@ -18,20 +24,22 @@ import {
   readState,
   recordBox,
   removeBoxRecord,
+  renderCarryEntries,
   reserveProjectIndex
-} from "./chunk-XKH7NTT7.js";
+} from "./chunk-DBBUDKKB.js";
 
 // ../../packages/sandbox-docker/dist/index.js
 import { mkdir as mkdir7, stat as stat8 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { basename as basename5, join as join12, resolve as resolve4 } from "path";
+import { basename as basename6, join as join12, resolve as resolve4 } from "path";
 import { execa as execa15 } from "execa";
 
 // ../../packages/ctl/dist/index.js
-import { readFile } from "fs/promises";
-import { parse as parseYaml } from "yaml";
 import { readFile as readFile2 } from "fs/promises";
 import { parse as parseYaml2 } from "yaml";
+import { parse as parseYaml } from "yaml";
+import { readFile as readFile3 } from "fs/promises";
+import { parse as parseYaml3 } from "yaml";
 var BOX_STATUS_EVENT = "box-status";
 function renderStatusTable(rows) {
   if (rows.length === 0) return "(no services configured)";
@@ -89,6 +97,20 @@ function truncate(s, n) {
   if (s.length <= n) return s;
   return s.slice(0, n - 1) + "\u2026";
 }
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseReplacementsSection(text) {
+  let doc;
+  try {
+    doc = parseYaml(text);
+  } catch (err) {
+    throw new ReplaceError(`yaml parse error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (doc === null || doc === void 0) return {};
+  if (!isPlainObject(doc)) throw new ReplaceError("top-level config must be a mapping");
+  return parseReplacements(doc.replacements);
+}
 var DEFAULT_BACKOFF = {
   initialMs: 500,
   maxMs: 3e4,
@@ -105,12 +127,12 @@ var ConfigError = class extends Error {
     this.name = "ConfigError";
   }
 };
-function isPlainObject(v) {
+function isPlainObject2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function parseEnv(raw, where) {
   if (raw === void 0 || raw === null) return void 0;
-  if (!isPlainObject(raw)) {
+  if (!isPlainObject2(raw)) {
     throw new ConfigError(`${where}.env must be a mapping of string \u2192 string`);
   }
   const out = {};
@@ -152,7 +174,7 @@ function parseRestart(raw, where) {
 var BACKOFF_KEYS = /* @__PURE__ */ new Set(["initial_ms", "max_ms", "factor"]);
 function parseBackoff(raw, where) {
   if (raw === void 0) return { ...DEFAULT_BACKOFF };
-  if (!isPlainObject(raw)) {
+  if (!isPlainObject2(raw)) {
     throw new ConfigError(`${where}.backoff must be a mapping`);
   }
   rejectUnknownKeys(raw, BACKOFF_KEYS, `${where}.backoff`);
@@ -234,7 +256,7 @@ var PROBE_KEYS = /* @__PURE__ */ new Set([
 ]);
 function parseReadyWhen(raw, where) {
   if (raw === void 0 || raw === null) return void 0;
-  if (!isPlainObject(raw)) {
+  if (!isPlainObject2(raw)) {
     throw new ConfigError(`${where}.ready_when must be a mapping`);
   }
   rejectUnknownKeys(raw, PROBE_KEYS, `${where}.ready_when`);
@@ -330,12 +352,94 @@ var SERVICE_KEYS = /* @__PURE__ */ new Set([
   "needs",
   "ready_when",
   "expose",
-  "ide"
+  "ide",
+  "image"
 ]);
+var IMAGE_KEYS = /* @__PURE__ */ new Set(["name", "ports", "env", "args", "container_name"]);
+function shQuote(s) {
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(s)) return s;
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function parsePorts(raw, where) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (!Array.isArray(raw)) {
+    throw new ConfigError(`${where}.ports must be a list of "<host>:<container>" strings`);
+  }
+  const out = [];
+  for (const [i, v] of raw.entries()) {
+    const s = typeof v === "number" ? String(v) : v;
+    if (typeof s !== "string" || !/^\d+(:\d+)?$/.test(s.trim())) {
+      throw new ConfigError(
+        `${where}.ports[${String(i)}] must be "<host>" or "<host>:<container>" (got ${JSON.stringify(v)})`
+      );
+    }
+    out.push(s.trim());
+  }
+  return out.length > 0 ? out : void 0;
+}
+function parseArgs(raw, where) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw === "string") return raw.trim().length > 0 ? raw : void 0;
+  if (Array.isArray(raw)) {
+    const parts = [];
+    for (const [i, v] of raw.entries()) {
+      if (typeof v !== "string") throw new ConfigError(`${where}.args[${String(i)}] must be a string`);
+      parts.push(v);
+    }
+    const joined = parts.join(" ").trim();
+    return joined.length > 0 ? joined : void 0;
+  }
+  throw new ConfigError(`${where}.args must be a string or a list of strings`);
+}
+function synthesizeImageCommand(opts) {
+  const name = shQuote(opts.name);
+  const run = ["docker", "run", "--name", name];
+  for (const p of opts.ports ?? []) run.push("-p", shQuote(p));
+  for (const [k, v] of Object.entries(opts.env ?? {})) run.push("-e", `${k}=${shQuote(v)}`);
+  run.push(shQuote(opts.image));
+  let runLine = run.join(" ");
+  if (opts.args) runLine += ` ${opts.args}`;
+  return [
+    "set -e",
+    `if docker container inspect ${name} >/dev/null 2>&1; then`,
+    `  docker start ${name} >/dev/null`,
+    `  exec docker logs -f ${name}`,
+    "else",
+    `  exec ${runLine}`,
+    "fi"
+  ].join("\n");
+}
+function parseImage(raw, where, defaultName) {
+  if (typeof raw === "string") {
+    const name2 = raw.trim();
+    if (name2.length === 0) throw new ConfigError(`${where}.image must not be empty`);
+    return { name: name2, containerName: defaultName };
+  }
+  if (!isPlainObject2(raw)) {
+    throw new ConfigError(`${where}.image must be an image ref string or a mapping`);
+  }
+  rejectUnknownKeys(raw, IMAGE_KEYS, `${where}.image`);
+  const name = assertString(raw.name, `${where}.image.name`).trim();
+  if (name.length === 0) throw new ConfigError(`${where}.image.name must not be empty`);
+  const ports = parsePorts(raw.ports, `${where}.image`);
+  const args = parseArgs(raw.args, `${where}.image`);
+  const env = parseEnv(raw.env, `${where}.image`);
+  const containerName = raw.container_name === void 0 ? defaultName : assertString(raw.container_name, `${where}.image.container_name`).trim();
+  if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(containerName)) {
+    throw new ConfigError(
+      `${where}.image.container_name "${containerName}" is not a valid docker container name`
+    );
+  }
+  const out = { name, containerName };
+  if (ports !== void 0) out.ports = ports;
+  if (env !== void 0) out.env = env;
+  if (args !== void 0) out.args = args;
+  return out;
+}
 var EXPOSE_KEYS = /* @__PURE__ */ new Set(["port", "as"]);
 function parseExpose(raw, where) {
   if (raw === void 0 || raw === null) return void 0;
-  if (!isPlainObject(raw)) {
+  if (!isPlainObject2(raw)) {
     throw new ConfigError(`${where}.expose must be a mapping`);
   }
   rejectUnknownKeys(raw, EXPOSE_KEYS, `${where}.expose`);
@@ -359,25 +463,78 @@ function parsePortNumber(raw, where) {
 }
 function parseService(name, raw) {
   const where = `services.${name}`;
-  if (!isPlainObject(raw)) {
+  if (!isPlainObject2(raw)) {
     throw new ConfigError(`${where} must be a mapping`);
   }
   rejectUnknownKeys(raw, SERVICE_KEYS, where);
-  const command = parseCommand(raw.command, where);
+  const hasImage = raw.image !== void 0 && raw.image !== null;
+  const hasCommand = raw.command !== void 0 && raw.command !== null;
+  if (hasImage && hasCommand) {
+    throw new ConfigError(`${where} sets both command and image \u2014 use exactly one`);
+  }
+  if (!hasImage && !hasCommand) {
+    throw new ConfigError(`${where} must set either command or image`);
+  }
   const cwd = raw.cwd === void 0 ? void 0 : assertString(raw.cwd, `${where}.cwd`);
-  const env = parseEnv(raw.env, where);
   const autostart = raw.autostart === void 0 ? true : assertBool(raw.autostart, `${where}.autostart`);
   const restart2 = parseRestart(raw.restart, where);
   const backoff = parseBackoff(raw.backoff, where);
   const needs = parseNeeds(raw.needs, `${where}.needs`);
   const readyWhen = parseReadyWhen(raw.ready_when, where);
   const expose = parseExpose(raw.expose, where);
+  if (hasImage) {
+    if (raw.env !== void 0) {
+      throw new ConfigError(`${where}.env is not valid for an image service \u2014 use image.env`);
+    }
+    const img = parseImage(raw.image, where, name);
+    const command2 = synthesizeImageCommand({
+      image: img.name,
+      name: img.containerName,
+      ports: img.ports,
+      env: img.env,
+      args: img.args
+    });
+    const spec = {
+      name,
+      command: command2,
+      cwd,
+      autostart,
+      restart: restart2,
+      backoff,
+      needs,
+      readyWhen,
+      expose,
+      image: img.name,
+      containerName: img.containerName
+    };
+    if (img.ports !== void 0) spec.ports = img.ports;
+    if (img.args !== void 0) spec.args = img.args;
+    return spec;
+  }
+  const command = parseCommand(raw.command, where);
+  const env = parseEnv(raw.env, where);
   return { name, command, cwd, env, autostart, restart: restart2, backoff, needs, readyWhen, expose };
 }
-var TASK_KEYS = /* @__PURE__ */ new Set(["command", "cwd", "env", "needs"]);
+var TASK_KEYS = /* @__PURE__ */ new Set(["command", "cwd", "env", "needs", "run_once"]);
+function parseRunOnce(raw, where) {
+  if (raw === void 0 || raw === null || raw === false) return void 0;
+  if (raw === true) return { kind: "marker" };
+  if (isPlainObject2(raw)) {
+    const keys = Object.keys(raw);
+    if (keys.length !== 1 || keys[0] !== "check") {
+      throw new ConfigError(`${where}.run_once object form must be exactly { check: <command> }`);
+    }
+    const check = raw.check;
+    if (typeof check !== "string" || check.trim().length === 0) {
+      throw new ConfigError(`${where}.run_once.check must be a non-empty command string`);
+    }
+    return { kind: "check", command: check };
+  }
+  throw new ConfigError(`${where}.run_once must be true or { check: <command> }`);
+}
 function parseTask(name, raw) {
   const where = `tasks.${name}`;
-  if (!isPlainObject(raw)) {
+  if (!isPlainObject2(raw)) {
     throw new ConfigError(`${where} must be a mapping`);
   }
   rejectUnknownKeys(raw, TASK_KEYS, where);
@@ -385,7 +542,10 @@ function parseTask(name, raw) {
   const cwd = raw.cwd === void 0 ? void 0 : assertString(raw.cwd, `${where}.cwd`);
   const env = parseEnv(raw.env, where);
   const needs = parseNeeds(raw.needs, `${where}.needs`);
-  return { name, command, cwd, env, needs };
+  const runOnce = parseRunOnce(raw.run_once, where);
+  const spec = { name, command, cwd, env, needs };
+  if (runOnce !== void 0) spec.runOnce = runOnce;
+  return spec;
 }
 function assertString(raw, where) {
   if (typeof raw !== "string") throw new ConfigError(`${where} must be a string`);
@@ -395,7 +555,7 @@ function assertBool(raw, where) {
   if (typeof raw !== "boolean") throw new ConfigError(`${where} must be a boolean`);
   return raw;
 }
-var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["services", "tasks", "ide", "defaults", "carry"]);
+var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["services", "tasks", "ide", "defaults", "carry", "replacements"]);
 function validateUnitGraph(tasks, services) {
   const names = /* @__PURE__ */ new Set();
   for (const t of tasks) {
@@ -449,19 +609,19 @@ function validateUnitGraph(tasks, services) {
 function parseConfig(text) {
   let doc;
   try {
-    doc = parseYaml(text);
+    doc = parseYaml2(text);
   } catch (err) {
     throw new ConfigError(`yaml parse error: ${err instanceof Error ? err.message : String(err)}`);
   }
-  if (doc === null || doc === void 0) return { services: [], tasks: [] };
-  if (!isPlainObject(doc)) {
+  if (doc === null || doc === void 0) return { services: [], tasks: [], replacements: {} };
+  if (!isPlainObject2(doc)) {
     throw new ConfigError("top-level config must be a mapping");
   }
   rejectUnknownKeys(doc, TOP_LEVEL_KEYS, "(root)");
   const services = [];
   const servicesRaw = doc.services;
   if (servicesRaw !== void 0 && servicesRaw !== null) {
-    if (!isPlainObject(servicesRaw)) {
+    if (!isPlainObject2(servicesRaw)) {
       throw new ConfigError("services must be a mapping of name \u2192 service");
     }
     for (const [name, raw] of Object.entries(servicesRaw)) {
@@ -474,7 +634,7 @@ function parseConfig(text) {
   const tasks = [];
   const tasksRaw = doc.tasks;
   if (tasksRaw !== void 0 && tasksRaw !== null) {
-    if (!isPlainObject(tasksRaw)) {
+    if (!isPlainObject2(tasksRaw)) {
       throw new ConfigError("tasks must be a mapping of name \u2192 task");
     }
     for (const [name, raw] of Object.entries(tasksRaw)) {
@@ -484,10 +644,10 @@ function parseConfig(text) {
       tasks.push(parseTask(name, raw));
     }
   }
-  if (doc.ide !== void 0 && doc.ide !== null && !isPlainObject(doc.ide)) {
+  if (doc.ide !== void 0 && doc.ide !== null && !isPlainObject2(doc.ide)) {
     throw new ConfigError("ide must be a mapping");
   }
-  if (doc.defaults !== void 0 && doc.defaults !== null && !isPlainObject(doc.defaults)) {
+  if (doc.defaults !== void 0 && doc.defaults !== null && !isPlainObject2(doc.defaults)) {
     throw new ConfigError("defaults must be a mapping");
   }
   validateUnitGraph(tasks, services);
@@ -497,15 +657,21 @@ function parseConfig(text) {
       `at most one service may set expose: (got: ${exposed.map((s) => s.name).join(", ")})`
     );
   }
-  return { services, tasks };
+  let replacements;
+  try {
+    replacements = parseReplacements(doc.replacements);
+  } catch (err) {
+    throw new ConfigError(err instanceof Error ? err.message : String(err));
+  }
+  return { services, tasks, replacements };
 }
 async function loadConfig(path) {
   let text;
   try {
-    text = await readFile(path, "utf8");
+    text = await readFile2(path, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
-      return { services: [], tasks: [] };
+      return { services: [], tasks: [], replacements: {} };
     }
     throw err;
   }
@@ -517,16 +683,26 @@ var CarryConfigError = class extends Error {
     this.name = "CarryConfigError";
   }
 };
-var ITEM_KEYS = /* @__PURE__ */ new Set(["src", "dest", "mode", "user", "exclude", "optional"]);
-function parseExclude(raw, where) {
+var ITEM_KEYS = /* @__PURE__ */ new Set([
+  "src",
+  "dest",
+  "mode",
+  "user",
+  "exclude",
+  "optional",
+  "replaceEnvs",
+  "replace",
+  "rules"
+]);
+function parseStringList(raw, where, desc) {
   if (raw === void 0 || raw === null) return void 0;
   if (!Array.isArray(raw)) {
-    throw new CarryConfigError(`${where}.exclude must be a list of glob/name strings`);
+    throw new CarryConfigError(`${where} must be a list of ${desc}`);
   }
   const out = [];
   for (const [i, v] of raw.entries()) {
     if (typeof v !== "string" || v.trim().length === 0) {
-      throw new CarryConfigError(`${where}.exclude[${String(i)}] must be a non-empty string`);
+      throw new CarryConfigError(`${where}[${String(i)}] must be a non-empty string`);
     }
     out.push(v.trim());
   }
@@ -556,7 +732,7 @@ function parseUser(raw, where) {
   }
   return n;
 }
-function isPlainObject2(v) {
+function isPlainObject3(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function assertSrcShape(src, where) {
@@ -660,7 +836,7 @@ function parseMapping(raw, where) {
   assertDestShape(dest, where);
   const mode = parseMode(raw.mode, where);
   const user = parseUser(raw.user, where);
-  const exclude = parseExclude(raw.exclude, where);
+  const exclude = parseStringList(raw.exclude, `${where}.exclude`, "glob/name strings");
   let optional = false;
   if (raw.optional !== void 0 && raw.optional !== null) {
     if (typeof raw.optional !== "boolean") {
@@ -668,10 +844,30 @@ function parseMapping(raw, where) {
     }
     optional = raw.optional;
   }
+  let replaceEnvs;
+  if (raw.replaceEnvs !== void 0 && raw.replaceEnvs !== null) {
+    if (typeof raw.replaceEnvs !== "boolean") {
+      throw new CarryConfigError(`${where}.replaceEnvs must be a boolean`);
+    }
+    replaceEnvs = raw.replaceEnvs;
+  }
+  let replace;
+  if (raw.replace !== void 0 && raw.replace !== null) {
+    try {
+      const rules2 = parseReplaceRules(raw.replace, `${where}.replace`);
+      if (rules2.length > 0) replace = rules2;
+    } catch (err) {
+      throw new CarryConfigError(err instanceof Error ? err.message : String(err));
+    }
+  }
+  const rules = parseStringList(raw.rules, `${where}.rules`, "replacements rule-set names");
   const out = { src, dest, optional };
   if (mode !== void 0) out.mode = mode;
   if (user !== void 0) out.user = user;
   if (exclude !== void 0) out.exclude = exclude;
+  if (replaceEnvs !== void 0) out.replaceEnvs = replaceEnvs;
+  if (replace !== void 0) out.replace = replace;
+  if (rules !== void 0) out.rules = rules;
   return out;
 }
 function parseCarryRaw(raw) {
@@ -684,7 +880,7 @@ function parseCarryRaw(raw) {
     const where = `carry[${String(i)}]`;
     if (typeof item === "string") {
       out.push(parseShorthand(item, where));
-    } else if (isPlainObject2(item)) {
+    } else if (isPlainObject3(item)) {
       out.push(parseMapping(item, where));
     } else {
       throw new CarryConfigError(`${where} must be a string or mapping`);
@@ -695,14 +891,14 @@ function parseCarryRaw(raw) {
 function parseCarrySection(text) {
   let doc;
   try {
-    doc = parseYaml2(text);
+    doc = parseYaml3(text);
   } catch (err) {
     throw new CarryConfigError(
       `yaml parse error: ${err instanceof Error ? err.message : String(err)}`
     );
   }
   if (doc === null || doc === void 0) return [];
-  if (!isPlainObject2(doc)) {
+  if (!isPlainObject3(doc)) {
     throw new CarryConfigError("top-level config must be a mapping");
   }
   return parseCarryRaw(doc.carry);
@@ -710,7 +906,7 @@ function parseCarrySection(text) {
 async function loadCarrySection(path) {
   let text;
   try {
-    text = await readFile2(path, "utf8");
+    text = await readFile3(path, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -719,12 +915,12 @@ async function loadCarrySection(path) {
 }
 
 // ../../packages/config/dist/index.js
-import { parse as parseYaml3 } from "yaml";
+import { parse as parseYaml4 } from "yaml";
 import { createHash } from "crypto";
 import { realpath, stat } from "fs/promises";
 import { homedir } from "os";
 import { basename, dirname, join, resolve } from "path";
-import { readFile as readFile3 } from "fs/promises";
+import { readFile } from "fs/promises";
 import { parse as parseYaml22 } from "yaml";
 import { mkdir, readFile as readFile22, rename, rm, stat as stat2, writeFile } from "fs/promises";
 import { dirname as dirname2, isAbsolute, join as join2 } from "path";
@@ -837,6 +1033,10 @@ var BUILT_IN_DEFAULTS = {
   maintenance: {
     pruneProjectConfigs: true,
     pruneProjectConfigsEvery: 50
+  },
+  integrations: {
+    notion: { enabled: false },
+    linear: { enabled: false }
   }
 };
 var KEY_REGISTRY = [
@@ -1223,6 +1423,16 @@ var KEY_REGISTRY = [
     key: "maintenance.pruneProjectConfigsEvery",
     type: "int",
     description: "Run the orphan project-config sweep every N successful `agentbox create`."
+  },
+  {
+    key: "integrations.notion.enabled",
+    type: "bool",
+    description: 'Enable the in-box Notion integration shim (`ntn`/`notion` commands routed via the host relay). When false (default), the relay refuses dispatch with a clear "disabled" error and no host process is touched.'
+  },
+  {
+    key: "integrations.linear.enabled",
+    type: "bool",
+    description: 'Enable the in-box Linear integration shim (`linear` commands routed via the host relay; backed by `@schpet/linear-cli`). When false (default), the relay refuses dispatch with a clear "disabled" error and no host process is touched.'
   }
 ];
 var REGISTRY_BY_KEY = new Map(KEY_REGISTRY.map((d) => [d.key, d]));
@@ -1235,7 +1445,7 @@ var UserConfigError = class extends Error {
     this.name = "UserConfigError";
   }
 };
-function isPlainObject3(v) {
+function isPlainObject4(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var RENAMED_KEYS = /* @__PURE__ */ new Map([["box.snapshot", "box.hostSnapshot"]]);
@@ -1292,21 +1502,21 @@ function coerceTypedValue(raw, desc, where) {
 function parseUserConfig(text, where) {
   let doc;
   try {
-    doc = parseYaml3(text);
+    doc = parseYaml4(text);
   } catch (err) {
     throw new UserConfigError(
       `${where}: yaml parse error: ${err instanceof Error ? err.message : String(err)}`
     );
   }
   if (doc === null || doc === void 0) return {};
-  if (!isPlainObject3(doc)) {
+  if (!isPlainObject4(doc)) {
     throw new UserConfigError(`${where}: top-level must be a mapping`);
   }
   return parseUserConfigObject(doc, where);
 }
 function parseUserConfigObject(doc, where) {
   if (doc === null || doc === void 0) return {};
-  if (!isPlainObject3(doc)) {
+  if (!isPlainObject4(doc)) {
     throw new UserConfigError(`${where}: must be a mapping`);
   }
   const out = {};
@@ -1327,32 +1537,50 @@ function parseUserConfigObject(doc, where) {
       );
     }
     if (branchRaw === null || branchRaw === void 0) continue;
-    if (!isPlainObject3(branchRaw)) {
+    if (!isPlainObject4(branchRaw)) {
       throw new UserConfigError(`${where}.${branchName}: must be a mapping`);
     }
-    const branchOut = {};
-    for (const [leafName, leafRaw] of Object.entries(branchRaw)) {
-      const desc = branchSpec.leaves.get(leafName);
-      if (!desc) {
-        const renamedTo = RENAMED_KEYS.get(`${branchName}.${leafName}`);
-        if (renamedTo) {
-          throw new UserConfigError(
-            `${where}.${branchName}.${leafName} was renamed to ${renamedTo} \u2014 update your config`
-          );
-        }
-        throw new UserConfigError(
-          `${where}.${branchName}: unknown key "${leafName}" (known: ${[...branchSpec.leaves.keys()].join(", ")})`
-        );
-      }
-      if (leafRaw === void 0) continue;
-      branchOut[leafName] = coerceTypedValue(leafRaw, desc, `${where}.${desc.key}`);
-    }
+    const branchOut = parseBranchObject(branchSpec, branchName, branchRaw, "", where);
     if (Object.keys(branchOut).length > 0) {
       out[branchName] = branchOut;
     }
   }
   return out;
 }
+function parseBranchObject(branchSpec, branchName, raw, qualifiedPrefix, where) {
+  const out = {};
+  for (const [name, value] of Object.entries(raw)) {
+    if (value === void 0) continue;
+    const qualified = qualifiedPrefix ? `${qualifiedPrefix}.${name}` : name;
+    const desc = branchSpec.leaves.get(qualified);
+    if (desc) {
+      out[name] = coerceTypedValue(value, desc, `${where}.${desc.key}`);
+      continue;
+    }
+    if (isPlainObject4(value) && branchHasLeafBelow(branchSpec, qualified)) {
+      const sub = parseBranchObject(branchSpec, branchName, value, qualified, where);
+      if (Object.keys(sub).length > 0) out[name] = sub;
+      continue;
+    }
+    const renamedTo = RENAMED_KEYS.get(`${branchName}.${qualified}`);
+    if (renamedTo) {
+      throw new UserConfigError(
+        `${where}.${branchName}.${qualified} was renamed to ${renamedTo} \u2014 update your config`
+      );
+    }
+    throw new UserConfigError(
+      `${where}.${branchName}: unknown key "${qualified}" (known: ${[...branchSpec.leaves.keys()].join(", ")})`
+    );
+  }
+  return out;
+}
+function branchHasLeafBelow(branchSpec, prefix) {
+  const needle = `${prefix}.`;
+  for (const leaf of branchSpec.leaves.keys()) {
+    if (leaf.startsWith(needle)) return true;
+  }
+  return false;
+}
 function coerceFromString(key, raw) {
   const desc = lookupKeyOrThrow(key);
   switch (desc.type) {
@@ -1468,7 +1696,7 @@ async function configPathFor(scope, cwd) {
 async function loadOptionalUserConfig(path) {
   let text;
   try {
-    text = await readFile3(path, "utf8");
+    text = await readFile(path, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return {};
     throw err;
@@ -1479,7 +1707,7 @@ async function loadProjectAgentboxDefaults(workspacePath) {
   const path = workspaceConfigFile(workspacePath);
   let text;
   try {
-    text = await readFile3(path, "utf8");
+    text = await readFile(path, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return {};
     throw err;
@@ -1559,14 +1787,26 @@ function mergeLayers(input) {
   return { effective, sources };
 }
 function readLeaf(obj, branch, leaf) {
-  const b = obj[branch];
-  if (b === void 0 || b === null || typeof b !== "object") return void 0;
-  return b[leaf];
+  let cur = obj[branch];
+  for (const seg of leaf.split(".")) {
+    if (cur === void 0 || cur === null || typeof cur !== "object") return void 0;
+    cur = cur[seg];
+  }
+  return cur;
 }
 function writeLeaf(obj, branch, leaf, value) {
-  const b = obj[branch];
-  if (!b) return;
-  b[leaf] = value;
+  let cur = obj[branch];
+  if (!cur) return;
+  const segs = leaf.split(".");
+  for (let i = 0; i < segs.length - 1; i++) {
+    const seg = segs[i];
+    const next = cur[seg];
+    if (next === void 0 || next === null || typeof next !== "object") {
+      cur[seg] = {};
+    }
+    cur = cur[seg];
+  }
+  cur[segs[segs.length - 1]] = value;
 }
 function resolveDefaultCheckpoint(cfg, provider) {
   const perProvider = provider === "daytona" ? cfg.box.defaultCheckpointDaytona : provider === "hetzner" ? cfg.box.defaultCheckpointHetzner : provider === "vercel" ? cfg.box.defaultCheckpointVercel : provider === "e2b" ? cfg.box.defaultCheckpointE2b : cfg.box.defaultCheckpointDocker;
@@ -1742,25 +1982,34 @@ function stampSchema(doc) {
   }
 }
 function setLeaf(doc, key, value) {
-  const idx = key.indexOf(".");
-  const branch = key.slice(0, idx);
-  const leaf = key.slice(idx + 1);
-  const root = doc;
-  if (!root[branch] || typeof root[branch] !== "object") {
-    root[branch] = {};
+  const segs = key.split(".");
+  let cur = doc;
+  for (let i = 0; i < segs.length - 1; i++) {
+    const seg = segs[i];
+    const next = cur[seg];
+    if (!next || typeof next !== "object") {
+      cur[seg] = {};
+    }
+    cur = cur[seg];
   }
-  root[branch][leaf] = value;
+  cur[segs[segs.length - 1]] = value;
 }
 function unsetLeaf(doc, key) {
-  const idx = key.indexOf(".");
-  const branch = key.slice(0, idx);
-  const leaf = key.slice(idx + 1);
-  const root = doc;
-  const b = root[branch];
-  if (!b || typeof b !== "object" || !(leaf in b)) return false;
-  delete b[leaf];
-  if (Object.keys(b).length === 0) {
-    delete root[branch];
+  const segs = key.split(".");
+  const path = [doc];
+  for (let i = 0; i < segs.length - 1; i++) {
+    const seg = segs[i];
+    const next = path[path.length - 1][seg];
+    if (!next || typeof next !== "object") return false;
+    path.push(next);
+  }
+  const leafSeg = segs[segs.length - 1];
+  const leafContainer = path[path.length - 1];
+  if (!(leafSeg in leafContainer)) return false;
+  delete leafContainer[leafSeg];
+  for (let i = path.length - 1; i > 0; i--) {
+    if (Object.keys(path[i]).length > 0) break;
+    delete path[i - 1][segs[i - 1]];
   }
   return true;
 }
@@ -1803,17 +2052,17 @@ import { execa as execa2 } from "execa";
 import { mkdir as mkdir4, readFile as readFile5, readdir as readdir4, stat as stat4 } from "fs/promises";
 import { createHash as createHash3 } from "crypto";
 import { homedir as homedir2 } from "os";
-import { join as join5 } from "path";
+import { basename as basename2, dirname as dirname22, join as join5 } from "path";
 import { execa as execa3 } from "execa";
 import { existsSync, mkdirSync, renameSync, statSync } from "fs";
-import { basename as basename2, dirname as dirname3, posix, resolve as resolve2 } from "path";
+import { basename as basename3, dirname as dirname3, posix, resolve as resolve2 } from "path";
 import { execa as execa22 } from "execa";
 import { copyFile, mkdtemp, readdir as readdir22, readFile as readFile32, rm as rm3, stat as stat22, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir22, tmpdir } from "os";
-import { basename as basename3, join as join32, relative } from "path";
+import { basename as basename4, join as join32, relative } from "path";
 import { execa as execa5 } from "execa";
 import { chmod, mkdir as mkdir22, readFile as readFile23 } from "fs/promises";
-import { basename as basename22, join as join22 } from "path";
+import { basename as basename32, join as join22 } from "path";
 import { execa as execa4 } from "execa";
 import { spawnSync as spawnSync2 } from "child_process";
 import { stat as stat42 } from "fs/promises";
@@ -1825,7 +2074,7 @@ import { stat as stat5 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { join as join6 } from "path";
 import { execa as execa8 } from "execa";
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes2 } from "crypto";
 import { createHash as createHash22 } from "crypto";
 import { readFile as readFile52 } from "fs/promises";
 import { join as join7 } from "path";
@@ -1835,77 +2084,13 @@ import { readFile as readFile6 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { join as join8 } from "path";
 import { execa as execa10 } from "execa";
-
-// ../../packages/core/dist/index.js
-import { randomBytes } from "crypto";
-var claudeCodeLauncher = {
-  kind: "claude-code",
-  // claude treats its first positional argument as the seed user turn in
-  // interactive mode (`claude "<message>"`), so we slot the initial message
-  // ahead of any user-passed flags.
-  buildArgs(initialMessage, userArgs) {
-    if (!initialMessage) return [...userArgs];
-    return [initialMessage, ...userArgs];
-  }
-};
-var codexLauncher = {
-  kind: "codex",
-  buildArgs(initialMessage, userArgs) {
-    if (!initialMessage) return [...userArgs];
-    return [initialMessage, ...userArgs];
-  }
-};
-var opencodeLauncher = {
-  kind: "opencode",
-  buildArgs(initialMessage, userArgs) {
-    if (!initialMessage) return [...userArgs];
-    return [initialMessage, ...userArgs];
-  }
-};
-function resolveAgentLauncher(kind) {
-  if (kind === "claude-code") return claudeCodeLauncher;
-  if (kind === "codex") return codexLauncher;
-  if (kind === "opencode") return opencodeLauncher;
-  throw new Error(`unknown agent kind: ${String(kind)}`);
-}
-var UserFacingError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "UserFacingError";
-  }
-};
-var BoxNotFoundError = class extends Error {
-  constructor(query) {
-    super(`no agentbox matches "${query}"`);
-    this.query = query;
-    this.name = "BoxNotFoundError";
-  }
-  query;
-};
-var AmbiguousBoxError = class extends Error {
-  constructor(query, matches) {
-    const ids = matches.map((m) => m.id).join(", ");
-    super(`"${query}" matches multiple boxes: ${ids}`);
-    this.query = query;
-    this.matches = matches;
-    this.name = "AmbiguousBoxError";
-  }
-  query;
-  matches;
-};
-var BOX_ID_PREFIX = "b";
-function generateBoxId() {
-  return `${BOX_ID_PREFIX}${randomBytes(4).toString("hex")}`;
-}
-
-// ../../packages/sandbox-docker/dist/index.js
 import { execa as execa11 } from "execa";
 import { mkdir as mkdir42, readdir as readdir42, rm as rm32, stat as stat6 } from "fs/promises";
 import { homedir as homedir7, platform } from "os";
 import { join as join9, resolve as resolve22 } from "path";
 import { mkdir as mkdir5, mkdtemp as mkdtemp3, readFile as readFile7, readdir as readdir5, rm as rm4, writeFile as writeFile32 } from "fs/promises";
 import { homedir as homedir8, tmpdir as tmpdir3 } from "os";
-import { basename as basename4, join as join10 } from "path";
+import { basename as basename5, join as join10 } from "path";
 import { execa as execa12 } from "execa";
 import { stat as stat7 } from "fs/promises";
 import { execa as execa13 } from "execa";
@@ -1917,14 +2102,286 @@ import { cp, mkdir as mkdir6, readFile as readFile8, readdir as readdir6, rename
 import { request as httpRequest } from "http";
 import { createRequire } from "module";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname22, join as join11, resolve as resolve3, sep } from "path";
+import { dirname as dirname32, join as join11, resolve as resolve3, sep } from "path";
 import { setTimeout as delay2 } from "timers/promises";
 import { fileURLToPath } from "url";
 
 // ../../packages/relay/dist/index.js
-import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash2, randomBytes } from "crypto";
 import { execa } from "execa";
-import { spawn as spawn3 } from "child_process";
+
+// ../../packages/integrations/dist/index.js
+var linearConnector = {
+  service: "linear",
+  hostBin: "linear",
+  detect: {
+    versionArgs: ["--version"],
+    authArgs: ["auth", "whoami"],
+    installHint: "install @schpet/linear-cli: npm i -g @schpet/linear-cli",
+    loginHint: "linear auth login"
+  },
+  ops: {
+    whoami: {
+      write: false,
+      buildArgv: (args) => ["auth", "whoami", ...args]
+    },
+    "issue.list": {
+      write: false,
+      buildArgv: (args) => ["issue", "list", ...args]
+    },
+    "issue.mine": {
+      // The v2-native read for "issues assigned to me" — the README directs
+      // users here in place of the older `issue list --me`. Listed as a
+      // separate op so the shim doesn't reject the canonical form.
+      write: false,
+      buildArgv: (args) => ["issue", "mine", ...args]
+    },
+    "issue.view": {
+      write: false,
+      buildArgv: (args) => ["issue", "view", ...args]
+    },
+    "issue.query": {
+      write: false,
+      buildArgv: (args) => ["issue", "query", ...args]
+    },
+    "team.list": {
+      write: false,
+      buildArgv: (args) => ["team", "list", ...args]
+    },
+    api: {
+      write: false,
+      buildArgv: (args) => ["api", ...args],
+      refuseCall: refuseGraphqlNonQuery
+    },
+    "issue.create": {
+      write: true,
+      buildArgv: (args) => ["issue", "create", ...args]
+    },
+    "issue.update": {
+      write: true,
+      buildArgv: (args) => ["issue", "update", ...args]
+    },
+    "issue.comment": {
+      // Maps to `linear issue comment add` — `@schpet/linear-cli` v2 uses
+      // `add` (not `create`); `add`'s sibling subcommands are `list`,
+      // `update`, `delete`.
+      write: true,
+      buildArgv: (args) => ["issue", "comment", "add", ...args]
+    }
+  }
+};
+function refuseGraphqlNonQuery(args) {
+  const refuse = (reason) => ({
+    exitCode: 65,
+    stderr: `linear api: ${reason}
+`
+  });
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg === "--input" || arg.startsWith("--input=")) {
+      return refuse("'--input' (stdin/file body) isn't supported through the relay");
+    }
+    if (arg === "--variable") {
+      const next = args[i + 1] ?? "";
+      if (variableValueIsFileLoad(next)) {
+        return refuse(
+          "'--variable key=@<path>' (host-file load) isn't supported through the relay"
+        );
+      }
+      if (!next.startsWith("--")) i++;
+      continue;
+    }
+    if (arg.startsWith("--variable=")) {
+      if (variableValueIsFileLoad(arg.slice("--variable=".length))) {
+        return refuse(
+          "'--variable=key=@<path>' (host-file load) isn't supported through the relay"
+        );
+      }
+      continue;
+    }
+    if (arg === "--variables-json") {
+      const next = args[i + 1] ?? "";
+      if (!next.startsWith("--")) i++;
+      continue;
+    }
+    if (arg.startsWith("--variables-json=")) {
+      continue;
+    }
+    if (arg.startsWith("--")) continue;
+    const op = firstGraphqlOperationKeyword(arg);
+    if (op === "mutation" || op === "subscription") {
+      return refuse(
+        `only GraphQL queries are proxied (use issue.create / issue.update / issue.comment for writes); detected operation '${op}'`
+      );
+    }
+    if (op === "unparseable") {
+      return refuse(
+        `couldn't classify positional argv ${JSON.stringify(arg)} as a GraphQL operation (expected 'query', 'mutation', 'subscription', or '{')`
+      );
+    }
+  }
+  return null;
+}
+function variableValueIsFileLoad(value) {
+  if (value.startsWith("@")) return true;
+  return value.includes("=@");
+}
+function firstGraphqlOperationKeyword(source) {
+  let i = 0;
+  const n = source.length;
+  while (i < n) {
+    const c = source[i];
+    if (/\s/.test(c) || c === "," || c === "\uFEFF") {
+      i++;
+      continue;
+    }
+    if (c === "#") {
+      while (i < n && source[i] !== "\n") i++;
+      continue;
+    }
+    break;
+  }
+  if (i >= n) return null;
+  if (source[i] === "{") return "anonymous";
+  let j = i;
+  while (j < n) {
+    const c = source[j];
+    if (c >= "a" && c <= "z" || c >= "A" && c <= "Z") {
+      j++;
+    } else {
+      break;
+    }
+  }
+  if (j === i) return "unparseable";
+  return source.slice(i, j).toLowerCase();
+}
+var notionConnector = {
+  service: "notion",
+  hostBin: "ntn",
+  detect: {
+    versionArgs: ["--version"],
+    authArgs: ["api", "v1/users/me"],
+    installHint: "install ntn: https://developers.notion.com/reference/notion-cli",
+    loginHint: "ntn login"
+  },
+  ops: {
+    whoami: {
+      write: false,
+      buildArgv: (args) => ["whoami", ...args]
+    },
+    api: {
+      write: false,
+      buildArgv: (args) => ["api", ...args],
+      refuseCall: refuseUnsafeApiCall
+    },
+    "page.create": {
+      write: true,
+      buildArgv: (args) => ["pages", "create", ...args]
+    },
+    "page.update": {
+      write: true,
+      buildArgv: (args) => ["pages", "update", ...args]
+    }
+  }
+};
+var READ_POST_ENDPOINTS = [
+  /^\/?v1\/search$/,
+  /^\/?v1\/databases\/[^/?]+\/query$/,
+  /^\/?v1\/data_sources\/[^/?]+\/query$/
+];
+var SAFE_API_BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "--spec",
+  "--docs",
+  "-h",
+  "--help",
+  "-v",
+  "--verbose",
+  "-V",
+  "--version"
+]);
+function refuseUnsafeApiCall(args) {
+  const refuse = (reason) => ({
+    exitCode: 65,
+    stderr: `notion api: ${reason}
+`
+  });
+  let explicitMethod = null;
+  let hasBody = false;
+  let endpoint = null;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg === "-X" || arg === "--method") {
+      explicitMethod = args[i + 1] ?? "";
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--method=")) {
+      explicitMethod = arg.slice("--method=".length);
+      continue;
+    }
+    if (arg.startsWith("-X") && arg.length > 2) {
+      explicitMethod = arg.slice(2).replace(/^=/, "");
+      continue;
+    }
+    if (arg === "-d" || arg === "--data") {
+      hasBody = true;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--data=") || arg.startsWith("-d") && arg.length > 2) {
+      hasBody = true;
+      continue;
+    }
+    if (arg === "--file" || arg.startsWith("--file=")) {
+      return refuse("'--file' (host-file upload) isn't supported through the relay");
+    }
+    if (arg === "--input" || arg.startsWith("--input=")) {
+      return refuse("'--input' (stdin/file body) isn't supported through the relay; use -d <JSON>");
+    }
+    if (arg === "--notion-version") {
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--notion-version=")) continue;
+    if (arg.startsWith("-")) {
+      if (SAFE_API_BOOLEAN_FLAGS.has(arg)) continue;
+      return refuse(
+        `unsupported option '${arg}' (read-only api accepts a path, inline inputs, -d <JSON>, -X GET/POST, --notion-version, --spec, --docs)`
+      );
+    }
+    if (endpoint === null) {
+      endpoint = arg;
+      continue;
+    }
+    if (isBodyAssignment(arg)) hasBody = true;
+  }
+  const method = (explicitMethod && explicitMethod.length > 0 ? explicitMethod : hasBody ? "POST" : "GET").toUpperCase();
+  if (method === "GET") return null;
+  if (method !== "POST") {
+    return refuse(
+      `only GET and read-only POST are proxied (use page.create / page.update for writes); detected method '${method}'`
+    );
+  }
+  if (endpoint === null) {
+    return refuse("could not determine the API endpoint for a non-GET call");
+  }
+  if (endpoint.split("/").some((seg) => seg === "." || seg === "..")) {
+    return refuse(`path traversal segments ('.' / '..') are not allowed in '${endpoint}'`);
+  }
+  if (READ_POST_ENDPOINTS.some((re) => re.test(endpoint))) return null;
+  return refuse(
+    `POST is only proxied for read endpoints (v1/search, v1/databases/{id}/query, v1/data_sources/{id}/query); '${endpoint}' is not one (use page.create / page.update for writes)`
+  );
+}
+function isBodyAssignment(token) {
+  if (token.includes(":=")) return true;
+  if (token.includes("==")) return false;
+  return token.includes("=");
+}
+var ALL_CONNECTORS = [notionConnector, linearConnector];
+
+// ../../packages/relay/dist/index.js
+import { spawn as spawn4 } from "child_process";
 import {
   mkdir as mkdir2,
   readdir as readdir2,
@@ -2114,7 +2571,7 @@ async function uncachedBoxStateCount() {
 }
 function inspectDockerState(containerName) {
   return new Promise((resolveP) => {
-    const child = spawn3("docker", ["inspect", "--format", "{{.State.Status}}", containerName], {
+    const child = spawn4("docker", ["inspect", "--format", "{{.State.Status}}", containerName], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let out = "";
@@ -2158,7 +2615,7 @@ import { execa as execa18 } from "execa";
 import { createHash as createHash32 } from "crypto";
 import { copyFile as copyFile2, mkdir as mkdir8, mkdtemp as mkdtemp4, readdir as readdir8, readFile as readFile9, rm as rm7, stat as stat10 } from "fs/promises";
 import { homedir as homedir12, tmpdir as tmpdir4 } from "os";
-import { basename as basename6, dirname as dirname32, join as join16 } from "path";
+import { basename as basename7, dirname as dirname4, join as join16 } from "path";
 import { execa as execa19 } from "execa";
 function isHostPathHookCommand(command, hostHome) {
   if (typeof command !== "string" || command.length === 0) return false;
@@ -2285,16 +2742,16 @@ function rewritePluginPaths(value, hostPluginsPrefix) {
   }
   return value;
 }
-function isPlainObject4(v) {
+function isPlainObject5(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v);
 }
 function additiveMerge(hostRoot, boxRoot, hostPluginsPrefix, selectMap, withMap) {
   const hostMap = selectMap(hostRoot);
   const boxMap = selectMap(boxRoot);
-  if (!isPlainObject4(boxMap)) {
+  if (!isPlainObject5(boxMap)) {
     return { data: hostRoot, changed: false, addedKeys: [] };
   }
-  const base = isPlainObject4(hostMap) ? { ...hostMap } : {};
+  const base = isPlainObject5(hostMap) ? { ...hostMap } : {};
   const addedKeys = [];
   for (const [key, value] of Object.entries(boxMap)) {
     if (Object.prototype.hasOwnProperty.call(base, key)) continue;
@@ -2309,7 +2766,7 @@ function additiveMerge(hostRoot, boxRoot, hostPluginsPrefix, selectMap, withMap)
 function mergeKnownMarketplaces(hostJson, boxJson, opts) {
   const prefix = `${opts.hostHome}/.claude/plugins/`;
   return additiveMerge(
-    isPlainObject4(hostJson) ? hostJson : {},
+    isPlainObject5(hostJson) ? hostJson : {},
     boxJson,
     prefix,
     (root) => root,
@@ -2318,24 +2775,24 @@ function mergeKnownMarketplaces(hostJson, boxJson, opts) {
 }
 function mergeInstalledPlugins(hostJson, boxJson, opts) {
   const prefix = `${opts.hostHome}/.claude/plugins/`;
-  const hostRoot = isPlainObject4(hostJson) ? hostJson : { plugins: {} };
+  const hostRoot = isPlainObject5(hostJson) ? hostJson : { plugins: {} };
   return additiveMerge(
     hostRoot,
     boxJson,
     prefix,
-    (root) => isPlainObject4(root) ? root["plugins"] : void 0,
+    (root) => isPlainObject5(root) ? root["plugins"] : void 0,
     (host, merged) => ({ ...host, plugins: merged })
   );
 }
 function referencedPluginVersionKeys(installedPluginsJson) {
   const keys = /* @__PURE__ */ new Set();
-  if (!isPlainObject4(installedPluginsJson)) return keys;
+  if (!isPlainObject5(installedPluginsJson)) return keys;
   const plugins = installedPluginsJson["plugins"];
-  if (!isPlainObject4(plugins)) return keys;
+  if (!isPlainObject5(plugins)) return keys;
   for (const entries of Object.values(plugins)) {
     if (!Array.isArray(entries)) continue;
     for (const entry of entries) {
-      if (!isPlainObject4(entry)) continue;
+      if (!isPlainObject5(entry)) continue;
       const installPath = entry["installPath"];
       if (typeof installPath !== "string") continue;
       const segments = installPath.split("/").filter((s) => s.length > 0);
@@ -2585,7 +3042,7 @@ async function streamTarPipe(producerFile, producerArgs, consumerFile, consumerA
 async function uploadToBox(box, hostSrc, boxDst, exclude) {
   const srcAbs = resolve2(hostSrc);
   if (!existsSync(srcAbs)) throw new Error(`source not found: ${hostSrc}`);
-  const srcBasename = basename2(srcAbs);
+  const srcBasename = basename3(srcAbs);
   const srcParent = dirname3(srcAbs);
   let boxParent;
   let finalName;
@@ -2666,7 +3123,7 @@ async function downloadFromBox(box, boxSrc, hostDst, exclude) {
     finalName = srcBasename;
   } else {
     hostParent = dirname3(dstAbs);
-    finalName = basename2(dstAbs);
+    finalName = basename3(dstAbs);
   }
   mkdirSync(hostParent, { recursive: true });
   const finalPath = posix.join(hostParent, finalName);
@@ -3145,13 +3602,44 @@ async function copyOneEntry(container, entry) {
     throw new Error(`mkdir -p ${parentDir} failed: ${String(mkdir9.stderr).slice(0, 300)}`);
   }
   if (entry.kind === "file") {
-    const cp2 = await execa3(
+    const srcDir = dirname22(entry.absSrc);
+    const srcBase = basename2(entry.absSrc);
+    const destBase = boxDest.slice(boxDest.lastIndexOf("/") + 1);
+    const [packed, extract] = await streamTarPipe(
+      "tar",
+      ["-C", srcDir, "-cf", "-", srcBase],
       "docker",
-      ["cp", entry.absSrc, `${container}:${boxDest}`],
-      { reject: false }
+      [
+        "exec",
+        "-i",
+        "--user",
+        "0:0",
+        container,
+        "tar",
+        "-xf",
+        "-",
+        "-C",
+        parentDir,
+        "--no-same-permissions",
+        "--no-same-owner",
+        "-m"
+      ]
     );
-    if (cp2.exitCode !== 0) {
-      throw new Error(`docker cp failed: ${String(cp2.stderr).slice(0, 300)}`);
+    if (packed.exitCode !== 0) {
+      throw new Error(`tar pack failed: ${String(packed.stderr).slice(0, 300)}`);
+    }
+    if (extract.exitCode !== 0) {
+      throw new Error(`tar extract failed: ${String(extract.stderr).slice(0, 300)}`);
+    }
+    if (srcBase !== destBase) {
+      const mv = await execa3(
+        "docker",
+        ["exec", "--user", "0:0", container, "mv", "-f", `${parentDir}/${srcBase}`, boxDest],
+        { reject: false }
+      );
+      if (mv.exitCode !== 0) {
+        throw new Error(`rename to ${boxDest} failed: ${String(mv.stderr).slice(0, 300)}`);
+      }
     }
   } else {
     const excludeArgs = (entry.exclude ?? []).map((p) => `--exclude=${p}`);
@@ -3265,7 +3753,7 @@ async function extractVolumeAuthToBackup(opts) {
       "-e",
       // Pass the destination filename via env so the path isn't interpolated
       // into the script string (keeps the docker arg list static + injection-safe).
-      `DEST=${basename22(opts.backupFile)}`,
+      `DEST=${basename32(opts.backupFile)}`,
       opts.image,
       "sh",
       "-c",
@@ -3385,7 +3873,7 @@ function emptyResult(warnings = []) {
   }, warnings };
 }
 async function tarballFromDir(stageDir, agent) {
-  const tarballPath = join32(tmpdir(), `agentbox-${agent}-${basename3(stageDir)}.tar.gz`);
+  const tarballPath = join32(tmpdir(), `agentbox-${agent}-${basename4(stageDir)}.tar.gz`);
   await execa5("tar", ["-czf", tarballPath, "-C", stageDir, "."], {
     env: { ...process.env, COPYFILE_DISABLE: "1" }
   });
@@ -4262,14 +4750,14 @@ var ClaudeSessionError = class extends Error {
     this.name = "ClaudeSessionError";
   }
 };
-function shQuote(arg) {
+function shQuote2(arg) {
   if (arg.length === 0) return `''`;
   if (/^[A-Za-z0-9_\-./=:@%+,]+$/.test(arg)) return arg;
   return `'${arg.replace(/'/g, `'\\''`)}'`;
 }
 async function startClaudeSession(opts) {
   const sessionName = opts.sessionName ?? DEFAULT_CLAUDE_SESSION;
-  const cmd = ["claude", ...opts.claudeArgs].map(shQuote).join(" ");
+  const cmd = ["claude", ...opts.claudeArgs].map(shQuote2).join(" ");
   const term = process.env["TERM"] ?? "xterm-256color";
   const envFlags = ["-e", `TERM=${term}`];
   for (const k of FORWARDED_ENV_KEYS) {
@@ -4685,7 +5173,7 @@ async function pathExists3(p) {
     return false;
   }
 }
-function shQuote2(arg) {
+function shQuote22(arg) {
   if (arg.length === 0) return `''`;
   if (/^[A-Za-z0-9_\-./=:@%+,]+$/.test(arg)) return arg;
   return `'${arg.replace(/'/g, `'\\''`)}'`;
@@ -4795,7 +5283,7 @@ ${(install.stdout ?? "").toString().slice(-600)}`
 var CODEX_AGENTBOX_FLAGS = ["--enable", "hooks", "--dangerously-bypass-hook-trust"];
 async function startCodexSession(opts) {
   const sessionName = opts.sessionName ?? DEFAULT_CODEX_SESSION;
-  const cmd = ["codex", ...CODEX_AGENTBOX_FLAGS, ...opts.codexArgs].map(shQuote2).join(" ");
+  const cmd = ["codex", ...CODEX_AGENTBOX_FLAGS, ...opts.codexArgs].map(shQuote22).join(" ");
   const term = process.env["TERM"] ?? "xterm-256color";
   const envFlags = ["-e", `TERM=${term}`];
   for (const k of CODEX_FORWARDED_ENV_KEYS) {
@@ -5403,7 +5891,7 @@ async function launchVncDaemon(container, timeoutMs = 5e3) {
 }
 var VNC_PASSWORD_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 function generateVncPassword() {
-  const bytes = randomBytes3(8);
+  const bytes = randomBytes2(8);
   let out = "";
   for (let i = 0; i < 8; i++) {
     out += VNC_PASSWORD_ALPHABET[bytes[i] % VNC_PASSWORD_ALPHABET.length];
@@ -6106,7 +6594,7 @@ async function createSnapshot(opts) {
 var CHECKPOINTS_ROOT = join10(homedir8(), ".agentbox", "checkpoints");
 var CHECKPOINT_IMAGE_PREFIX = "agentbox-ckpt-";
 function checkpointImageTag(projectRoot, name) {
-  const mnemonic = sanitizeMnemonic(basename4(projectRoot));
+  const mnemonic = sanitizeMnemonic(basename5(projectRoot));
   return `${CHECKPOINT_IMAGE_PREFIX}${hashProjectPath(projectRoot)}_${mnemonic}:${name}`;
 }
 function projectCheckpointsDir(projectRoot) {
@@ -6603,7 +7091,7 @@ async function spawnRelay(relayBin, cliEntry, log) {
 function resolveRelayBin() {
   const override = process.env.AGENTBOX_RELAY_BIN;
   if (override && existsSync3(override)) return override;
-  const here = dirname22(fileURLToPath(import.meta.url));
+  const here = dirname32(fileURLToPath(import.meta.url));
   const candidates = [
     resolve3(here, "..", "runtime", "relay", "bin.cjs"),
     resolve3(here, "..", "..", "relay", "dist", "bin.cjs"),
@@ -6621,7 +7109,7 @@ function resolveRelayBin() {
 function resolveCliEntry() {
   const override = process.env.AGENTBOX_CLI_ENTRY;
   if (override && existsSync3(override)) return override;
-  const here = dirname22(fileURLToPath(import.meta.url));
+  const here = dirname32(fileURLToPath(import.meta.url));
   const candidates = [
     // Bundled CLI (dev + published): this module IS bundled into the CLI
     // entry, so the entry is index.js next to this file.
@@ -6637,7 +7125,7 @@ function resolveCliEntry() {
 async function stageRelayHome(version, log) {
   if (!version || version === "0.0.0-dev") return null;
   if (process.env.AGENTBOX_RELAY_BIN || process.env.AGENTBOX_CLI_ENTRY) return null;
-  const cliRoot = findCliRoot(dirname22(fileURLToPath(import.meta.url)));
+  const cliRoot = findCliRoot(dirname32(fileURLToPath(import.meta.url)));
   if (cliRoot === null) return null;
   const homeDir = join11(RELAY_HOME_DIR, version);
   const stagedEntry = join11(homeDir, "dist", "index.js");
@@ -7145,7 +7633,7 @@ function persistableLimits(lim) {
   return Object.keys(out).length > 0 ? out : void 0;
 }
 function sanitizeBasename(workspacePath) {
-  const raw = basename5(resolve4(workspacePath));
+  const raw = basename6(resolve4(workspacePath));
   return raw.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^[-._]+|[-._]+$/g, "").slice(0, 30).replace(/[-._]+$/, "");
 }
 function defaultBoxName(workspacePath, id) {
@@ -7716,9 +8204,14 @@ async function createBox(opts) {
   let carrySummary;
   if (opts.carry && opts.carry.length > 0) {
     log(`carry: copying ${String(opts.carry.length)} host path(s) into the box`);
+    const entries = await renderCarryEntries(
+      opts.carry,
+      { name, id, kind: "docker", hostWorkspace: workspace, projectRoot: opts.projectRoot },
+      log
+    );
     const result = await copyCarryPathsToBox({
       container: containerName,
-      entries: opts.carry,
+      entries,
       onLog: log
     });
     log(`carry: copied ${String(result.copied)}/${String(opts.carry.length)} entry/entries`);
@@ -8955,10 +9448,10 @@ async function stageDynamicSyncTarball(uploads) {
   try {
     for (const up of uploads) {
       const target = join16(stageDir, up.set, up.rel);
-      await mkdir8(dirname32(target), { recursive: true });
+      await mkdir8(dirname4(target), { recursive: true });
       await copyFile2(up.absSrc, target);
     }
-    tarballPath = join16(tmpdir4(), `agentbox-dynsync-${basename6(stageDir)}.tar.gz`);
+    tarballPath = join16(tmpdir4(), `agentbox-dynsync-${basename7(stageDir)}.tar.gz`);
     await execa19("tar", ["-czf", tarballPath, "-C", stageDir, "."], {
       env: { ...process.env, COPYFILE_DISABLE: "1" }
     });
@@ -9023,12 +9516,10 @@ export {
   renderStatusTable,
   renderTaskTable,
   renderPortsTable,
+  parseReplacementsSection,
+  parseCarrySection,
   loadCarrySection,
-  resolveAgentLauncher,
-  UserFacingError,
-  BoxNotFoundError,
-  AmbiguousBoxError,
-  generateBoxId,
+  ALL_CONNECTORS,
   DEFAULT_RELAY_PORT,
   RELAY_CONTAINER_NAME,
   RELAY_NETWORK_NAME,
@@ -9258,4 +9749,4 @@ export {
   browserSessionActive,
   ensureBoxBrowser
 };
-//# sourceMappingURL=chunk-MLMFNN4T.js.map
+//# sourceMappingURL=chunk-GXJNJUEV.js.map