@tablation/crew 0.104.0 → 0.105.0

package/dist/cli.js

@@ -1912,8 +1912,8 @@ function configureSecretStore(c) {
 function keysDir(stateDir) {
   return join10(stateDir, "keys");
 }
-function entryName(host, slug) {
-  return `${createHash2("sha256").update(`${host}\0${slug}`).digest("hex")}.json`;
+function entryName(host, slug2) {
+  return `${createHash2("sha256").update(`${host}\0${slug2}`).digest("hex")}.json`;
 }
 var FileSessionStore = class {
   dir;
@@ -1924,23 +1924,23 @@ var FileSessionStore = class {
     mkdirSync6(this.dir, { recursive: true, mode: 448 });
     if ((statSync3(this.dir).mode & 63) !== 0) chmodSync2(this.dir, 448);
   }
-  async get(host, slug) {
-    const file = join10(this.dir, entryName(host, slug));
+  async get(host, slug2) {
+    const file = join10(this.dir, entryName(host, slug2));
     if (!existsSync8(this.dir)) return void 0;
     accessSync(this.dir, constants.R_OK | constants.X_OK);
     if (!existsSync8(file)) return void 0;
     return JSON.parse(readFileSync9(file, "utf8"));
   }
-  async set(host, slug, session) {
+  async set(host, slug2, session) {
     this.ensureDir();
-    const file = join10(this.dir, entryName(host, slug));
+    const file = join10(this.dir, entryName(host, slug2));
     const tmp = `${file}.${process.pid}.tmp`;
     writeFileSync7(tmp, JSON.stringify(session), { mode: 384 });
     renameSync2(tmp, file);
   }
-  async clear(host, slug) {
+  async clear(host, slug2) {
     if (!existsSync8(this.dir)) return;
-    rmSync7(join10(this.dir, entryName(host, slug)), { force: true });
+    rmSync7(join10(this.dir, entryName(host, slug2)), { force: true });
   }
   /** Whether a key could be written here right now, without leaving anything behind. */
   writable() {
@@ -1973,23 +1973,23 @@ var CrewHintedStore = class {
   constructor(inner) {
     this.inner = inner;
   }
-  async get(host, slug) {
+  async get(host, slug2) {
     try {
-      return await this.inner.get(host, slug);
+      return await this.inner.get(host, slug2);
     } catch (e) {
       throw crewifyStoreError(e);
     }
   }
-  async set(host, slug, s) {
+  async set(host, slug2, s) {
     try {
-      await this.inner.set(host, slug, s);
+      await this.inner.set(host, slug2, s);
     } catch (e) {
       throw crewifyStoreError(e);
     }
   }
-  async clear(host, slug) {
+  async clear(host, slug2) {
     try {
-      await this.inner.clear(host, slug);
+      await this.inner.clear(host, slug2);
     } catch (e) {
       throw crewifyStoreError(e);
     }
@@ -2102,7 +2102,8 @@ var TOP_LEVEL = /* @__PURE__ */ new Set([
   "docs",
   "hooks",
   "labels",
-  "release"
+  "release",
+  "sandbox"
 ]);
 var BRANCH_KEYS = /* @__PURE__ */ new Set(["base", "name", "push", "remote", "lowercase"]);
 var PLACEHOLDER = /\{(key|number|slug|role|prefix|tag|issue)\}/g;
@@ -2169,6 +2170,36 @@ function rejectUnknown(obj, allowed, where, file) {
     );
   }
 }
+var PACKAGE_NAME = /^[a-z0-9][a-z0-9+.\-]*(=[A-Za-z0-9.+:~\-]+)?$/;
+function stringList(raw, where, file) {
+  if (raw === void 0 || raw === null) return [];
+  if (!Array.isArray(raw)) throw new RepoConfigError(`${file}: ${where} must be a list of strings`);
+  return raw.map((v) => {
+    if (typeof v !== "string" || v.trim() === "") throw new RepoConfigError(`${file}: ${where} entries must be non-empty strings`);
+    return v;
+  });
+}
+function parseSandbox(raw, file) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "object" || Array.isArray(raw)) throw new RepoConfigError(`${file}: sandbox must be a mapping`);
+  const r = raw;
+  const packages = stringList(r.packages, "sandbox.packages", file);
+  const setup = stringList(r.setup, "sandbox.setup", file);
+  for (const p of packages) {
+    if (!PACKAGE_NAME.test(p)) throw new RepoConfigError(`${file}: sandbox.packages entry "${p}" is not a package name (lowercase letters, digits, + . - and an optional =version)`);
+  }
+  let image;
+  if (r.image !== void 0 && r.image !== null) {
+    if (typeof r.image !== "string" || r.image.trim() === "" || /\s/.test(r.image)) {
+      throw new RepoConfigError(`${file}: sandbox.image must be an image reference with no whitespace`);
+    }
+    image = r.image;
+    if (packages.length > 0) {
+      throw new RepoConfigError(`${file}: sandbox.image and sandbox.packages are alternatives \u2014 a published image already carries its packages; put the rest in sandbox.setup`);
+    }
+  }
+  return { ...image ? { image } : {}, packages, setup };
+}
 function parseRepoConfig(text2, file) {
   let raw;
   try {
@@ -2187,6 +2218,7 @@ function parseRepoConfig(text2, file) {
   rejectUnknown(raw.branch, BRANCH_KEYS, "branch", file);
   rejectUnknown(raw.worktrees, /* @__PURE__ */ new Set(["copy", "prefix", "name"]), "worktrees", file);
   rejectUnknown(raw.docs, /* @__PURE__ */ new Set(["triagePolicy", "designGuide"]), "docs", file);
+  rejectUnknown(raw.sandbox, /* @__PURE__ */ new Set(["image", "packages", "setup"]), "sandbox", file);
   if (raw.version === void 0) throw new RepoConfigError(`${file}: version is required`);
   if (raw.version !== SPEC_VERSION) {
     throw new RepoConfigError(
@@ -2243,6 +2275,7 @@ function parseRepoConfig(text2, file) {
       );
     }
   }
+  const sandbox = parseSandbox(raw.sandbox, file);
   const platform2 = String(raw.platform ?? "any");
   if (!isPlatformRequirement(platform2)) {
     throw new RepoConfigError(
@@ -2371,6 +2404,7 @@ function parseRepoConfig(text2, file) {
     branch,
     worktrees: worktrees2,
     docs,
+    ...sandbox ? { sandbox } : {},
     platform: platform2,
     shell: raw.shell ? String(raw.shell) : void 0,
     hooks,
@@ -2489,6 +2523,8 @@ function resolveRepoConfig(repo, ship, dir) {
   );
   return {
     version: SPEC_VERSION,
+    // Repo-only, like platform: what a repo needs installed is a fact about it.
+    ...repo?.sandbox ? { sandbox: repo.sandbox } : {},
     worktrees: {
       // Not merged: which gitignored files a worktree needs is a fact about
       // the repository and nothing else, so a ship cannot supply or override
@@ -3864,9 +3900,9 @@ function labelFor(crewHome, job) {
       return crewHome;
     }
   })();
-  const hash = createHash3("sha1").update(real).digest("hex").slice(0, 8);
+  const hash2 = createHash3("sha1").update(real).digest("hex").slice(0, 8);
   const stem = job === "release" ? "com.tablation.crew-release" : job === "passengers" ? "com.tablation.crew-passengers" : "com.tablation.crew";
-  return `${stem}.${hash}`;
+  return `${stem}.${hash2}`;
 }
 function cronMarkerFor(label) {
   return `# crew:${label} \u2014 managed by \`crew install\`, do not edit by hand`;
@@ -5313,11 +5349,433 @@ function attentionProblems(items, already) {
   return items.filter((i) => !seen.has(i.key)).map((i) => ({ severity: "attention", kind: i.kind, message: i.message }));
 }
 
-// src/doctor-checks.ts
+// src/sandbox-image.ts
+import { createHash as createHash5 } from "crypto";
+import { spawn as spawn2 } from "child_process";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync3, writeFileSync as writeFileSync10, rmSync as rmSync9 } from "fs";
+import { join as join15 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+
+// src/passenger-containers.ts
 import { execFileSync as execFileSync3 } from "child_process";
+import { createHash as createHash4 } from "crypto";
+var realExec = (cmd, args, opts) => {
+  try {
+    return execFileSync3(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: opts?.timeoutMs });
+  } catch (e) {
+    const err3 = e;
+    const why = [err3.stderr, err3.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
+    throw new Error(`${cmd} ${args.join(" ")}: ${why || err3.message.trim()}`);
+  }
+};
+var DOCKER_INFO_TIMEOUT_MS = 1e4;
+function dockerAvailable(exec = realExec) {
+  try {
+    exec("docker", ["info"], { timeoutMs: DOCKER_INFO_TIMEOUT_MS });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var PASSENGER_IMAGE_REPO = "tablation/crew-passenger-mcp";
+function passengerImageRef(cfg) {
+  return process.env.CREW_PASSENGER_IMAGE || cfg.ship.passengerImage || `${PASSENGER_IMAGE_REPO}:${crewVersion(cfg.crewHome)}`;
+}
+function imagePresent(image, exec = realExec) {
+  try {
+    exec("docker", ["image", "inspect", image]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureImage(image, exec = realExec) {
+  if (!imagePresent(image, exec)) exec("docker", ["pull", image]);
+}
+function containerNameFor(workspaceId) {
+  return `crew-passenger-${workspaceId}`;
+}
+function portFor(workspaceId, base = 28765, span = 1e3) {
+  const digest = createHash4("sha256").update(workspaceId).digest();
+  return base + digest.readUInt32BE(0) % span;
+}
+function mountsDigest(mounts, image) {
+  const sorted2 = [...mounts].sort((a, b) => a.containerPath.localeCompare(b.containerPath));
+  return createHash4("sha256").update(JSON.stringify({ mounts: sorted2, image })).digest("hex").slice(0, 16);
+}
+function planContainers(cfg) {
+  const byWorkspace = /* @__PURE__ */ new Map();
+  const image = passengerImageRef(cfg);
+  for (const route2 of cfg.routes) {
+    if (!route2.enabled || !route2.hostPassengers || !route2.resolved?.workspaceId) continue;
+    const workspaceId = route2.resolved.workspaceId;
+    const mounts = byWorkspace.get(workspaceId) ?? /* @__PURE__ */ new Map();
+    for (const target of passengerCheckoutTargets(route2)) {
+      mounts.set(target.name, { hostPath: target.dir, containerPath: `/workspace/${target.name}` });
+    }
+    byWorkspace.set(workspaceId, mounts);
+  }
+  return [...byWorkspace.entries()].filter(([, mounts]) => mounts.size > 0).map(([workspaceId, mounts]) => {
+    const mountList = [...mounts.values()];
+    return {
+      workspaceId,
+      containerName: containerNameFor(workspaceId),
+      port: portFor(workspaceId),
+      image,
+      mounts: mountList,
+      mountsHash: mountsDigest(mountList, image)
+    };
+  });
+}
+function listPassengerContainers(exec = realExec) {
+  const out = exec("docker", ["ps", "-a", "--filter", "name=crew-passenger-", "--format", "{{.Names}}	{{.State}}"]);
+  return out.split("\n").map((l) => l.trim()).filter(Boolean).map((line) => {
+    const [name, state] = line.split("	");
+    return { name, running: state === "running" };
+  });
+}
+function currentMountsHash(name, exec) {
+  try {
+    const out = exec("docker", ["inspect", "--format", '{{ index .Config.Labels "crew.mounts.hash" }}', name]);
+    const hash2 = out.trim();
+    return hash2 || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function stopContainer(name, exec = realExec) {
+  try {
+    exec("docker", ["rm", "-f", name]);
+  } catch {
+  }
+}
+function startContainer(plan, tablationApiBaseUrl, sync, exec = realExec) {
+  const args = [
+    "run",
+    "-d",
+    "--name",
+    plan.containerName,
+    "--restart",
+    "unless-stopped",
+    "-p",
+    `${plan.port}:8765`,
+    "-e",
+    `PASSENGER_MCP_WORKSPACE_ID=${plan.workspaceId}`,
+    "-e",
+    `TABLATION_API_BASE_URL=${tablationApiBaseUrl}`,
+    "--label",
+    `crew.mounts.hash=${plan.mountsHash}`
+  ];
+  if (sync) {
+    args.push(
+      "--add-host",
+      "host.docker.internal:host-gateway",
+      "-e",
+      `PASSENGER_SYNC_URL=http://${sync.host}:${sync.port}/sync`,
+      "-e",
+      `PASSENGER_SYNC_SECRET=${sync.secret}`,
+      "-e",
+      `PASSENGER_MCP_SECRET=${sync.secret}`
+    );
+  }
+  for (const m of plan.mounts) args.push("-v", `${m.hostPath}:${m.containerPath}:ro`);
+  args.push(plan.image);
+  exec("docker", args);
+}
+function syncPassengerContainers(cfg, tablationApiBaseUrl, exec = realExec, syncEndpoints = /* @__PURE__ */ new Map()) {
+  const plans = planContainers(cfg);
+  const plannedByName = new Map(plans.map((p) => [p.containerName, p]));
+  const existing = listPassengerContainers(exec);
+  const existingByName = new Map(existing.map((c) => [c.name, c]));
+  const started = [];
+  const recreated = [];
+  const stopped = [];
+  const ensured = /* @__PURE__ */ new Set();
+  const start = (plan, sync) => {
+    if (!ensured.has(plan.image)) {
+      ensureImage(plan.image, exec);
+      ensured.add(plan.image);
+    }
+    startContainer(plan, tablationApiBaseUrl, sync, exec);
+  };
+  for (const plan of plans) {
+    const sync = syncEndpoints.get(plan.workspaceId);
+    const current = existingByName.get(plan.containerName);
+    if (!current) {
+      start(plan, sync);
+      started.push(plan.containerName);
+    } else if (!current.running) {
+      stopContainer(plan.containerName, exec);
+      start(plan, sync);
+      started.push(plan.containerName);
+    } else if (currentMountsHash(plan.containerName, exec) !== plan.mountsHash) {
+      stopContainer(plan.containerName, exec);
+      start(plan, sync);
+      recreated.push(plan.containerName);
+    }
+  }
+  for (const { name } of existing) {
+    if (!plannedByName.has(name)) {
+      stopContainer(name, exec);
+      stopped.push(name);
+    }
+  }
+  return { started, recreated, stopped };
+}
+function passengerCheckoutSyncSpecs(cfg, workspaceId) {
+  const specs = [];
+  for (const route2 of cfg.routes) {
+    if (!route2.enabled || !route2.hostPassengers || !route2.resolved?.workspaceId) continue;
+    if (workspaceId && route2.resolved.workspaceId !== workspaceId) continue;
+    const routeWorkspaceId = route2.resolved.workspaceId;
+    const ordinaryByName = new Map(reposOf(route2).map((t) => [t.name, t]));
+    for (const target of passengerCheckoutTargets(route2)) {
+      const ordinary = ordinaryByName.get(target.name);
+      const override = route2.repoOverrides[target.name];
+      const effective = resolveRepoConfig(
+        ordinary ? loadRepoConfig(ordinary.dir) : null,
+        { branch: { ...route2.branch, ...override?.branch } },
+        ordinary?.dir ?? target.dir
+      );
+      specs.push({
+        name: target.name,
+        workspaceId: routeWorkspaceId,
+        dir: target.dir,
+        remote: target.remote,
+        gitRemoteName: effective.branch.remote,
+        base: effective.branch.base,
+        originUrl: ordinary ? originUrlOf(ordinary.dir, effective.branch.remote) : null,
+        cloneScheme: cfg.ship.cloneScheme,
+        ...target.forgeHost ? { forgeHost: target.forgeHost } : {}
+      });
+    }
+  }
+  return specs;
+}
+function syncAllPassengerCheckouts(cfg) {
+  return passengerCheckoutSyncSpecs(cfg).map((spec) => ({
+    name: spec.name,
+    workspaceId: spec.workspaceId,
+    outcome: syncPassengerCheckout(spec.dir, spec.remote, spec.gitRemoteName, spec.base, { originUrl: spec.originUrl, scheme: spec.cloneScheme, host: spec.forgeHost })
+  }));
+}
+
+// src/sandbox-image.ts
+var SANDBOX_BASE_IMAGE = "nvcr.io/nvidia/base/ubuntu:24.04";
+var SANDBOX_HARNESS_VERSION = "0.1.6";
+var SANDBOX_UID = 1e3;
+var CREW_PREFIX = "/opt/crew";
+var SANDBOX_RETRY_AFTER_MS = 60 * 60 * 1e3;
+var KEEP_TAGS = 2;
+var CREDENTIAL_HELPER = `#!/bin/sh
+# git credential helper: answers from the environment the runner passes in, so
+# no token is ever written into an image layer.
+[ "$1" = get ] || exit 0
+[ -n "$CREW_FORGE_TOKEN" ] || exit 0
+echo "username=\${CREW_FORGE_USER:-x-access-token}"
+echo "password=$CREW_FORGE_TOKEN"
+`;
+var MCP_CONFIG = `${JSON.stringify({ mcpServers: {} }, null, 2)}
+`;
+var hash = (parts) => createHash5("sha256").update(JSON.stringify(parts)).digest("hex").slice(0, 12);
+var slug = (s) => s.toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
+var run = (cmd) => `RUN ["/bin/bash", "-c", ${JSON.stringify(`set -euo pipefail; ${cmd}`)}]`;
+var CREW_ENV = {
+  CREW_SANDBOX: "1",
+  CREW_CACHE_DIR: `${CREW_PREFIX}/cache`,
+  XDG_CACHE_HOME: `${CREW_PREFIX}/cache`,
+  npm_config_cache: `${CREW_PREFIX}/cache/npm`,
+  npm_config_store_dir: `${CREW_PREFIX}/pnpm-store`,
+  PNPM_HOME: `${CREW_PREFIX}/pnpm`
+};
+function baseLayer() {
+  const dockerfile = [
+    `FROM ${SANDBOX_BASE_IMAGE}`,
+    `LABEL io.crew.sandbox.layer="base" io.crew.sandbox.harness="${SANDBOX_HARNESS_VERSION}"`,
+    ""
+  ].join("\n");
+  return { name: "base", tag: `crew-sandbox-base:${hash({ SANDBOX_BASE_IMAGE, SANDBOX_HARNESS_VERSION })}`, dockerfile, files: {} };
+}
+function crewLayer(base) {
+  const files = { "credential-helper": CREDENTIAL_HELPER, "mcp.json": MCP_CONFIG };
+  const env = Object.entries(CREW_ENV).map(([k, v]) => `${k}=${v}`).join(" ");
+  const dockerfile = [
+    `FROM ${base.tag}`,
+    "USER root",
+    run("apt-get update && apt-get install -y --no-install-recommends ca-certificates curl git && rm -rf /var/lib/apt/lists/*"),
+    `COPY credential-helper ${CREW_PREFIX}/bin/credential-helper`,
+    `COPY mcp.json ${CREW_PREFIX}/mcp/mcp.json`,
+    run(`chmod 0755 ${CREW_PREFIX}/bin/credential-helper && git config --system credential.helper ${CREW_PREFIX}/bin/credential-helper`),
+    run(`mkdir -p ${CREW_PREFIX}/cache ${CREW_PREFIX}/pnpm-store ${CREW_PREFIX}/pnpm /sandbox && chown -R ${SANDBOX_UID}:${SANDBOX_UID} ${CREW_PREFIX} /sandbox`),
+    `ENV ${env} PATH=${CREW_PREFIX}/pnpm:${CREW_PREFIX}/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin`,
+    `LABEL io.crew.sandbox.layer="crew"`,
+    ""
+  ].join("\n");
+  return { name: "crew", tag: `crew-sandbox-crew:${hash({ base: base.tag, dockerfile, files })}`, dockerfile, files };
+}
+function repoLayer(repo, decl, crew) {
+  const env = Object.entries(CREW_ENV).map(([k, v]) => `${k}=${v}`).join(" ");
+  const lines2 = [];
+  if (decl.image) {
+    lines2.push(
+      `FROM ${crew.tag} AS crew`,
+      `FROM ${decl.image}`,
+      "USER root",
+      `COPY --from=crew ${CREW_PREFIX} ${CREW_PREFIX}`,
+      `ENV ${env} PATH=${CREW_PREFIX}/pnpm:${CREW_PREFIX}/bin:$PATH`
+    );
+  } else {
+    lines2.push(`FROM ${crew.tag}`, "USER root");
+  }
+  if (decl.packages.length > 0) {
+    lines2.push(run(`apt-get update && apt-get install -y --no-install-recommends ${decl.packages.join(" ")} && rm -rf /var/lib/apt/lists/*`));
+  }
+  lines2.push(
+    run(`mkdir -p /sandbox && chown -R ${SANDBOX_UID}:${SANDBOX_UID} /sandbox ${CREW_PREFIX}`),
+    `USER ${SANDBOX_UID}`,
+    "WORKDIR /sandbox"
+  );
+  for (const step of decl.setup) lines2.push(run(step));
+  lines2.push(`LABEL io.crew.sandbox.layer="repo" io.crew.sandbox.repo=${JSON.stringify(repo)}`, "");
+  const dockerfile = lines2.join("\n");
+  return { name: "repo", tag: `crew-sandbox/${slug(repo)}:${hash({ crew: crew.tag, dockerfile })}`, dockerfile, files: {} };
+}
+function planSandbox(repo, decl) {
+  const base = baseLayer();
+  const crew = crewLayer(base);
+  const layer = repoLayer(repo, decl, crew);
+  return { repo, tag: layer.tag, layers: [base, crew, layer] };
+}
+var sandboxStatePath = (stateDir) => join15(stateDir, "sandbox-images.json");
+function readSandboxState(stateDir) {
+  try {
+    const v = JSON.parse(readFileSync14(sandboxStatePath(stateDir), "utf8"));
+    return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+  } catch {
+    return {};
+  }
+}
+function writeSandboxState(stateDir, state) {
+  mkdirSync9(stateDir, { recursive: true });
+  const file = sandboxStatePath(stateDir);
+  writeFileSync10(`${file}.tmp`, `${JSON.stringify(state, null, 2)}
+`);
+  renameSync3(`${file}.tmp`, file);
+}
+function sandboxImageStatus(state, plan) {
+  const s = state[plan.repo];
+  const current = s?.tags[0];
+  if (s?.failure && s.failure.tag === plan.tag) {
+    return { status: "failed", detail: `last build of ${plan.tag} failed at ${s.failure.at}; log ${s.failure.logPath}${current ? `; running ${current.tag}` : ""}` };
+  }
+  if (!current) return { status: "missing", detail: `no image built yet (wants ${plan.tag}); run \`crew sandbox build\`` };
+  if (current.tag !== plan.tag) return { status: "stale", detail: `running ${current.tag}, declaration now builds ${plan.tag}` };
+  return { status: "ok", detail: `${current.tag} built ${current.builtAt}` };
+}
+var spawnBuildRunner = (engine = "docker") => (args, logPath) => new Promise((resolve7) => {
+  const child = spawn2(engine, args, { stdio: ["ignore", "pipe", "pipe"] });
+  const chunks = [];
+  child.stdout.on("data", (d) => chunks.push(d));
+  child.stderr.on("data", (d) => chunks.push(d));
+  const done = (code, extra = "") => {
+    writeFileSync10(logPath, `$ ${engine} ${args.join(" ")}
+${Buffer.concat(chunks).toString("utf8")}${extra}`, { flag: "a" });
+    resolve7(code);
+  };
+  child.on("error", (e) => done(127, `${e.message}
+`));
+  child.on("close", (code) => done(code ?? 1));
+});
+var engineHasImage = (engine = "docker", exec = realExec) => (tag) => {
+  try {
+    exec(engine, ["image", "inspect", tag], { timeoutMs: 2e4 });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var engineRemoveImage = (engine = "docker", exec = realExec) => (tag) => {
+  try {
+    exec(engine, ["image", "rm", tag], { timeoutMs: 6e4 });
+  } catch {
+  }
+};
+var sandboxLogDir = (stateDir) => join15(stateDir, "sandbox-logs");
+async function buildSandboxImage(plan, deps) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const state = readSandboxState(deps.stateDir);
+  const entry = state[plan.repo] ?? { tags: [] };
+  if (entry.tags[0]?.tag === plan.tag && deps.hasImage(plan.tag)) {
+    return { kind: "reused", tag: plan.tag };
+  }
+  const logDir = sandboxLogDir(deps.stateDir);
+  mkdirSync9(logDir, { recursive: true });
+  const logPath = join15(logDir, `${slug(plan.repo)}-${now().toISOString().replace(/[:.]/g, "-")}.log`);
+  const builtLayers = [];
+  for (const layer of plan.layers) {
+    if (deps.hasImage(layer.tag)) continue;
+    const ctx = join15(tmpdir2(), `crew-sandbox-${hash([layer.tag, process.pid, Date.now()])}`);
+    mkdirSync9(ctx, { recursive: true });
+    try {
+      writeFileSync10(join15(ctx, "Dockerfile"), layer.dockerfile);
+      for (const [name, content] of Object.entries(layer.files)) writeFileSync10(join15(ctx, name), content);
+      const code = await deps.run(["build", "--tag", layer.tag, "--file", join15(ctx, "Dockerfile"), ctx], logPath);
+      if (code !== 0) {
+        state[plan.repo] = { ...entry, failure: { tag: plan.tag, at: now().toISOString(), logPath } };
+        writeSandboxState(deps.stateDir, state);
+        return { kind: "failed", tag: plan.tag, logPath, layer: layer.name };
+      }
+      builtLayers.push(layer.name);
+    } finally {
+      rmSync9(ctx, { recursive: true, force: true });
+    }
+  }
+  const tags = [{ tag: plan.tag, builtAt: now().toISOString() }, ...entry.tags.filter((t) => t.tag !== plan.tag)];
+  const dropped = tags.slice(KEEP_TAGS);
+  state[plan.repo] = { tags: tags.slice(0, KEEP_TAGS) };
+  writeSandboxState(deps.stateDir, state);
+  for (const t of dropped) deps.removeImage(t.tag);
+  return { kind: "built", tag: plan.tag, builtLayers };
+}
+var sandboxFailedKey = (repo) => `sandbox_build_failed:${repo}`;
+function sandboxFailedItem(repo, tag, layer, logPath, nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    kind: "sandbox_build_failed",
+    key: sandboxFailedKey(repo),
+    since: nowIso,
+    message: `${repo}: sandbox image ${tag} failed to build at the ${layer} layer (log: ${logPath}); sandboxes keep running the previous image. Retries automatically after the declaration changes or in an hour; \`crew sandbox build\` forces it`
+  };
+}
+async function sandboxBuildTick(repos, deps, force = false) {
+  const nowMs = (deps.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+  for (const r of repos) {
+    const plan = planSandbox(r.name, r.decl);
+    const state = readSandboxState(deps.stateDir)[r.name];
+    const upToDate = state?.tags[0]?.tag === plan.tag && deps.hasImage(plan.tag);
+    if (upToDate) {
+      deps.clear(sandboxFailedKey(r.name));
+      continue;
+    }
+    if (!force && state?.failure?.tag === plan.tag && nowMs - Date.parse(state.failure.at) < SANDBOX_RETRY_AFTER_MS) continue;
+    deps.log(`sandbox image for ${r.name}: building ${plan.tag}`);
+    const out = await buildSandboxImage(plan, deps);
+    if (out.kind === "failed") {
+      deps.raise(sandboxFailedItem(r.name, out.tag, out.layer, out.logPath));
+      deps.log(`sandbox image for ${r.name}: build failed at the ${out.layer} layer, log ${out.logPath}`);
+    } else {
+      deps.clear(sandboxFailedKey(r.name));
+      deps.log(`sandbox image for ${r.name}: ${out.kind === "built" ? `built ${out.tag}` : `${out.tag} already built`}`);
+    }
+    return r.name;
+  }
+  return null;
+}
+
+// src/doctor-checks.ts
+import { execFileSync as execFileSync4 } from "child_process";
 var PROBE_BRANCH = "crew-probe-branch";
 var realGit = (cwd, args, env) => {
-  execFileSync3("git", args, { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+  execFileSync4("git", args, { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
 };
 function isSshRemote(url) {
   return /^ssh:\/\//.test(url) || /^[\w.-]+@[\w.-]+:/.test(url);
@@ -5325,12 +5783,12 @@ function isSshRemote(url) {
 function pushAuthHint(remoteUrl) {
   return isSshRemote(remoteUrl) ? "make sure an SSH key is loaded for this host (ssh-add), and that the scheduler user can reach it" : "run `gh auth login`, then `gh auth setup-git`";
 }
-function probePushAuth(o, run2 = realGit, baseEnv = process.env) {
+function probePushAuth(o, run3 = realGit, baseEnv = process.env) {
   if (o.offline) return { state: "skipped", detail: "skipped (--offline)" };
   if (!o.remoteUrl) return { state: "skipped", detail: `no remote "${o.remote}" configured` };
   const env = { ...baseEnv, GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never", GIT_SSH_COMMAND: `${baseEnv.GIT_SSH_COMMAND ?? "ssh"} -o BatchMode=yes` };
   try {
-    run2(o.dir, ["push", "--dry-run", o.remote, `HEAD:refs/heads/${PROBE_BRANCH}`], env);
+    run3(o.dir, ["push", "--dry-run", o.remote, `HEAD:refs/heads/${PROBE_BRANCH}`], env);
     return { state: "ok" };
   } catch (e) {
     const err3 = e;
@@ -5346,7 +5804,7 @@ function probePushAuth(o, run2 = realGit, baseEnv = process.env) {
       };
     }
     try {
-      run2(o.dir, ["ls-remote", "--exit-code", o.remote, "HEAD"], env);
+      run3(o.dir, ["ls-remote", "--exit-code", o.remote, "HEAD"], env);
       return {
         state: "failed",
         detail: `the token for forge ${f.host} is read-only (fetch works, push refused): ${detail}`,
@@ -5438,31 +5896,31 @@ function roleCapWarnings(ship) {
 }
 
 // src/selftest.ts
-import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync22, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync2, readFileSync as readFileSync20, rmSync as rmSync13, writeFileSync as writeFileSync15 } from "fs";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join24 } from "path";
+import { spawn as spawn5 } from "child_process";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync2, readFileSync as readFileSync21, rmSync as rmSync14, writeFileSync as writeFileSync16 } from "fs";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join25 } from "path";
 
 // src/agent.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { readFileSync as readFileSync19, existsSync as existsSync21, statSync as statSync7, mkdirSync as mkdirSync12, writeFileSync as writeFileSync14, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
+import { readFileSync as readFileSync20, existsSync as existsSync21, statSync as statSync7, mkdirSync as mkdirSync13, writeFileSync as writeFileSync15, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
 import { StringDecoder } from "string_decoder";
 import { finished } from "stream/promises";
-import { join as join23, dirname as dirname8, basename as basename8 } from "path";
-import { createHash as createHash4 } from "crypto";
+import { join as join24, dirname as dirname8, basename as basename8 } from "path";
+import { createHash as createHash6 } from "crypto";
 
 // src/state.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, existsSync as existsSync14, mkdirSync as mkdirSync9, rmSync as rmSync9, statSync as statSync6, readdirSync as readdirSync5 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, existsSync as existsSync14, mkdirSync as mkdirSync10, rmSync as rmSync10, statSync as statSync6, readdirSync as readdirSync5 } from "fs";
+import { join as join16 } from "path";
 var EPOCH = "1970-01-01T00:00:00.000Z";
 var State = class _State {
   dir;
   constructor(dir) {
     this.dir = dir;
-    mkdirSync9(dir, { recursive: true });
+    mkdirSync10(dir, { recursive: true });
   }
   path(...parts) {
-    return join15(this.dir, ...parts);
+    return join16(this.dir, ...parts);
   }
   /**
    * The timestamp every "new since last poll" check is measured against.
@@ -5473,14 +5931,14 @@ var State = class _State {
    */
   watermark() {
     try {
-      const v = readFileSync14(this.path(".poll-watermark"), "utf8").trim();
+      const v = readFileSync15(this.path(".poll-watermark"), "utf8").trim();
       return v || EPOCH;
     } catch {
       return EPOCH;
     }
   }
   setWatermark(at) {
-    writeFileSync10(this.path(".poll-watermark"), `${at}
+    writeFileSync11(this.path(".poll-watermark"), `${at}
 `);
   }
   /**
@@ -5507,10 +5965,10 @@ var State = class _State {
     return new Set(roles.filter((r) => this.isRolePaused(r)));
   }
   pause(role) {
-    writeFileSync10(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
+    writeFileSync11(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
   }
   resume(role) {
-    rmSync9(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
+    rmSync10(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
   }
   /**
    * The release phase (merge, deploy, release) has its own sentinel, one
@@ -5521,8 +5979,8 @@ var State = class _State {
     return existsSync14(this.path(".release-paused"));
   }
   setReleasePaused(paused) {
-    if (paused) writeFileSync10(this.path(".release-paused"), "");
-    else rmSync9(this.path(".release-paused"), { force: true });
+    if (paused) writeFileSync11(this.path(".release-paused"), "");
+    else rmSync10(this.path(".release-paused"), { force: true });
   }
   /**
    * Why a release cycle must not run right now, or null when it may. Every
@@ -5559,7 +6017,7 @@ var State = class _State {
     const name = _State.safe(rawName);
     const file = this.path(`.${name}.lock`);
     try {
-      const existing = Number.parseInt(readFileSync14(file, "utf8").trim(), 10);
+      const existing = Number.parseInt(readFileSync15(file, "utf8").trim(), 10);
       if (Number.isFinite(existing) && existing > 0) {
         try {
           process.kill(existing, 0);
@@ -5569,13 +6027,13 @@ var State = class _State {
       }
     } catch {
     }
-    writeFileSync10(file, `${process.pid}
+    writeFileSync11(file, `${process.pid}
 `);
     return {
       ok: true,
       release: () => {
         try {
-          rmSync9(file, { force: true });
+          rmSync10(file, { force: true });
         } catch {
         }
       }
@@ -5597,7 +6055,7 @@ var State = class _State {
       if (!/^\.release-.+\.lock$/.test(n)) continue;
       let pid = 0;
       try {
-        pid = Number.parseInt(readFileSync14(this.path(n), "utf8").trim(), 10);
+        pid = Number.parseInt(readFileSync15(this.path(n), "utf8").trim(), 10);
       } catch {
         continue;
       }
@@ -5683,7 +6141,7 @@ var State = class _State {
   ticketInFlight(recordId) {
     const file = this.path(`.${_State.safe(`crew-ticket-${recordId}`)}.lock`);
     try {
-      const pid = Number.parseInt(readFileSync14(file, "utf8").trim(), 10);
+      const pid = Number.parseInt(readFileSync15(file, "utf8").trim(), 10);
       if (!Number.isFinite(pid) || pid <= 0) return false;
       process.kill(pid, 0);
       return true;
@@ -5717,7 +6175,7 @@ var State = class _State {
     const heldReported = `.release-held-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync14(this.path(f), "utf8").trim() || null;
+        return readFileSync15(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -5726,12 +6184,12 @@ var State = class _State {
       blockedCount: () => Number.parseInt(read(blocked) ?? "", 10) || 0,
       noteBlocked: () => {
         const n = (Number.parseInt(read(blocked) ?? "", 10) || 0) + 1;
-        writeFileSync10(this.path(blocked), `${n}
+        writeFileSync11(this.path(blocked), `${n}
 `);
         return n;
       },
       clearBlocked: () => {
-        rmSync9(this.path(blocked), { force: true });
+        rmSync10(this.path(blocked), { force: true });
       },
       /**
        * The commit a deploy last failed on.
@@ -5743,11 +6201,11 @@ var State = class _State {
        */
       deployFailedSha: () => read(failed),
       noteDeployFailed: (sha) => {
-        writeFileSync10(this.path(failed), `${sha}
+        writeFileSync11(this.path(failed), `${sha}
 `);
       },
       clearDeployFailed: () => {
-        rmSync9(this.path(failed), { force: true });
+        rmSync10(this.path(failed), { force: true });
       },
       /**
        * Consecutive test-gate failures on the same head (CREW-1368). A failure
@@ -5757,31 +6215,31 @@ var State = class _State {
       noteTestGateFailed: (sha) => {
         const [prev, n] = (read(gateFailed) ?? "").split(" ");
         const next = prev === sha ? (Number.parseInt(n ?? "", 10) || 0) + 1 : 1;
-        writeFileSync10(this.path(gateFailed), `${sha} ${next}
+        writeFileSync11(this.path(gateFailed), `${sha} ${next}
 `);
         return next;
       },
       clearTestGateFailed: () => {
-        rmSync9(this.path(gateFailed), { force: true });
+        rmSync10(this.path(gateFailed), { force: true });
       },
       /** Whether the board was already told about this head's red gate. */
       heldReported: () => {
         try {
-          return readFileSync14(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
+          return readFileSync15(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
         } catch {
           return null;
         }
       },
       noteHeldReported: (signature) => {
-        writeFileSync10(this.path(heldReported), `${signature}
+        writeFileSync11(this.path(heldReported), `${signature}
 `);
       },
       clearHeldReported: () => {
-        rmSync9(this.path(heldReported), { force: true });
+        rmSync10(this.path(heldReported), { force: true });
       },
       testGateReported: (sha) => read(gateReported) === sha,
       noteTestGateReported: (sha) => {
-        writeFileSync10(this.path(gateReported), `${sha}
+        writeFileSync11(this.path(gateReported), `${sha}
 `);
       }
     };
@@ -5804,13 +6262,13 @@ var State = class _State {
     const ticketStreakFile = `.fairness-ticket-streak-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync14(this.path(f), "utf8").trim() || null;
+        return readFileSync15(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
     };
     const clear2 = () => {
-      for (const f of [streakFile, ticketFile, sinceFile, ticketStreakFile]) rmSync9(this.path(f), { force: true });
+      for (const f of [streakFile, ticketFile, sinceFile, ticketStreakFile]) rmSync10(this.path(f), { force: true });
     };
     return {
       /** Consecutive cycles this route had actionable work and did not win. */
@@ -5837,18 +6295,18 @@ var State = class _State {
           clear2();
           return;
         }
-        writeFileSync10(this.path(streakFile), `${this.readInt(streakFile) + 1}
+        writeFileSync11(this.path(streakFile), `${this.readInt(streakFile) + 1}
 `);
         const prior = read(ticketFile);
         if (topTicket && topTicket === prior) {
-          writeFileSync10(this.path(ticketStreakFile), `${this.readInt(ticketStreakFile) + 1}
+          writeFileSync11(this.path(ticketStreakFile), `${this.readInt(ticketStreakFile) + 1}
 `);
         } else if (topTicket) {
-          writeFileSync10(this.path(ticketFile), `${topTicket}
+          writeFileSync11(this.path(ticketFile), `${topTicket}
 `);
-          writeFileSync10(this.path(sinceFile), `${(/* @__PURE__ */ new Date()).toISOString()}
+          writeFileSync11(this.path(sinceFile), `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
-          writeFileSync10(this.path(ticketStreakFile), "1\n");
+          writeFileSync11(this.path(ticketStreakFile), "1\n");
         }
       }
     };
@@ -5869,14 +6327,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync14(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync15(this.path(file), "utf8"));
           return parsed && typeof parsed === "object" ? parsed : {};
         } catch {
           return {};
         }
       },
       persist: (next) => {
-        writeFileSync10(this.path(file), JSON.stringify(next));
+        writeFileSync11(this.path(file), JSON.stringify(next));
       }
     };
   }
@@ -5892,14 +6350,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync14(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync15(this.path(file), "utf8"));
           return Array.isArray(parsed) ? parsed.filter((x) => typeof x === "string") : [];
         } catch {
           return [];
         }
       },
       persist: (next) => {
-        writeFileSync10(this.path(file), JSON.stringify(next));
+        writeFileSync11(this.path(file), JSON.stringify(next));
       }
     };
   }
@@ -5913,14 +6371,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync14(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync15(this.path(file), "utf8"));
           return Array.isArray(parsed) ? parsed : [];
         } catch {
           return [];
         }
       },
       persist: (next) => {
-        writeFileSync10(this.path(file), JSON.stringify(next));
+        writeFileSync11(this.path(file), JSON.stringify(next));
       }
     };
   }
@@ -5933,7 +6391,7 @@ var State = class _State {
     const file = ".release-last-run";
     return {
       touch: () => {
-        writeFileSync10(this.path(file), (/* @__PURE__ */ new Date()).toISOString());
+        writeFileSync11(this.path(file), (/* @__PURE__ */ new Date()).toISOString());
       },
       at: () => {
         try {
@@ -5946,7 +6404,7 @@ var State = class _State {
   }
   readInt(file) {
     try {
-      return Number.parseInt(readFileSync14(this.path(file), "utf8").trim(), 10) || 0;
+      return Number.parseInt(readFileSync15(this.path(file), "utf8").trim(), 10) || 0;
     } catch {
       return 0;
     }
@@ -6429,8 +6887,8 @@ var PERISCOPE_COLUMNS = [
 ];
 
 // src/agent-log.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, readdirSync as readdirSync6, readFileSync as readFileSync15, rmSync as rmSync10, writeFileSync as writeFileSync11 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync11, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync11, writeFileSync as writeFileSync12 } from "fs";
+import { join as join17 } from "path";
 
 // src/pending-backoff.ts
 var sleepBackoff = (attempts) => Math.min(6e4 * 2 ** Math.max(0, attempts - 1), 30 * 6e4);
@@ -6487,14 +6945,14 @@ async function findTicketRecord(target, t, ref) {
   );
   return rows.length === 1 ? rows[0].id : void 0;
 }
-function counterIncrements(run2, cols, have) {
+function counterIncrements(run3, cols, have) {
   const figures = [
     [cols.agentRuns, 1],
-    [cols.tokensIn, run2.tokensIn],
-    [cols.tokensOut, run2.tokensOut],
-    [cols.cacheReadTokens, run2.cacheReadTokens],
-    [cols.cacheWriteTokens, run2.cacheWriteTokens],
-    [cols.costUsd, run2.costUsd]
+    [cols.tokensIn, run3.tokensIn],
+    [cols.tokensOut, run3.tokensOut],
+    [cols.cacheReadTokens, run3.cacheReadTokens],
+    [cols.cacheWriteTokens, run3.cacheWriteTokens],
+    [cols.costUsd, run3.costUsd]
   ];
   const out = {};
   for (const [column, value2] of figures) {
@@ -6517,41 +6975,41 @@ async function post(target, path, body) {
   if (!res.ok) throw new AgentLogHttpError(`${path}: ${res.status} ${res.statusText}`, res.status);
   return await res.json();
 }
-async function reportAgentRun(target, run2) {
+async function reportAgentRun(target, run3) {
   let ticketRecordId;
-  if (target.tickets && run2.ticketReference) {
+  if (target.tickets && run3.ticketReference) {
     try {
-      ticketRecordId = await findTicketRecord(target, target.tickets, run2.ticketReference);
+      ticketRecordId = await findTicketRecord(target, target.tickets, run3.ticketReference);
     } catch {
     }
   }
   const body = {
     agentId: target.agentId,
-    ticketReference: run2.ticketReference,
-    outcome: run2.outcome,
-    startedAt: run2.startedAt,
-    finishedAt: run2.finishedAt,
+    ticketReference: run3.ticketReference,
+    outcome: run3.outcome,
+    startedAt: run3.startedAt,
+    finishedAt: run3.finishedAt,
     source: "client",
     client: "crew",
-    model: run2.model,
-    tokensIn: run2.tokensIn,
-    tokensOut: run2.tokensOut,
-    cacheReadTokens: run2.cacheReadTokens,
-    cacheWriteTokens: run2.cacheWriteTokens,
-    costUsd: run2.costUsd,
-    numTurns: run2.numTurns,
-    prefixTokens: run2.prefixTokens,
-    promptVersion: run2.promptVersion,
-    promptSha: run2.promptSha
+    model: run3.model,
+    tokensIn: run3.tokensIn,
+    tokensOut: run3.tokensOut,
+    cacheReadTokens: run3.cacheReadTokens,
+    cacheWriteTokens: run3.cacheWriteTokens,
+    costUsd: run3.costUsd,
+    numTurns: run3.numTurns,
+    prefixTokens: run3.prefixTokens,
+    promptVersion: run3.promptVersion,
+    promptSha: run3.promptSha
   };
   const workItem = target.tickets && ticketRecordId ? { workItemTable: target.tickets.issuesModelId, workItemRecordId: ticketRecordId } : {};
   let entry;
   try {
-    entry = await post(target, "/agents/log", { ...body, ...workItem, harness: run2.harness, provider: run2.provider });
+    entry = await post(target, "/agents/log", { ...body, ...workItem, harness: run3.harness, provider: run3.provider });
   } catch (e) {
     if (!(e instanceof AgentLogHttpError)) throw new AgentLogUnreachableError(e.message);
     if (e.status >= 500) throw new AgentLogUnreachableError(e.message);
-    if (e.status !== 400 || !run2.harness && !run2.provider && !ticketRecordId) {
+    if (e.status !== 400 || !run3.harness && !run3.provider && !ticketRecordId) {
       e.row = true;
       throw e;
     }
@@ -6562,7 +7020,7 @@ async function reportAgentRun(target, run2) {
       throw e2;
     }
   }
-  for (const cycle of run2.cycles) {
+  for (const cycle of run3.cycles) {
     await post(target, `/agents/log/${entry.id}/cycles`, {
       cycleIndex: cycle.cycleIndex,
       occurredAt: cycle.occurredAt,
@@ -6570,7 +7028,7 @@ async function reportAgentRun(target, run2) {
       ...cycle.role ? { role: cycle.role } : {}
     });
   }
-  const counters = target.tickets && ticketRecordId ? await addRunToTicket(target, target.tickets, ticketRecordId, run2) : void 0;
+  const counters = target.tickets && ticketRecordId ? await addRunToTicket(target, target.tickets, ticketRecordId, run3) : void 0;
   return {
     agentLogId: entry.id,
     ...counters?.warning ? { counterWarning: counters.warning } : {},
@@ -6584,38 +7042,38 @@ async function writeCounters(target, w) {
   if (Object.keys(body).length === 0) return;
   await request(target, "PATCH", `/data-models/${w.issuesModelId}/records/${w.recordId}`, body);
 }
-async function addRunToTicket(target, t, recordId, run2) {
+async function addRunToTicket(target, t, recordId, run3) {
   const write = {
     issuesModelId: t.issuesModelId,
     recordId,
-    ticketReference: run2.ticketReference,
+    ticketReference: run3.ticketReference,
     counters: t.counters,
-    body: counterIncrements(run2, t.counters, new Set(Object.values(t.counters)))
+    body: counterIncrements(run3, t.counters, new Set(Object.values(t.counters)))
   };
   try {
     await writeCounters(target, write);
     return {};
   } catch (e) {
     return {
-      warning: `could not add run spend to ${run2.ticketReference}: ${e.message}`,
+      warning: `could not add run spend to ${run3.ticketReference}: ${e.message}`,
       ...isRetryable(e) ? { retry: write } : {}
     };
   }
 }
-var queueDir = (stateDir) => join16(stateDir, "pending-agent-logs");
+var queueDir = (stateDir) => join17(stateDir, "pending-agent-logs");
 function queueAgentRun(stateDir, name, q) {
-  mkdirSync10(queueDir(stateDir), { recursive: true });
-  writeFileSync11(join16(queueDir(stateDir), `${name}.json`), JSON.stringify(q));
+  mkdirSync11(queueDir(stateDir), { recursive: true });
+  writeFileSync12(join17(queueDir(stateDir), `${name}.json`), JSON.stringify(q));
 }
 async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = queueDir(stateDir);
   if (!existsSync15(dir)) return 0;
   let sent = 0;
   for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join16(dir, f);
+    const path = join17(dir, f);
     let q;
     try {
-      q = JSON.parse(readFileSync15(path, "utf8"));
+      q = JSON.parse(readFileSync16(path, "utf8"));
     } catch {
       continue;
     }
@@ -6634,17 +7092,17 @@ async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__
         attempts: 0,
         nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      rmSync10(path, { force: true });
+      rmSync11(path, { force: true });
       sent += 1;
       log.emit(`sent a queued Agent Log report (${f})`);
     } catch (e) {
       if (!(e instanceof AgentLogUnreachableError)) {
-        rmSync10(path, { force: true });
+        rmSync11(path, { force: true });
         log.warn(`dropped a queued Agent Log report (${f}): ${e.message}`);
         continue;
       }
       const attempts = q.attempts + 1;
-      writeFileSync11(path, JSON.stringify({
+      writeFileSync12(path, JSON.stringify({
         ...q,
         attempts,
         warned: true,
@@ -6655,20 +7113,20 @@ async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__
   }
   return sent;
 }
-var countersDir = (stateDir) => join16(stateDir, "pending-ticket-counters");
+var countersDir = (stateDir) => join17(stateDir, "pending-ticket-counters");
 function queueTicketCounters(stateDir, name, q) {
-  mkdirSync10(countersDir(stateDir), { recursive: true });
-  writeFileSync11(join16(countersDir(stateDir), `${name}.json`), JSON.stringify(q));
+  mkdirSync11(countersDir(stateDir), { recursive: true });
+  writeFileSync12(join17(countersDir(stateDir), `${name}.json`), JSON.stringify(q));
 }
 async function replayQueuedTicketCounters(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = countersDir(stateDir);
   if (!existsSync15(dir)) return 0;
   let sent = 0;
   for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join16(dir, f);
+    const path = join17(dir, f);
     let q;
     try {
-      q = JSON.parse(readFileSync15(path, "utf8"));
+      q = JSON.parse(readFileSync16(path, "utf8"));
     } catch {
       continue;
     }
@@ -6677,17 +7135,17 @@ async function replayQueuedTicketCounters(stateDir, route2, keyFor, log, now = /
       const apiKey = await keyFor(q.role);
       if (!apiKey) continue;
       await writeCounters({ ...q.target, apiKey }, q.write);
-      rmSync10(path, { force: true });
+      rmSync11(path, { force: true });
       sent += 1;
       log.emit(`added a queued run's spend to ${q.write.ticketReference ?? q.write.recordId} (${f})`);
     } catch (e) {
       if (!isRetryable(e)) {
-        rmSync10(path, { force: true });
+        rmSync11(path, { force: true });
         log.warn(`dropped a queued ticket counter update (${f}): ${e.message}`);
         continue;
       }
       const attempts = q.attempts + 1;
-      writeFileSync11(path, JSON.stringify({
+      writeFileSync12(path, JSON.stringify({
         ...q,
         attempts,
         warned: true,
@@ -6890,8 +7348,8 @@ var HandoffTranscriptTracker = class {
 };
 
 // src/pending-handoff.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, readdirSync as readdirSync7, readFileSync as readFileSync16, rmSync as rmSync11, writeFileSync as writeFileSync12 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync12, readdirSync as readdirSync7, readFileSync as readFileSync17, rmSync as rmSync12, writeFileSync as writeFileSync13 } from "fs";
+import { join as join20 } from "path";
 
 // src/ticket-branch.ts
 import { basename as basename6 } from "path";
@@ -8058,15 +8516,15 @@ function holdWarnings(tickets, ships, contract, humanHolds, now = Date.now()) {
 
 // src/run-worktree.ts
 import { existsSync as existsSync17 } from "fs";
-import { dirname as dirname7, join as join18 } from "path";
+import { dirname as dirname7, join as join19 } from "path";
 
 // src/ports.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 import { existsSync as existsSync16 } from "fs";
-import { join as join17 } from "path";
-var run = (cmd, args) => {
+import { join as join18 } from "path";
+var run2 = (cmd, args) => {
   try {
-    return execFileSync4(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return execFileSync5(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
   } catch {
     return "";
   }
@@ -8080,7 +8538,7 @@ function listeners() {
     seen.add(key);
     out.push({ pid, port });
   };
-  const lsof = run("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN"]);
+  const lsof = run2("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN"]);
   if (lsof) {
     for (const line of lsof.split("\n").slice(1)) {
       const cols = line.split(/\s+/);
@@ -8090,7 +8548,7 @@ function listeners() {
     }
     return out;
   }
-  const ss = run("ss", ["-ltnpH"]);
+  const ss = run2("ss", ["-ltnpH"]);
   for (const line of ss.split("\n")) {
     const local = line.trim().split(/\s+/)[3];
     const pid = /pid=(\d+)/.exec(line)?.[1];
@@ -8108,7 +8566,7 @@ function ticketForPort(port, s = DEFAULT_PORTS) {
 }
 function worktreeExists(parent, prefix, n) {
   for (const name of [`${prefix}${n}`, `${prefix}${String(n).padStart(3, "0")}`]) {
-    if (existsSync16(join17(parent, name, ".git"))) return true;
+    if (existsSync16(join18(parent, name, ".git"))) return true;
   }
   return false;
 }
@@ -8142,7 +8600,7 @@ async function killGently(pids, graceMs = 2e3) {
 function pidsInWorktree(path, n, s = DEFAULT_PORTS) {
   const pids = /* @__PURE__ */ new Set();
   for (const port of [s.backendBase + n, s.frontendBase + n]) for (const p of pidsOnPort(port)) pids.add(p);
-  const matched = run("pgrep", ["-f", `${path}/`]);
+  const matched = run2("pgrep", ["-f", `${path}/`]);
   for (const line of matched.split("\n")) {
     const pid = Number(line.trim());
     if (Number.isFinite(pid) && pid > 0 && pid !== process.pid) pids.add(pid);
@@ -8207,7 +8665,7 @@ function planRunWorktree(dir, cfg, t, role, opts = {}) {
     if (countCommits(existing.path, `${baseRef}..HEAD`) > 0) return { action: "leave-unpushed", path: existing.path, branch };
     return { action: "recut", path: existing.path, branch, base: baseRef };
   }
-  const path = join18(dirname7(dir), worktreeForTicket(dir, cfg, t, role));
+  const path = join19(dirname7(dir), worktreeForTicket(dir, cfg, t, role));
   if (located?.where === "remote" || located && hasRemote && remoteBranchExists(dir, remote, located.branch)) {
     return { action: "cut-remote", path, branch: located.branch };
   }
@@ -8664,12 +9122,12 @@ async function guardRunStrays(route2, ship, tracker, role, workingId, since2, lo
 
 // src/pending-handoff.ts
 var PENDING_MAX_AGE_MS = 48 * 36e5;
-var pendingDirFor = (stateDir) => join19(stateDir, "pending-handoffs");
-var stateDirOfStream = (streamPath) => join19(streamPath, "..", "..");
+var pendingDirFor = (stateDir) => join20(stateDir, "pending-handoffs");
+var stateDirOfStream = (streamPath) => join20(streamPath, "..", "..");
 function writePendingHandoff(stateDir, rec) {
   const dir = pendingDirFor(stateDir);
-  mkdirSync11(dir, { recursive: true });
-  writeFileSync12(join19(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
+  mkdirSync12(dir, { recursive: true });
+  writeFileSync13(join20(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
 }
 function listPendingHandoffs(stateDir, route2) {
   const dir = pendingDirFor(stateDir);
@@ -8677,7 +9135,7 @@ function listPendingHandoffs(stateDir, route2) {
   const out = [];
   for (const f of readdirSync7(dir).filter((n) => n.endsWith(".json")).sort()) {
     try {
-      const rec = JSON.parse(readFileSync16(join19(dir, f), "utf8"));
+      const rec = JSON.parse(readFileSync17(join20(dir, f), "utf8"));
       if (rec.version === 1 && rec.ticketRecordId && (!route2 || rec.route === route2)) out.push(rec);
     } catch {
     }
@@ -8685,7 +9143,7 @@ function listPendingHandoffs(stateDir, route2) {
   return out;
 }
 function removePendingHandoff(stateDir, ticketRecordId) {
-  rmSync11(join19(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
+  rmSync12(join20(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
 }
 function pendingHandoffFor(stateDir, ticketRecordId) {
   return listPendingHandoffs(stateDir).find((r) => r.ticketRecordId === ticketRecordId);
@@ -8795,8 +9253,8 @@ function expandSkillMarkers(text2, lookup2, opts = {}) {
 }
 
 // src/skills.ts
-import { readFileSync as readFileSync18, readdirSync as readdirSync8, existsSync as existsSync20 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync19, readdirSync as readdirSync8, existsSync as existsSync20 } from "fs";
+import { join as join22 } from "path";
 import { parse as parseYaml } from "yaml";
 import { TablationClient as TablationClient3, StaleWriteError as StaleWriteError3, TablationApiError as TablationApiError2 } from "@tablation/client";
 
@@ -8812,8 +9270,8 @@ ${additions}`;
 }
 
 // src/agents.ts
-import { readFileSync as readFileSync17, existsSync as existsSync19 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync18, existsSync as existsSync19 } from "fs";
+import { join as join21 } from "path";
 import { TablationClient as TablationClient2, StaleWriteError as StaleWriteError2, TablationApiError } from "@tablation/client";
 var PERSONA_NAME = {
   dev: "Developer",
@@ -8827,12 +9285,12 @@ var CREW_AGENT_COLUMN = "agent_id";
 var AgentsSyncError = class extends Error {
 };
 function personaDefaultPrompt(promptsDir, role) {
-  const briefPath = join20(promptsDir, "personas", `lane-${role}.md`);
+  const briefPath = join21(promptsDir, "personas", `lane-${role}.md`);
   if (!existsSync19(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
-  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync17(briefPath, "utf8");
-  const commonPath = join20(promptsDir, "personas", "common.md");
-  if (!existsSync19(commonPath)) return readFileSync17(briefPath, "utf8");
-  return `${readFileSync17(commonPath, "utf8")}${readFileSync17(briefPath, "utf8")}`;
+  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync18(briefPath, "utf8");
+  const commonPath = join21(promptsDir, "personas", "common.md");
+  if (!existsSync19(commonPath)) return readFileSync18(briefPath, "utf8");
+  return `${readFileSync18(commonPath, "utf8")}${readFileSync18(briefPath, "utf8")}`;
 }
 async function resolveAgentId(route2, role, opts) {
   const cached = route2.resolved?.agentPersonas?.[role]?.agentId;
@@ -9279,7 +9737,7 @@ function describeCrewLink(o) {
 var SkillSyncError = class extends Error {
 };
 function parseSkillFile(path) {
-  const text2 = readFileSync18(path, "utf8");
+  const text2 = readFileSync19(path, "utf8");
   const match = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/.exec(text2);
   if (!match) throw new SkillSyncError(`${path}: missing YAML frontmatter (expected a leading --- block)`);
   const frontmatter = match[1];
@@ -9292,9 +9750,9 @@ function parseSkillFile(path) {
   return { name: meta.name, description: meta.description, prompt: body, file: path };
 }
 function listLocalSkills(promptsDir) {
-  const dir = join21(promptsDir, "skills");
+  const dir = join22(promptsDir, "skills");
   if (!existsSync20(dir)) return [];
-  return readdirSync8(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join21(dir, f)));
+  return readdirSync8(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join22(dir, f)));
 }
 async function syncSkills(route2, opts) {
   if (!route2.resolved) {
@@ -9478,10 +9936,10 @@ function skillMarkerWarnings(promptsDir, personaPrompts) {
 }
 
 // src/runner.ts
-import { spawn as spawn2, execFile, execFileSync as execFileSync5 } from "child_process";
-import { mkdtempSync, writeFileSync as writeFileSync13, rmSync as rmSync12 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { basename as basename7, join as join22 } from "path";
+import { spawn as spawn3, execFile, execFileSync as execFileSync6 } from "child_process";
+import { mkdtempSync, writeFileSync as writeFileSync14, rmSync as rmSync13 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { basename as basename7, join as join23 } from "path";
 import { promisify } from "util";
 
 // src/run-limit.ts
@@ -9545,7 +10003,7 @@ var SANDBOX_PROMPT_PATH = "/sandbox/prompt.txt";
 var HostRunner = class {
   kind = "host";
   start(plan, o) {
-    const child = spawn2(plan.bin, plan.args, {
+    const child = spawn3(plan.bin, plan.args, {
       cwd: plan.cwd,
       env: o.env,
       stdio: ["pipe", o.streamFd, "inherit"],
@@ -9632,17 +10090,17 @@ var SandboxRunner = class {
       const harness = cfg.agentBin ?? basename7(plan.bin);
       const viaUpload = Buffer.byteLength(plan.prompt) > SANDBOX_STDIN_LIMIT;
       if (viaUpload) {
-        const tmp = mkdtempSync(join22(tmpdir2(), "crew-prompt-"));
+        const tmp = mkdtempSync(join23(tmpdir3(), "crew-prompt-"));
         try {
-          const file = join22(tmp, "prompt.txt");
-          writeFileSync13(file, plan.prompt, { mode: 384 });
+          const file = join23(tmp, "prompt.txt");
+          writeFileSync14(file, plan.prompt, { mode: 384 });
           await this.os(["sandbox", "upload", name, file, SANDBOX_PROMPT_PATH]);
         } finally {
-          rmSync12(tmp, { recursive: true, force: true });
+          rmSync13(tmp, { recursive: true, force: true });
         }
       }
       const command2 = viaUpload ? ["sh", "-c", `exec ${[harness, ...plan.args].map(shQuote2).join(" ")} < ${SANDBOX_PROMPT_PATH}`] : [harness, ...plan.args];
-      const child = spawn2(cfg.bin, ["sandbox", "exec", "-n", name, "--no-login-shell", "--workdir", cfg.workDir, "--", ...command2], {
+      const child = spawn3(cfg.bin, ["sandbox", "exec", "-n", name, "--no-login-shell", "--workdir", cfg.workDir, "--", ...command2], {
         env: process.env,
         stdio: ["pipe", o.streamFd, "inherit"],
         detached: true
@@ -9682,7 +10140,7 @@ function describeExecError(e) {
 }
 function gitOrigin(cwd) {
   try {
-    return execFileSync5("git", ["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    return execFileSync6("git", ["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
   } catch {
     return null;
   }
@@ -9693,16 +10151,16 @@ function runnerFor(kind, sandbox) {
 function runnerOfSidecar(sc) {
   return sc.runner === "sandbox" ? new SandboxRunner(sc.sandboxBin ? { bin: sc.sandboxBin } : {}) : new HostRunner();
 }
-function checkSandboxRunner(cfg = {}, run2 = (b, a) => execFileSync5(b, a, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 15e3 })) {
+function checkSandboxRunner(cfg = {}, run3 = (b, a) => execFileSync6(b, a, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 15e3 })) {
   const bin = cfg.bin ?? DEFAULT_SANDBOX_CONFIG.bin;
   let version;
   try {
-    version = run2(bin, ["--version"]).trim();
+    version = run3(bin, ["--version"]).trim();
   } catch (e) {
     return { ok: false, detail: `${bin} is not installed or not on the scheduler PATH (${e.message.split("\n")[0]})` };
   }
   try {
-    run2(bin, ["status"]);
+    run3(bin, ["status"]);
   } catch (e) {
     const err3 = e;
     return {
@@ -9740,7 +10198,7 @@ var ALLOWANCE_REFUSAL_MARKER = "AI_ALLOWANCE_EXCEEDED";
 function streamShowsAllowanceRefusal(streamPath) {
   let raw;
   try {
-    raw = readFileSync19(streamPath, "utf8");
+    raw = readFileSync20(streamPath, "utf8");
   } catch {
     return false;
   }
@@ -9763,13 +10221,13 @@ function streamShowsAllowanceRefusal(streamPath) {
   }
   return false;
 }
-var digestPathFor = (stateDir, routeLabel, role, runId) => join23(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPathFor = (stateDir, routeLabel, role, runId) => join24(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
 function planAgentRun(o) {
-  const briefPath = join23(o.route.promptsDir, "personas", `lane-${o.role}.md`);
+  const briefPath = join24(o.route.promptsDir, "personas", `lane-${o.role}.md`);
   if (!existsSync21(briefPath)) {
     throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
   }
-  const commonPath = join23(o.route.promptsDir, "personas", "common.md");
+  const commonPath = join24(o.route.promptsDir, "personas", "common.md");
   const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync21(commonPath);
   const now = o.now ?? (() => Date.now());
   const routeLabel = routeSlug(o.route.route);
@@ -9779,10 +10237,10 @@ function planAgentRun(o) {
   let ageSeconds;
   if (existsSync21(digestPath2)) {
     ageSeconds = Math.floor((now() - statSync7(digestPath2).mtimeMs) / 1e3);
-    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync19(digestPath2, "utf8");
+    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync20(digestPath2, "utf8");
   }
-  const common = usesCommon ? readFileSync19(commonPath, "utf8") : "";
-  const brief = readFileSync19(briefPath, "utf8");
+  const common = usesCommon ? readFileSync20(commonPath, "utf8") : "";
+  const brief = readFileSync20(briefPath, "utf8");
   const effectiveCommon = o.divergedPrompt ? "" : common;
   const effectiveBrief = appendAdditions(o.divergedPrompt ?? brief, o.personaAdditions);
   const localSkills = new Map(listLocalSkills(o.route.promptsDir).map((s) => [s.name, s.prompt]));
@@ -9803,8 +10261,8 @@ function planAgentRun(o) {
     brief: expanded.text,
     digest
   });
-  const promptSha = createHash4("sha256").update(expanded.text).digest("hex");
-  const streamsDir = join23(o.stateDir, "streams");
+  const promptSha = createHash6("sha256").update(expanded.text).digest("hex");
+  const streamsDir = join24(o.stateDir, "streams");
   const base = `${routeLabel}-${o.role}-${o.cycle}${o.runId ? `-${o.runId}` : ""}`;
   const seat = resolveSeat(o.ship, o.route, o.role, o.agentPersona ?? (o.agentModel ? { model: o.agentModel } : {}), o.repo);
   const { model } = seat;
@@ -9890,8 +10348,8 @@ function planAgentRun(o) {
     digestAttached: digest !== void 0,
     digestAgeSeconds: ageSeconds,
     model,
-    streamPath: join23(streamsDir, `${base}.jsonl`),
-    eventsPath: join23(streamsDir, `${base}.events.jsonl`),
+    streamPath: join24(streamsDir, `${base}.jsonl`),
+    eventsPath: join24(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
     ticketRecordId: o.ticketRecordId ?? null,
     repo: o.repo ?? null,
@@ -9922,7 +10380,7 @@ function describePlan(p) {
 var pidPathFor = (streamPath) => `${streamPath}.pid`;
 function readRunSidecar(streamPath) {
   try {
-    const sc = JSON.parse(readFileSync19(pidPathFor(streamPath), "utf8"));
+    const sc = JSON.parse(readFileSync20(pidPathFor(streamPath), "utf8"));
     return typeof sc.pid === "number" && typeof sc.spawnedAt === "string" && typeof sc.role === "string" ? sc : null;
   } catch {
     return null;
@@ -9969,7 +10427,7 @@ async function killForDeadline(kill, pid, emit, role, ticket, spawnedAt, limitMi
 var withoutKey = ({ apiKey: _apiKey, ...rest }) => rest;
 function openSink(path) {
   try {
-    mkdirSync12(dirname8(path), { recursive: true });
+    mkdirSync13(dirname8(path), { recursive: true });
     return createWriteStream(path, { flags: "a" });
   } catch {
     return void 0;
@@ -10151,7 +10609,7 @@ var RunObserver = class {
 };
 function writeRunMeta(id, startedAt, liveTicket, extra) {
   try {
-    writeFileSync14(`${id.streamPath}.meta.json`, JSON.stringify({
+    writeFileSync15(`${id.streamPath}.meta.json`, JSON.stringify({
       route: id.route,
       role: id.role,
       hint: id.ticket,
@@ -10311,7 +10769,7 @@ function spawnAgent(plan, emit, hintMoved) {
   const id = identityOf(plan, adapter.harness);
   let streamFd;
   try {
-    mkdirSync12(dirname8(plan.streamPath), { recursive: true });
+    mkdirSync13(dirname8(plan.streamPath), { recursive: true });
     streamFd = openSync3(plan.streamPath, "a");
   } catch (e) {
     void endSink(eventsSink);
@@ -10330,9 +10788,9 @@ function spawnAgent(plan, emit, hintMoved) {
   }
   if (begun instanceof Promise) {
     return begun.then(
-      (run2) => {
+      (run3) => {
         closeSync3(streamFd);
-        return supervise(run2);
+        return supervise(run3);
       },
       (e) => {
         closeSync3(streamFd);
@@ -10369,7 +10827,7 @@ function spawnAgent(plan, emit, hintMoved) {
           promptSha: plan.promptSha
         };
         try {
-          writeFileSync14(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
+          writeFileSync15(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
         } catch {
         }
       }
@@ -10582,9 +11040,9 @@ async function mintMissingSeatKeys(route2, o) {
       out.push({ role, action: "no_agent" });
       continue;
     }
-    const slug = slugFor(route2, agentId);
+    const slug2 = slugFor(route2, agentId);
     try {
-      if ((await store.get(host, slug))?.apiKey) {
+      if ((await store.get(host, slug2))?.apiKey) {
         out.push({ role, action: "already_stored" });
         continue;
       }
@@ -10622,7 +11080,7 @@ async function mintMissingSeatKeys(route2, o) {
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           ...body.id ? { keyId: body.id } : {}
         };
-        await store.set(host, slug, session);
+        await store.set(host, slug2, session);
       } catch (e) {
         let revoked = false;
         if (body.id) {
@@ -10686,9 +11144,9 @@ async function revokeSeatKeys(route2, o) {
       out.push({ role, action: "no_agent" });
       continue;
     }
-    const slug = slugFor(route2, agentId);
+    const slug2 = slugFor(route2, agentId);
     try {
-      const session = await store.get(host, slug);
+      const session = await store.get(host, slug2);
       if (!session?.apiKey) {
         out.push({ role, action: "not_stored" });
         continue;
@@ -10709,7 +11167,7 @@ async function revokeSeatKeys(route2, o) {
         out.push({ role, action: "failed", detail: `${del2.status} ${del2.statusText}` });
         continue;
       }
-      await store.clear(host, slug);
+      await store.clear(host, slug2);
       out.push({ role, action: "revoked", detail: del2.ok ? void 0 : "server already had no such key" });
     } catch (e) {
       out.push({ role, action: "failed", detail: /Command failed|security|sk_|-w /i.test(e.message) ? describeStoreError(e) : e.message });
@@ -10761,7 +11219,7 @@ var realDeps = {
         resolve7(r);
       }
     };
-    const child = spawn4(o.bin, o.args, { cwd: o.cwd, env: o.env, stdio: ["pipe", "pipe", "pipe"], detached: true });
+    const child = spawn5(o.bin, o.args, { cwd: o.cwd, env: o.env, stdio: ["pipe", "pipe", "pipe"], detached: true });
     const killGroup = () => {
       try {
         if (child.pid !== void 0) process.kill(-child.pid, "SIGKILL");
@@ -10859,17 +11317,17 @@ var REMEDY = {
   timeout: "the harness did not answer in time \u2014 run it by hand to see where it stalls",
   "wrong-answer": "the agent answered but did not name the workspace \u2014 run it by hand to see what it said"
 };
-function classify(spec, run2, seen) {
+function classify(spec, run3, seen) {
   const bin = spec.launcher ?? spec.bin;
   const fail = (failure, what) => ({ failure, detail: `${what} \u2014 ${REMEDY[failure]}` });
-  if (run2.spawnError) {
-    if (run2.spawnError.code === "ENOENT") return fail("binary-not-found", `\`${bin}\` is not on the scheduler PATH`);
-    return fail("binary-not-found", `could not start \`${bin}\` (${run2.spawnError.message})`);
+  if (run3.spawnError) {
+    if (run3.spawnError.code === "ENOENT") return fail("binary-not-found", `\`${bin}\` is not on the scheduler PATH`);
+    return fail("binary-not-found", `could not start \`${bin}\` (${run3.spawnError.message})`);
   }
-  if (run2.timedOut) return fail("timeout", "no answer within the time limit");
+  if (run3.timedOut) return fail("timeout", "no answer within the time limit");
   const text2 = `${seen.toolOutput}
-${run2.stderr}`;
-  if (REFUSED.test(seen.toolOutput) || seen.tools.some((t) => t.startsWith("mcp__")) && REFUSED.test(run2.stderr)) {
+${run3.stderr}`;
+  if (REFUSED.test(seen.toolOutput) || seen.tools.some((t) => t.startsWith("mcp__")) && REFUSED.test(run3.stderr)) {
     return fail("key-refused", "the tracker returned 401/403 to the MCP call");
   }
   if (seen.mcpFailed || !seen.tools.some((t) => t.startsWith("mcp__")) && MCP_GONE.test(`${text2}
@@ -10877,8 +11335,8 @@ ${seen.texts.join("\n")}`)) {
     return fail("mcp-unavailable", "the tracker MCP tool was not available to the session");
   }
   const answered = seen.texts.length > 0 || seen.finalText;
-  if (!answered || LOGIN.test(run2.stderr) || LOGIN.test(seen.finalText ?? "")) {
-    return fail("login-missing", `\`${bin}\` exited${run2.code !== null ? ` (${run2.code})` : ""} before answering; the vendor login is probably missing`);
+  if (!answered || LOGIN.test(run3.stderr) || LOGIN.test(seen.finalText ?? "")) {
+    return fail("login-missing", `\`${bin}\` exited${run3.code !== null ? ` (${run3.code})` : ""} before answering; the vendor login is probably missing`);
   }
   return fail("wrong-answer", `the agent replied "${(seen.finalText ?? seen.texts.at(-1) ?? "").trim().slice(0, 80)}"`);
 }
@@ -10906,9 +11364,9 @@ async function runSelftest(i, deps = realDeps) {
     ...adapter.runEnv(spec),
     [KEY_VAR]: i.apiKey
   };
-  const cwd = mkdtempSync2(join24(tmpdir3(), "crew-selftest-"));
+  const cwd = mkdtempSync2(join25(tmpdir4(), "crew-selftest-"));
   try {
-    const run2 = await deps.run({
+    const run3 = await deps.run({
       bin: invocation.bin,
       args: invocation.args,
       cwd,
@@ -10917,18 +11375,18 @@ async function runSelftest(i, deps = realDeps) {
 `,
       timeoutMs: i.timeoutMs ?? SELFTEST_TIMEOUT_MS
     });
-    const seen = observe(spec, run2.stdout);
+    const seen = observe(spec, run3.stdout);
     const answer = [seen.finalText ?? "", ...seen.texts].join("\n");
     const usage2 = { ...seen.tokens !== void 0 ? { tokens: seen.tokens } : {}, ...seen.costUsd !== void 0 ? { costUsd: seen.costUsd } : {} };
-    if (!run2.spawnError && !run2.timedOut && answer.toLowerCase().includes(i.workspaceName.toLowerCase())) {
+    if (!run3.spawnError && !run3.timedOut && answer.toLowerCase().includes(i.workspaceName.toLowerCase())) {
       const auth = spec.harness === "claude" ? ` on ${describeClaudeAuth(spec)}` : "";
       return finish({ ok: true, workspace: i.workspaceName, detail: `read workspace "${i.workspaceName}"${auth}`, ...usage2 });
     }
-    const { failure, detail } = classify(spec, run2, seen);
+    const { failure, detail } = classify(spec, run3, seen);
     return finish({ ok: false, failure, detail, ...usage2 });
   } finally {
     try {
-      rmSync13(cwd, { recursive: true, force: true });
+      rmSync14(cwd, { recursive: true, force: true });
     } catch {
     }
   }
@@ -10939,11 +11397,11 @@ function formatResult(r) {
   const secs = `${(r.ms / 1e3).toFixed(1)}s`;
   return r.ok ? `${r.toolchain}: PASS ${r.detail} (${secs}${tok})` : `${r.toolchain}: FAIL ${r.failure} \u2014 ${r.detail} (${secs})`;
 }
-var fileFor2 = (stateDir) => join24(stateDir, "selftest.json");
+var fileFor2 = (stateDir) => join25(stateDir, "selftest.json");
 function readSelftest(stateDir) {
   try {
     const p = fileFor2(stateDir);
-    return existsSync22(p) ? JSON.parse(readFileSync20(p, "utf8")) : {};
+    return existsSync22(p) ? JSON.parse(readFileSync21(p, "utf8")) : {};
   } catch {
     return {};
   }
@@ -10951,8 +11409,8 @@ function readSelftest(stateDir) {
 function recordSelftest(stateDir, results) {
   const all = readSelftest(stateDir);
   for (const r of results) all[r.toolchain] = r;
-  mkdirSync13(stateDir, { recursive: true });
-  writeFileSync15(fileFor2(stateDir), `${JSON.stringify(all, null, 2)}
+  mkdirSync14(stateDir, { recursive: true });
+  writeFileSync16(fileFor2(stateDir), `${JSON.stringify(all, null, 2)}
 `);
 }
 function doctorSelftestLines(stored, toolchains) {
@@ -10964,7 +11422,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve6, dirname as dirname25, join as join48, basename as basename15 } from "path";
+import { resolve as resolve6, dirname as dirname25, join as join49, basename as basename15 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname4, homedir as homedir11 } from "os";
 import { spawnSync as spawnSync10 } from "child_process";
@@ -11161,14 +11619,14 @@ function rosterMarkdown(roster, meId) {
 }
 
 // src/connect-resume.ts
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync21, rmSync as rmSync14, writeFileSync as writeFileSync16 } from "fs";
-import { dirname as dirname9, join as join25 } from "path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync22, rmSync as rmSync15, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname9, join as join26 } from "path";
 function lastSessionFile(stateDir) {
-  return join25(stateDir, "connect-session.json");
+  return join26(stateDir, "connect-session.json");
 }
 function readPointers(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync21(lastSessionFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync22(lastSessionFile(stateDir), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     const out = {};
     for (const [host, v] of Object.entries(parsed)) {
@@ -11182,8 +11640,8 @@ function readPointers(stateDir) {
 }
 function writePointers(stateDir, pointers) {
   const file = lastSessionFile(stateDir);
-  mkdirSync14(dirname9(file), { recursive: true });
-  writeFileSync16(file, `${JSON.stringify(pointers, null, 2)}
+  mkdirSync15(dirname9(file), { recursive: true });
+  writeFileSync17(file, `${JSON.stringify(pointers, null, 2)}
 `, { mode: 384 });
 }
 function rememberSession(stateDir, host, workspaceSlug) {
@@ -11200,7 +11658,7 @@ function forgetWorkspace(stateDir, host, workspaceSlug) {
     const { [host]: _old, ...rest } = all;
     const next = left.length ? { ...rest, [host]: left } : rest;
     if (Object.keys(next).length) writePointers(stateDir, next);
-    else rmSync14(lastSessionFile(stateDir), { force: true });
+    else rmSync15(lastSessionFile(stateDir), { force: true });
   } catch {
   }
 }
@@ -11240,7 +11698,7 @@ function forgetSession(stateDir, host) {
   try {
     const { [host]: _gone, ...rest } = readPointers(stateDir);
     if (Object.keys(rest).length) writePointers(stateDir, rest);
-    else rmSync14(lastSessionFile(stateDir), { force: true });
+    else rmSync15(lastSessionFile(stateDir), { force: true });
   } catch {
   }
 }
@@ -11268,15 +11726,15 @@ async function signOutSessions(o) {
 }
 
 // src/reset.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync15, readFileSync as readFileSync22, readdirSync as readdirSync9, rmSync as rmSync15, statSync as statSync8, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname10, join as join26 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync16, readFileSync as readFileSync23, readdirSync as readdirSync9, rmSync as rmSync16, statSync as statSync8, writeFileSync as writeFileSync18 } from "fs";
+import { dirname as dirname10, join as join27 } from "path";
 import { hostFromUrl as hostFromUrl3 } from "@tablation/client";
 function clonedCheckoutsFile(stateDir) {
-  return join26(stateDir, "cloned-checkouts.json");
+  return join27(stateDir, "cloned-checkouts.json");
 }
 function readClonedCheckouts(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync22(clonedCheckoutsFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync23(clonedCheckoutsFile(stateDir), "utf8"));
     return Array.isArray(parsed) ? parsed.filter((d) => typeof d === "string") : [];
   } catch {
     return [];
@@ -11286,8 +11744,8 @@ function recordClonedCheckout(stateDir, dir) {
   const known = readClonedCheckouts(stateDir);
   if (known.includes(dir)) return;
   const file = clonedCheckoutsFile(stateDir);
-  mkdirSync15(dirname10(file), { recursive: true });
-  writeFileSync17(file, `${JSON.stringify([...known, dir], null, 2)}
+  mkdirSync16(dirname10(file), { recursive: true });
+  writeFileSync18(file, `${JSON.stringify([...known, dir], null, 2)}
 `);
 }
 var mark = (dryRun) => dryRun ? "would-remove" : "removed";
@@ -11342,7 +11800,7 @@ async function runReset(o, fx) {
   if (o.beforeState) steps.push(...await o.beforeState());
   steps.push(...o.wipeState ? wipeStateDir(o.stateDir, o.dryRun) : removeState(o.stateDir, o.dryRun));
   if (existsSync23(o.configFile)) {
-    if (!o.dryRun) rmSync15(o.configFile, { force: true });
+    if (!o.dryRun) rmSync16(o.configFile, { force: true });
     steps.push({ step: "config", target: o.configFile, action: mark(o.dryRun) });
   } else {
     steps.push({ step: "config", target: o.configFile, action: "absent" });
@@ -11358,21 +11816,21 @@ function removeCheckout(dir, dryRun, fx) {
   if (linkedWorktrees.length) {
     return { step: "checkout", target: dir, action: "kept", detail: `has linked worktrees (${linkedWorktrees.join(", ")}); remove them first` };
   }
-  if (!dryRun) rmSync15(dir, { recursive: true, force: true });
+  if (!dryRun) rmSync16(dir, { recursive: true, force: true });
   return { step: "checkout", target: dir, action: mark(dryRun) };
 }
 function removeState(stateDir, dryRun) {
   const out = [];
-  const targets = [join26(stateDir, "resolved"), join26(stateDir, "keys"), clonedCheckoutsFile(stateDir), join26(stateDir, "connect-session.json"), join26(stateDir, "reload-requested"), join26(stateDir, "daemon.started")];
+  const targets = [join27(stateDir, "resolved"), join27(stateDir, "keys"), clonedCheckoutsFile(stateDir), join27(stateDir, "connect-session.json"), join27(stateDir, "reload-requested"), join27(stateDir, "daemon.started")];
   try {
     for (const name of readdirSync9(stateDir)) {
-      if (name.startsWith(".") && statSync8(join26(stateDir, name)).isFile()) targets.push(join26(stateDir, name));
+      if (name.startsWith(".") && statSync8(join27(stateDir, name)).isFile()) targets.push(join27(stateDir, name));
     }
   } catch {
   }
   for (const t of targets) {
     if (!existsSync23(t)) continue;
-    if (!dryRun) rmSync15(t, { recursive: true, force: true });
+    if (!dryRun) rmSync16(t, { recursive: true, force: true });
     out.push({ step: "state", target: t, action: mark(dryRun) });
   }
   if (!out.length) out.push({ step: "state", target: stateDir, action: "absent", detail: "nothing to remove" });
@@ -11386,7 +11844,7 @@ function wipeStateDir(stateDir, dryRun) {
     return [{ step: "state", target: stateDir, action: "absent", detail: "no state directory" }];
   }
   if (!names.length) return [{ step: "state", target: stateDir, action: "absent", detail: "already empty" }];
-  if (!dryRun) for (const n of names) rmSync15(join26(stateDir, n), { recursive: true, force: true });
+  if (!dryRun) for (const n of names) rmSync16(join27(stateDir, n), { recursive: true, force: true });
   return [{ step: "state", target: stateDir, action: mark(dryRun), detail: `${names.length} entr${names.length === 1 ? "y" : "ies"}` }];
 }
 function describeResetStep(s) {
@@ -11410,21 +11868,21 @@ async function runDeprovision(o, fx, deps) {
   };
   const afterScheduler = async () => {
     const steps2 = [];
-    for (const run2 of deps.liveRuns()) {
-      const target = `${run2.role} run on ${run2.route} (pid ${run2.pid})`;
+    for (const run3 of deps.liveRuns()) {
+      const target = `${run3.role} run on ${run3.route} (pid ${run3.pid})`;
       if (o.dryRun) {
         steps2.push({ step: "run", target, action: "would-remove" });
         continue;
       }
       try {
-        await deps.killRun(run2);
-        deps.recordKill(run2);
+        await deps.killRun(run3);
+        deps.recordKill(run3);
       } catch (e) {
         steps2.push({ step: "run", target, action: "failed", detail: e.message });
         continue;
       }
       try {
-        await deps.handBack(run2);
+        await deps.handBack(run3);
         steps2.push({ step: "run", target, action: "removed", detail: "killed" });
       } catch (e) {
         steps2.push({ step: "run", target, action: "removed", detail: `killed; could not tell its ticket (${e.message})` });
@@ -11471,8 +11929,8 @@ import { spawnSync as spawnSync6 } from "child_process";
 import { existsSync as existsSync26, readdirSync as readdirSync12 } from "fs";
 
 // src/interrupted.ts
-import { existsSync as existsSync24, readdirSync as readdirSync10, readFileSync as readFileSync23 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync24, readdirSync as readdirSync10, readFileSync as readFileSync24 } from "fs";
+import { join as join28 } from "path";
 var INTERRUPTED_MARKER = calloutHeader("NOTE", "Interrupted");
 function interruptedComment(b) {
   const tree = b.dirty === null ? "The worktree could not be checked." : b.dirty ? "The worktree has uncommitted changes \u2014 they are this seat's own, from that run." : "The worktree is clean.";
@@ -11493,19 +11951,19 @@ function runFinished(streamPath) {
   const path = `${streamPath}.meta.json`;
   if (!existsSync24(path)) return false;
   try {
-    return JSON.parse(readFileSync23(path, "utf8")).running !== true;
+    return JSON.parse(readFileSync24(path, "utf8")).running !== true;
   } catch {
     return true;
   }
 }
 function orphanedStreams(o) {
-  const dir = join27(o.stateDir, "streams");
+  const dir = join28(o.stateDir, "streams");
   if (!existsSync24(dir)) return [];
   const ownerAlive = o.isOwnerAlive ?? pidAlive;
   const out = [];
   for (const name of readdirSync10(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join27(dir, name);
+    const streamPath = join28(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || sidecar.route !== o.routeLabel) continue;
@@ -11559,14 +12017,14 @@ async function reconcileRuns(o) {
 
 // src/live-runs.ts
 import { existsSync as existsSync25, readdirSync as readdirSync11 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 function liveRuns(stateDir, isAlive = runIsAlive) {
-  const dir = join28(stateDir, "streams");
+  const dir = join29(stateDir, "streams");
   if (!existsSync25(dir)) return [];
   const out = [];
   for (const name of readdirSync11(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join28(dir, name);
+    const streamPath = join29(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || !isAlive(sidecar)) continue;
@@ -11580,8 +12038,8 @@ function siblingRuns(runs, ownTicketRecordId) {
 async function settleRunEnd(o) {
   const { tracker, emit } = o;
   const all = o.runs ?? liveRuns(o.stateDir);
-  const slug = routeSlug(o.route.route);
-  const seatSiblings = siblingRuns(all.filter((r) => r.role === o.role && r.route === slug), o.ownTicketRecordId);
+  const slug2 = routeSlug(o.route.route);
+  const seatSiblings = siblingRuns(all.filter((r) => r.role === o.role && r.route === slug2), o.ownTicketRecordId);
   const shipSiblings = siblingRuns(all, o.ownTicketRecordId);
   const newest = (rs) => rs[rs.length - 1];
   if (o.memberId) {
@@ -11603,234 +12061,30 @@ async function settleRunEnd(o) {
     emit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
   }
 }
-function describeRun(run2, route2, seatIds, worktreeOf = (d, n) => {
+function describeRun(run3, route2, seatIds, worktreeOf = (d, n) => {
   try {
     return worktreeForNumber(d, n)?.path ?? null;
   } catch {
     return null;
   }
 }) {
-  const ownRoute = run2.route === routeSlug(route2.route);
-  const repoDir = run2.repo ? reposOf(route2).find((t) => t.name === run2.repo)?.dir : void 0;
-  const num = run2.ticket?.replace(/^\D+/, "") ?? "";
+  const ownRoute = run3.route === routeSlug(route2.route);
+  const repoDir = run3.repo ? reposOf(route2).find((t) => t.name === run3.repo)?.dir : void 0;
+  const num = run3.ticket?.replace(/^\D+/, "") ?? "";
   return {
-    role: run2.role,
-    seat: ownRoute ? seatIds[run2.role] ?? null : null,
-    ticket: run2.ticket,
-    ticketRecordId: run2.ticketRecordId,
-    repo: run2.repo ?? null,
+    role: run3.role,
+    seat: ownRoute ? seatIds[run3.role] ?? null : null,
+    ticket: run3.ticket,
+    ticketRecordId: run3.ticketRecordId,
+    repo: run3.repo ?? null,
     worktree: repoDir && num ? worktreeOf(repoDir, num) : null,
-    stream: run2.streamPath,
-    pid: run2.pid,
-    startedAt: run2.spawnedAt,
-    deadline: run2.deadline ?? null
+    stream: run3.streamPath,
+    pid: run3.pid,
+    startedAt: run3.spawnedAt,
+    deadline: run3.deadline ?? null
   };
 }
 
-// src/passenger-containers.ts
-import { execFileSync as execFileSync6 } from "child_process";
-import { createHash as createHash5 } from "crypto";
-var realExec = (cmd, args, opts) => {
-  try {
-    return execFileSync6(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: opts?.timeoutMs });
-  } catch (e) {
-    const err3 = e;
-    const why = [err3.stderr, err3.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
-    throw new Error(`${cmd} ${args.join(" ")}: ${why || err3.message.trim()}`);
-  }
-};
-var DOCKER_INFO_TIMEOUT_MS = 1e4;
-function dockerAvailable(exec = realExec) {
-  try {
-    exec("docker", ["info"], { timeoutMs: DOCKER_INFO_TIMEOUT_MS });
-    return true;
-  } catch {
-    return false;
-  }
-}
-var PASSENGER_IMAGE_REPO = "tablation/crew-passenger-mcp";
-function passengerImageRef(cfg) {
-  return process.env.CREW_PASSENGER_IMAGE || cfg.ship.passengerImage || `${PASSENGER_IMAGE_REPO}:${crewVersion(cfg.crewHome)}`;
-}
-function imagePresent(image, exec = realExec) {
-  try {
-    exec("docker", ["image", "inspect", image]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function ensureImage(image, exec = realExec) {
-  if (!imagePresent(image, exec)) exec("docker", ["pull", image]);
-}
-function containerNameFor(workspaceId) {
-  return `crew-passenger-${workspaceId}`;
-}
-function portFor(workspaceId, base = 28765, span = 1e3) {
-  const digest = createHash5("sha256").update(workspaceId).digest();
-  return base + digest.readUInt32BE(0) % span;
-}
-function mountsDigest(mounts, image) {
-  const sorted2 = [...mounts].sort((a, b) => a.containerPath.localeCompare(b.containerPath));
-  return createHash5("sha256").update(JSON.stringify({ mounts: sorted2, image })).digest("hex").slice(0, 16);
-}
-function planContainers(cfg) {
-  const byWorkspace = /* @__PURE__ */ new Map();
-  const image = passengerImageRef(cfg);
-  for (const route2 of cfg.routes) {
-    if (!route2.enabled || !route2.hostPassengers || !route2.resolved?.workspaceId) continue;
-    const workspaceId = route2.resolved.workspaceId;
-    const mounts = byWorkspace.get(workspaceId) ?? /* @__PURE__ */ new Map();
-    for (const target of passengerCheckoutTargets(route2)) {
-      mounts.set(target.name, { hostPath: target.dir, containerPath: `/workspace/${target.name}` });
-    }
-    byWorkspace.set(workspaceId, mounts);
-  }
-  return [...byWorkspace.entries()].filter(([, mounts]) => mounts.size > 0).map(([workspaceId, mounts]) => {
-    const mountList = [...mounts.values()];
-    return {
-      workspaceId,
-      containerName: containerNameFor(workspaceId),
-      port: portFor(workspaceId),
-      image,
-      mounts: mountList,
-      mountsHash: mountsDigest(mountList, image)
-    };
-  });
-}
-function listPassengerContainers(exec = realExec) {
-  const out = exec("docker", ["ps", "-a", "--filter", "name=crew-passenger-", "--format", "{{.Names}}	{{.State}}"]);
-  return out.split("\n").map((l) => l.trim()).filter(Boolean).map((line) => {
-    const [name, state] = line.split("	");
-    return { name, running: state === "running" };
-  });
-}
-function currentMountsHash(name, exec) {
-  try {
-    const out = exec("docker", ["inspect", "--format", '{{ index .Config.Labels "crew.mounts.hash" }}', name]);
-    const hash = out.trim();
-    return hash || void 0;
-  } catch {
-    return void 0;
-  }
-}
-function stopContainer(name, exec = realExec) {
-  try {
-    exec("docker", ["rm", "-f", name]);
-  } catch {
-  }
-}
-function startContainer(plan, tablationApiBaseUrl, sync, exec = realExec) {
-  const args = [
-    "run",
-    "-d",
-    "--name",
-    plan.containerName,
-    "--restart",
-    "unless-stopped",
-    "-p",
-    `${plan.port}:8765`,
-    "-e",
-    `PASSENGER_MCP_WORKSPACE_ID=${plan.workspaceId}`,
-    "-e",
-    `TABLATION_API_BASE_URL=${tablationApiBaseUrl}`,
-    "--label",
-    `crew.mounts.hash=${plan.mountsHash}`
-  ];
-  if (sync) {
-    args.push(
-      "--add-host",
-      "host.docker.internal:host-gateway",
-      "-e",
-      `PASSENGER_SYNC_URL=http://${sync.host}:${sync.port}/sync`,
-      "-e",
-      `PASSENGER_SYNC_SECRET=${sync.secret}`,
-      "-e",
-      `PASSENGER_MCP_SECRET=${sync.secret}`
-    );
-  }
-  for (const m of plan.mounts) args.push("-v", `${m.hostPath}:${m.containerPath}:ro`);
-  args.push(plan.image);
-  exec("docker", args);
-}
-function syncPassengerContainers(cfg, tablationApiBaseUrl, exec = realExec, syncEndpoints = /* @__PURE__ */ new Map()) {
-  const plans = planContainers(cfg);
-  const plannedByName = new Map(plans.map((p) => [p.containerName, p]));
-  const existing = listPassengerContainers(exec);
-  const existingByName = new Map(existing.map((c) => [c.name, c]));
-  const started = [];
-  const recreated = [];
-  const stopped = [];
-  const ensured = /* @__PURE__ */ new Set();
-  const start = (plan, sync) => {
-    if (!ensured.has(plan.image)) {
-      ensureImage(plan.image, exec);
-      ensured.add(plan.image);
-    }
-    startContainer(plan, tablationApiBaseUrl, sync, exec);
-  };
-  for (const plan of plans) {
-    const sync = syncEndpoints.get(plan.workspaceId);
-    const current = existingByName.get(plan.containerName);
-    if (!current) {
-      start(plan, sync);
-      started.push(plan.containerName);
-    } else if (!current.running) {
-      stopContainer(plan.containerName, exec);
-      start(plan, sync);
-      started.push(plan.containerName);
-    } else if (currentMountsHash(plan.containerName, exec) !== plan.mountsHash) {
-      stopContainer(plan.containerName, exec);
-      start(plan, sync);
-      recreated.push(plan.containerName);
-    }
-  }
-  for (const { name } of existing) {
-    if (!plannedByName.has(name)) {
-      stopContainer(name, exec);
-      stopped.push(name);
-    }
-  }
-  return { started, recreated, stopped };
-}
-function passengerCheckoutSyncSpecs(cfg, workspaceId) {
-  const specs = [];
-  for (const route2 of cfg.routes) {
-    if (!route2.enabled || !route2.hostPassengers || !route2.resolved?.workspaceId) continue;
-    if (workspaceId && route2.resolved.workspaceId !== workspaceId) continue;
-    const routeWorkspaceId = route2.resolved.workspaceId;
-    const ordinaryByName = new Map(reposOf(route2).map((t) => [t.name, t]));
-    for (const target of passengerCheckoutTargets(route2)) {
-      const ordinary = ordinaryByName.get(target.name);
-      const override = route2.repoOverrides[target.name];
-      const effective = resolveRepoConfig(
-        ordinary ? loadRepoConfig(ordinary.dir) : null,
-        { branch: { ...route2.branch, ...override?.branch } },
-        ordinary?.dir ?? target.dir
-      );
-      specs.push({
-        name: target.name,
-        workspaceId: routeWorkspaceId,
-        dir: target.dir,
-        remote: target.remote,
-        gitRemoteName: effective.branch.remote,
-        base: effective.branch.base,
-        originUrl: ordinary ? originUrlOf(ordinary.dir, effective.branch.remote) : null,
-        cloneScheme: cfg.ship.cloneScheme,
-        ...target.forgeHost ? { forgeHost: target.forgeHost } : {}
-      });
-    }
-  }
-  return specs;
-}
-function syncAllPassengerCheckouts(cfg) {
-  return passengerCheckoutSyncSpecs(cfg).map((spec) => ({
-    name: spec.name,
-    workspaceId: spec.workspaceId,
-    outcome: syncPassengerCheckout(spec.dir, spec.remote, spec.gitRemoteName, spec.base, { originUrl: spec.originUrl, scheme: spec.cloneScheme, host: spec.forgeHost })
-  }));
-}
-
 // src/deprovision-host.ts
 var DOCKER_LABEL_OWNER = "crew.owner=crew";
 var DOCKER_LABEL_CACHE = "crew.kind=cache";
@@ -11862,22 +12116,22 @@ function realDeprovisionDeps(cfg, emit, crewHome, getStore) {
   };
   return {
     liveRuns: () => liveRuns(stateDir).map((r) => ({ role: r.role, route: r.route, pid: r.pid, ticketRecordId: r.ticketRecordId ?? void 0, streamPath: r.streamPath })),
-    killRun: (run2) => killRunGroup(run2.pid),
-    recordKill(run2) {
-      emit.emit(`run_killed: ${run2.role} run on ${run2.route} stopped by crew deprovision`, {
+    killRun: (run3) => killRunGroup(run3.pid),
+    recordKill(run3) {
+      emit.emit(`run_killed: ${run3.role} run on ${run3.route} stopped by crew deprovision`, {
         step: "agent",
-        role: run2.role,
-        data: { event: "run_killed", reason: "deprovision", pid: run2.pid }
+        role: run3.role,
+        data: { event: "run_killed", reason: "deprovision", pid: run3.pid }
       });
     },
-    async handBack(run2) {
-      const route2 = routeFor(run2.route);
-      if (!run2.ticketRecordId || !route2) return;
-      const memberId = route2.resolved?.seats[run2.role];
+    async handBack(run3) {
+      const route2 = routeFor(run3.route);
+      if (!run3.ticketRecordId || !route2) return;
+      const memberId = route2.resolved?.seats[run3.role];
       if (!memberId) return;
-      const identity = await resolveSeatKey(route2, run2.role, getStore);
+      const identity = await resolveSeatKey(route2, run3.role, getStore);
       const tracker = new Tracker(route2, cfg.ship, { apiKey: identity.apiKey });
-      const t = await tracker.ticket(run2.ticketRecordId);
+      const t = await tracker.ticket(run3.ticketRecordId);
       const target = repoTargetFor(route2, t.repo_id);
       const num = String(t[tracker.contract.columns.key] ?? "").replace(/^\D+/, "");
       const wt = target && num ? worktreeForNumber(target.dir, num) : null;
@@ -11886,7 +12140,7 @@ function realDeprovisionDeps(cfg, emit, crewHome, getStore) {
         if (wt) dirty = status(wt.path).length > 0;
       } catch {
       }
-      await tracker.postEvent(run2.ticketRecordId, interruptedComment({
+      await tracker.postEvent(run3.ticketRecordId, interruptedComment({
         branch: wt?.branch ?? null,
         dirty,
         reason: "the host was released and wiped"
@@ -11941,9 +12195,9 @@ function realDeprovisionDeps(cfg, emit, crewHome, getStore) {
 }
 
 // src/pool-member.ts
-import { mkdirSync as mkdirSync16, readFileSync as readFileSync24, renameSync as renameSync3, writeFileSync as writeFileSync18 } from "fs";
+import { mkdirSync as mkdirSync17, readFileSync as readFileSync25, renameSync as renameSync4, writeFileSync as writeFileSync19 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname11, join as join29 } from "path";
+import { dirname as dirname11, join as join30 } from "path";
 var POOL_EXIT = { ok: 0, failed: 1, credential: 2 };
 function backoffMs(attempt) {
   return Math.min(6e4, 5e3 * 2 ** Math.max(0, attempt));
@@ -12132,24 +12386,24 @@ async function runPoolMember(deps) {
   }
 }
 function defaultMemberDir(env = process.env) {
-  return env.CREW_POOL_DIR ?? join29(env.XDG_STATE_HOME ?? join29(homedir8(), ".local", "state"), "crew-pool-member");
+  return env.CREW_POOL_DIR ?? join30(env.XDG_STATE_HOME ?? join30(homedir8(), ".local", "state"), "crew-pool-member");
 }
 function fileMemberStore(dir) {
-  const file = join29(dir, "member.json");
+  const file = join30(dir, "member.json");
   return {
     read() {
       try {
-        return JSON.parse(readFileSync24(file, "utf8"));
+        return JSON.parse(readFileSync25(file, "utf8"));
       } catch {
         return {};
       }
     },
     write(f) {
-      mkdirSync16(dirname11(file), { recursive: true, mode: 448 });
+      mkdirSync17(dirname11(file), { recursive: true, mode: 448 });
       const tmp = `${file}.tmp`;
-      writeFileSync18(tmp, `${JSON.stringify(f)}
+      writeFileSync19(tmp, `${JSON.stringify(f)}
 `, { mode: 384 });
-      renameSync3(tmp, file);
+      renameSync4(tmp, file);
     }
   };
 }
@@ -12204,13 +12458,13 @@ import { hostname as hostname3 } from "os";
 
 // src/machine-id.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { createHash as createHash6 } from "crypto";
-import { existsSync as existsSync27, mkdirSync as mkdirSync17, readFileSync as readFileSync25, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname12, join as join30 } from "path";
+import { createHash as createHash7 } from "crypto";
+import { existsSync as existsSync27, mkdirSync as mkdirSync18, readFileSync as readFileSync26, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname12, join as join31 } from "path";
 function machineIdPathFor(stateDir) {
-  return join30(stateDir, "machine-id");
+  return join31(stateDir, "machine-id");
 }
-var sha256 = (s) => createHash6("sha256").update(s).digest("hex");
+var sha256 = (s) => createHash7("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
   try {
     if (platform2 === "darwin") {
@@ -12222,7 +12476,7 @@ function readRawMachineId(platform2 = process.platform) {
     }
     for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
       if (existsSync27(p)) {
-        const id = readFileSync25(p, "utf8").trim();
+        const id = readFileSync26(p, "utf8").trim();
         if (id) return id;
       }
     }
@@ -12234,14 +12488,14 @@ function ensureMachineId(stateDir, opts = {}) {
   if (opts.override?.trim()) return sha256(opts.override.trim());
   const path = machineIdPathFor(stateDir);
   if (existsSync27(path)) {
-    const cached = readFileSync25(path, "utf8").trim();
+    const cached = readFileSync26(path, "utf8").trim();
     if (/^[0-9a-f]{64}$/.test(cached)) return cached;
   }
   const raw = (opts.read ?? readRawMachineId)();
   if (!raw) return void 0;
   const hashed = sha256(raw);
-  mkdirSync17(dirname12(path), { recursive: true });
-  writeFileSync19(path, `${hashed}
+  mkdirSync18(dirname12(path), { recursive: true });
+  writeFileSync20(path, `${hashed}
 `, { mode: 384 });
   return hashed;
 }
@@ -12254,7 +12508,7 @@ function matchShipRows(ships, shipName2, machineId) {
 
 // src/provision.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import { existsSync as existsSync28, readFileSync as readFileSync26, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync27, writeFileSync as writeFileSync21 } from "fs";
 import { hostname as hostname2 } from "os";
 import { parseDocument as parseDocument3 } from "yaml";
 
@@ -12263,7 +12517,7 @@ import { parseDocument as parseDocument2 } from "yaml";
 
 // src/repos-cmd.ts
 import { homedir as homedir9 } from "os";
-import { basename as basename9, join as join31, resolve as resolve3 } from "path";
+import { basename as basename9, join as join32, resolve as resolve3 } from "path";
 import { isMap, isSeq, parseDocument, stringify } from "yaml";
 var ReposError = class extends Error {
 };
@@ -12541,7 +12795,7 @@ function planRepoClone(i) {
   }
   const ship = doc.get("ship", true);
   const basePath = String(m.get("reposBasePath") ?? (isMap(ship) ? ship.get("reposBasePath") : void 0) ?? "~/Crew");
-  const target = i.dir ? expandDir(i.dir, i.base) : join31(expandDir(basePath, i.base), i.route.split("/")[0], name);
+  const target = i.dir ? expandDir(i.dir, i.base) : join32(expandDir(basePath, i.base), i.route.split("/")[0], name);
   const add = planRepoAdd({ text: i.text, base: i.base, route: i.route, path: target, origin: remote, resolved: i.resolved, name, isCheckout: i.isCheckout });
   const forgeHost = i.resolved?.repoForgeHosts?.[id];
   return { ...add, remote, target, ...forgeHost ? { forgeHost } : {} };
@@ -12814,13 +13068,13 @@ function realProvisionDeps(crewHome) {
     enableRoute(route2) {
       const file = configFile();
       if (!file) return false;
-      const text2 = readFileSync26(file, "utf8");
+      const text2 = readFileSync27(file, "utf8");
       const doc = parseDocument3(text2);
       const routes = doc.get("routes");
       const entry = routes?.items?.find((r) => r.get("route") === route2);
       if (!entry) throw new Error(`route ${route2} is not in ${file}`);
       if (entry.get("enabled") === true) return false;
-      writeFileSync20(file, planEnable(text2, route2));
+      writeFileSync21(file, planEnable(text2, route2));
       return true;
     },
     installState() {
@@ -12840,7 +13094,7 @@ function realProvisionDeps(crewHome) {
           continue;
         }
         for (const p of plan.unitPaths) {
-          if (!existsSync28(p) || readFileSync26(p, "utf8") !== plan.unitContent[p]) unitsStale = true;
+          if (!existsSync28(p) || readFileSync27(p, "utf8") !== plan.unitContent[p]) unitsStale = true;
         }
       }
       const label = labelFor(crewHome, "run");
@@ -12864,10 +13118,10 @@ function realProvisionDeps(crewHome) {
     setShipSetting(key, value2) {
       const file = configFile();
       if (!file) return false;
-      const doc = parseDocument3(readFileSync26(file, "utf8"));
+      const doc = parseDocument3(readFileSync27(file, "utf8"));
       if (doc.getIn(["ship", key]) === value2) return false;
       doc.setIn(["ship", key], value2);
-      writeFileSync20(file, doc.toString());
+      writeFileSync21(file, doc.toString());
       return true;
     },
     storedToken(host) {
@@ -12883,12 +13137,12 @@ host=${host}
 }
 
 // src/tunnel.ts
-import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync29, mkdirSync as mkdirSync18, readFileSync as readFileSync27, writeFileSync as writeFileSync21, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
+import { spawn as spawn6 } from "child_process";
+import { existsSync as existsSync29, mkdirSync as mkdirSync19, readFileSync as readFileSync28, writeFileSync as writeFileSync22, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
 import { randomInt } from "crypto";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
-var defaultSpawn = (cmd, args) => spawn5(cmd, args, DEFAULT_SPAWN_OPTIONS);
+var defaultSpawn = (cmd, args) => spawn6(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
 var SLUG_LENGTH = 12;
 function generateTunnelSlug() {
@@ -12900,12 +13154,12 @@ function bindAddrFor(o, path) {
   const base = `workspace-${o.workspaceId}-slug-${o.slug}${path ? `-path-${path}` : ""}-key-${o.apiKey}`;
   return o.mcpSecret && !path ? `${base}-secret-${o.mcpSecret}` : base;
 }
-function relayBaseUrlFor(slug, relayHost, relayHttpPort, relayPublicDomain) {
+function relayBaseUrlFor(slug2, relayHost, relayHttpPort, relayPublicDomain) {
   const domain = relayPublicDomain ?? relayHost.replace(/^.*@/, "");
-  return `https://${slug}.${domain}${relayHttpPort === 443 ? "" : `:${relayHttpPort}`}`;
+  return `https://${slug2}.${domain}${relayHttpPort === 443 ? "" : `:${relayHttpPort}`}`;
 }
-function publicUrlFor(slug, relayHost, relayHttpPort, relayPublicDomain) {
-  return `${relayBaseUrlFor(slug, relayHost, relayHttpPort, relayPublicDomain)}/mcp`;
+function publicUrlFor(slug2, relayHost, relayHttpPort, relayPublicDomain) {
+  return `${relayBaseUrlFor(slug2, relayHost, relayHttpPort, relayPublicDomain)}/mcp`;
 }
 function sshArgsFor(o) {
   const forwards = [];
@@ -12958,21 +13212,21 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join32(stateDir, "passengers", `${workspaceId}.json`);
+  return join33(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
   if (!existsSync29(path)) return void 0;
   try {
-    return JSON.parse(readFileSync27(path, "utf8"));
+    return JSON.parse(readFileSync28(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync18(join32(stateDir, "passengers"), { recursive: true });
-  writeFileSync21(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync19(join33(stateDir, "passengers"), { recursive: true });
+  writeFileSync22(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function updatePersistedTunnel(stateDir, workspaceId, patch2) {
@@ -13006,8 +13260,8 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
     const controlUnchanged = existing?.controlSocket === deps.controlSocket;
     const currentSecret = mcpSecrets.get(plan.workspaceId);
     const secretUnchanged = (existing?.mcpSecret ?? void 0) === (currentSecret ?? void 0);
-    const slug = existing?.slug ?? generateTunnelSlug();
-    const slugUnchanged = existing?.liveSlug === slug;
+    const slug2 = existing?.slug ?? generateTunnelSlug();
+    const slugUnchanged = existing?.liveSlug === slug2;
     if (existing && alive(existing.pid) && existing.mountsHash === mountsHash && secretUnchanged && slugUnchanged && controlUnchanged) {
       if (existing.status === "connecting") {
         const settled = { ...existing, status: "connected" };
@@ -13032,7 +13286,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
       relayHost,
       relayPort,
       workspaceId: plan.workspaceId,
-      slug,
+      slug: slug2,
       apiKey,
       localPort: plan.port,
       controlSocket: deps.controlSocket,
@@ -13052,8 +13306,8 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       status: settledStatus,
       mcpSecret: currentSecret,
-      slug,
-      liveSlug: slug,
+      slug: slug2,
+      liveSlug: slug2,
       endpointId: existing?.endpointId,
       registeredKey: existing?.registeredKey
     };
@@ -13074,7 +13328,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join32(stateDir, "passengers");
+  const dir = join33(stateDir, "passengers");
   if (!existsSync29(dir)) return [];
   return readdirSync13(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
@@ -13157,8 +13411,8 @@ function realPoolMemberDeps(o) {
       if (!cfg?.ship.relayHost) return null;
       for (const r of cfg.routes) {
         const ws = r.resolved?.workspaceId;
-        const slug = ws ? readPersistedTunnel(cfg.ship.stateDir, ws)?.slug : void 0;
-        if (slug) return relayBaseUrlFor(slug, cfg.ship.relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain);
+        const slug2 = ws ? readPersistedTunnel(cfg.ship.stateDir, ws)?.slug : void 0;
+        if (slug2) return relayBaseUrlFor(slug2, cfg.ship.relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain);
       }
       return null;
     },
@@ -13941,8 +14195,8 @@ ${waiting.map((t) => `| ${displayKey2(t)} | ${t.status} | ${blockers(t, i)} |`).
 }
 
 // src/poll.ts
-import { writeFileSync as writeFileSync22 } from "fs";
-import { join as join33 } from "path";
+import { writeFileSync as writeFileSync23 } from "fs";
+import { join as join34 } from "path";
 
 // src/stalled.ts
 var STALLED_AFTER_CYCLES = 30;
@@ -14249,7 +14503,7 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route2, role, runId) => join33(stateDir, `digest-${route2}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPath = (stateDir, route2, role, runId) => join34(stateDir, `digest-${route2}-${role}${runId ? `-${runId}` : ""}.md`);
 function otherRunsRemoved(tickets, own) {
   if (!own) return tickets;
   return tickets.filter((t) => t.id === own.ticket.id || !own.inFlight(t.id));
@@ -14327,7 +14581,7 @@ function writeDigest(o, d, role, stateDir, runId, own) {
 
 ${body}` : body;
     const path = digestPath(stateDir, routeSlug(o.route.route), role, runId);
-    writeFileSync22(path, text2);
+    writeFileSync23(path, text2);
     o.emit.emit(`queue digest written for ${role} (${Buffer.byteLength(text2)} bytes)`, {
       data: { role, bytes: Buffer.byteLength(text2) }
     });
@@ -14435,7 +14689,7 @@ async function resolveOne(tracker, t, seat, approvedStatus, buildingStatus, affi
 }
 
 // src/repo-refresh.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync19, readFileSync as readFileSync28, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync20, readFileSync as readFileSync29, writeFileSync as writeFileSync24 } from "fs";
 import { dirname as dirname14 } from "path";
 var REFRESH_COOLDOWN_MS = 2 * 6e4;
 var UNSERVABLE_PASSES_BEFORE_ATTENTION = 3;
@@ -14466,10 +14720,10 @@ function applyRepoRows(resolved, rows) {
 function persistRepoRows(stateDir, routeName, rows) {
   const path = resolvedPathFor(stateDir, routeName);
   if (!existsSync31(path)) return;
-  const raw = JSON.parse(readFileSync28(path, "utf8"));
+  const raw = JSON.parse(readFileSync29(path, "utf8"));
   applyRepoRows(raw, rows);
-  mkdirSync19(dirname14(path), { recursive: true });
-  writeFileSync23(path, `${JSON.stringify(raw, null, 2)}
+  mkdirSync20(dirname14(path), { recursive: true });
+  writeFileSync24(path, `${JSON.stringify(raw, null, 2)}
 `);
 }
 async function refreshUnknownRepos(o) {
@@ -14919,8 +15173,8 @@ Ship ${shipName2} found: ${problem}. The release refuses to squash a ref nobody
 var localRefSkipReported = (ticket, problem, events) => events.some((e) => e.record_id === ticket.id && e.event_type === "local_ref_skip" && (e.message ?? "").includes(problem));
 
 // src/connect-wizard.ts
-import { delimiter, dirname as dirname15, join as join34 } from "path";
-import { accessSync as accessSync3, constants as constants3, existsSync as existsSync32, mkdirSync as mkdirSync20, writeFileSync as writeFileSync24 } from "fs";
+import { delimiter, dirname as dirname15, join as join35 } from "path";
+import { accessSync as accessSync3, constants as constants3, existsSync as existsSync32, mkdirSync as mkdirSync21, writeFileSync as writeFileSync25 } from "fs";
 import { stringify as stringify2 } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
 function shouldRunWizard(opts) {
@@ -14942,7 +15196,7 @@ function defaultIsExecutable(p) {
 function findOnPath2(name, pathEnv, isExecutable = defaultIsExecutable) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join34(dir, name);
+    const candidate = join35(dir, name);
     if (isExecutable(candidate)) return candidate;
   }
   return void 0;
@@ -15003,9 +15257,9 @@ routes:
 ${routeBlock}`;
 }
 function writeNewConfig(path, text2) {
-  mkdirSync20(dirname15(path), { recursive: true });
+  mkdirSync21(dirname15(path), { recursive: true });
   try {
-    writeFileSync24(path, text2, { mode: 384, flag: "wx" });
+    writeFileSync25(path, text2, { mode: 384, flag: "wx" });
     return true;
   } catch (e) {
     if (e.code === "EEXIST") return false;
@@ -15039,7 +15293,7 @@ Wrote ${o.configPath}.
 // src/connect-json.ts
 import { accessSync as accessSync4, constants as constants4 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname16, join as join35 } from "path";
+import { dirname as dirname16, join as join36 } from "path";
 import { delimiter as delimiter2 } from "path";
 var CHOICE_EXIT_CODE = 3;
 function createEmitter(json2, write) {
@@ -15078,12 +15332,12 @@ function agentBinSearchDirs(home, pathEnv, extraPath) {
   const dirs = [
     ...pathEnv.split(delimiter2),
     ...(extraPath ?? "").split(delimiter2),
-    join35(home, ".local/bin"),
-    join35(home, ".claude/local"),
+    join36(home, ".local/bin"),
+    join36(home, ".claude/local"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
-    join35(home, ".npm-global/bin"),
-    join35(home, ".volta/bin")
+    join36(home, ".npm-global/bin"),
+    join36(home, ".volta/bin")
   ];
   return [...new Set(dirs.filter(Boolean))];
 }
@@ -15119,9 +15373,9 @@ function flagWizardAnswers(f, env) {
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync29, writeFileSync as writeFileSync25, existsSync as existsSync33, copyFileSync, mkdirSync as mkdirSync21, mkdtempSync as mkdtempSync3, rmSync as rmSync16 } from "fs";
-import { dirname as dirname17, join as join36 } from "path";
-import { tmpdir as tmpdir4 } from "os";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync26, existsSync as existsSync33, copyFileSync, mkdirSync as mkdirSync22, mkdtempSync as mkdtempSync3, rmSync as rmSync17 } from "fs";
+import { dirname as dirname17, join as join37 } from "path";
+import { tmpdir as tmpdir5 } from "os";
 
 // src/release.ts
 function describeUnplaceable(unplaceable, verifiedStatus) {
@@ -15861,13 +16115,13 @@ async function bump(o, size) {
     }
     return printed;
   }
-  const files = o.repo.release.versionFiles.map((f) => join36(o.cwd, f));
+  const files = o.repo.release.versionFiles.map((f) => join37(o.cwd, f));
   const first = files[0];
   if (!existsSync33(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
     return null;
   }
-  const current = JSON.parse(readFileSync29(first, "utf8")).version;
+  const current = JSON.parse(readFileSync30(first, "utf8")).version;
   if (!current) {
     o.emit.error(`no version field in ${o.repo.release.versionFiles[0]}`);
     return null;
@@ -15880,27 +16134,27 @@ async function bump(o, size) {
     return version;
   }
   for (const f of files) {
-    const src = readFileSync29(f, "utf8");
+    const src = readFileSync30(f, "utf8");
     const out = src.replace(/("version"\s*:\s*")[^"]*(")/, `$1${version}$2`);
     if (out === src) {
       o.emit.error(`no version field in ${f}`);
       return null;
     }
-    writeFileSync25(f, out);
+    writeFileSync26(f, out);
   }
   return version;
 }
 function writeChangelog(o, version, entries) {
   const file = o.repo.release.changelog;
   if (!file || entries.length === 0) return;
-  const path = join36(o.cwd, file);
+  const path = join37(o.cwd, file);
   const section = renderChangelogSection(version, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), entries);
   if (o.dryRun) {
     o.emit.emit(`would prepend ${entries.length} entr(ies) to ${file}`);
     return;
   }
-  const existing = existsSync33(path) ? readFileSync29(path, "utf8") : "# Changelog\n";
-  writeFileSync25(path, insertChangelogSection(existing, section));
+  const existing = existsSync33(path) ? readFileSync30(path, "utf8") : "# Changelog\n";
+  writeFileSync26(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
   if (!o.repo.hooks.released) return void 0;
@@ -15978,23 +16232,23 @@ async function confirmLastRelease(o, decision) {
   if (!confirmed) o.emit.warn(`${decision.lastTag} is still not confirmed live \u2014 tickets stay verified`);
   return { confirmed, version };
 }
-function closeReleaseCheckout(cwd, root, dir, branch, run2 = gitOk) {
+function closeReleaseCheckout(cwd, root, dir, branch, run3 = gitOk) {
   try {
-    run2(cwd, ["worktree", "remove", "--force", dir]);
+    run3(cwd, ["worktree", "remove", "--force", dir]);
   } finally {
     try {
-      rmSync16(root, { recursive: true, force: true });
+      rmSync17(root, { recursive: true, force: true });
     } finally {
-      run2(cwd, ["worktree", "prune"]);
-      run2(cwd, ["branch", "-D", branch]);
+      run3(cwd, ["worktree", "prune"]);
+      run3(cwd, ["branch", "-D", branch]);
     }
   }
 }
 function openReleaseCheckout(o) {
   const { remote, base } = o.repo.branch;
   const branch = `crew/release-${Date.now()}`;
-  const root = mkdtempSync3(join36(tmpdir4(), "crew-release-"));
-  const dir = join36(root, "checkout");
+  const root = mkdtempSync3(join37(tmpdir5(), "crew-release-"));
+  const dir = join37(root, "checkout");
   o.emit.emit(`release checkout: ${dir}`, { step: "release" });
   const close = () => closeReleaseCheckout(o.cwd, root, dir, branch);
   try {
@@ -16004,10 +16258,10 @@ function openReleaseCheckout(o) {
     throw e;
   }
   for (const f of o.repo.worktrees.copy) {
-    const src = join36(o.cwd, f);
+    const src = join37(o.cwd, f);
     if (!existsSync33(src)) continue;
-    mkdirSync21(dirname17(join36(dir, f)), { recursive: true });
-    copyFileSync(src, join36(dir, f));
+    mkdirSync22(dirname17(join37(dir, f)), { recursive: true });
+    copyFileSync(src, join37(dir, f));
   }
   return { dir, branch, close };
 }
@@ -16152,7 +16406,7 @@ async function runReleaseCycle(o, movedPast2, localRefSkips) {
   let checkout;
   const stranded = recoverStrandedReleaseCheckouts(o.cwd);
   if (stranded.length > 0) o.emit.warn(scoped(`dropped release checkout(s) stranded by a crash: ${stranded.join(", ")}`));
-  const swept = sweepStaleReleaseRoots(tmpdir4());
+  const swept = sweepStaleReleaseRoots(tmpdir5());
   if (swept.length > 0) o.emit.emit(scoped(`removed ${swept.length} stale crew-release-* temp dir(s)`), { step: "release" });
   try {
     checkout = openReleaseCheckout(o);
@@ -17325,7 +17579,7 @@ function nextRoles(decision, ran) {
 }
 
 // src/ship-name.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync30, renameSync as renameSync4, writeFileSync as writeFileSync26 } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync23, readFileSync as readFileSync31, renameSync as renameSync5, writeFileSync as writeFileSync27 } from "fs";
 import { dirname as dirname18 } from "path";
 import { parseDocument as parseDocument5 } from "yaml";
 var ShipNameError = class extends Error {
@@ -17389,7 +17643,7 @@ async function syncRouteName(i) {
 function readSyncedName(resolvedFile) {
   if (!existsSync35(resolvedFile)) return void 0;
   try {
-    const v = JSON.parse(readFileSync30(resolvedFile, "utf8")).shipName;
+    const v = JSON.parse(readFileSync31(resolvedFile, "utf8")).shipName;
     return typeof v === "string" ? v : void 0;
   } catch {
     return void 0;
@@ -17399,22 +17653,22 @@ function writeSyncedName(resolvedFile, name) {
   if (!existsSync35(resolvedFile)) return;
   let raw;
   try {
-    raw = JSON.parse(readFileSync30(resolvedFile, "utf8"));
+    raw = JSON.parse(readFileSync31(resolvedFile, "utf8"));
   } catch {
     return;
   }
   if (raw.shipName === name) return;
   raw.shipName = name;
-  mkdirSync22(dirname18(resolvedFile), { recursive: true });
+  mkdirSync23(dirname18(resolvedFile), { recursive: true });
   const tmp = `${resolvedFile}.tmp${process.pid}`;
-  writeFileSync26(tmp, `${JSON.stringify(raw, null, 2)}
+  writeFileSync27(tmp, `${JSON.stringify(raw, null, 2)}
 `);
-  renameSync4(tmp, resolvedFile);
+  renameSync5(tmp, resolvedFile);
 }
 async function reconcileShipName(i) {
   let local = i.ship.name;
   try {
-    local = shipNameOfYaml(readFileSync30(i.configFile, "utf8")) ?? local;
+    local = shipNameOfYaml(readFileSync31(i.configFile, "utf8")) ?? local;
   } catch {
   }
   const resolvedFile = resolvedPathFor(i.stateDir, i.route);
@@ -17438,8 +17692,8 @@ async function reconcileShipName(i) {
   }
   if (result.status !== "ok") return result;
   if (result.action === "adopt" || result.action === "row-wins") {
-    const text2 = readFileSync30(i.configFile, "utf8");
-    writeFileSync26(i.configFile, setShipNameInYaml(text2, result.name));
+    const text2 = readFileSync31(i.configFile, "utf8");
+    writeFileSync27(i.configFile, setShipNameInYaml(text2, result.name));
     i.ship.name = result.name;
     if (result.action === "row-wins") {
       i.emit?.warn(
@@ -18098,7 +18352,7 @@ function describeCapability(i) {
 }
 
 // src/agents-sync-run.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync23, readFileSync as readFileSync31, writeFileSync as writeFileSync27 } from "fs";
+import { existsSync as existsSync36, mkdirSync as mkdirSync24, readFileSync as readFileSync32, writeFileSync as writeFileSync28 } from "fs";
 import { dirname as dirname19 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
@@ -18132,12 +18386,12 @@ async function runAgentsSync(target, o) {
   for (const s of skillResult?.outcomes ?? []) o.say(describeSkillSyncOutcome(s));
   if (!dryRun) {
     const resolvedPath = resolvedPathFor(o.stateDir, target.route);
-    const raw = existsSync36(resolvedPath) ? JSON.parse(readFileSync31(resolvedPath, "utf8")) : {};
+    const raw = existsSync36(resolvedPath) ? JSON.parse(readFileSync32(resolvedPath, "utf8")) : {};
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
-    mkdirSync23(dirname19(resolvedPath), { recursive: true });
-    writeFileSync27(resolvedPath, `${JSON.stringify(raw, null, 2)}
+    mkdirSync24(dirname19(resolvedPath), { recursive: true });
+    writeFileSync28(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
     if (target.resolved) {
       target.resolved.agentPersonas = personaResult.agentPersonas;
@@ -18152,7 +18406,7 @@ async function runAgentsSync(target, o) {
 }
 
 // src/logbook.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { TablationClient as TablationClient4 } from "@tablation/client";
 var LogbookError = class extends Error {
 };
@@ -18225,7 +18479,7 @@ async function showLogEntry(route2, entryId, opts = {}) {
     };
   }
   const prompt = appendAdditions(match.prompt ?? "", match.prompt_additions);
-  const actualSha = createHash7("sha256").update(prompt).digest("hex");
+  const actualSha = createHash8("sha256").update(prompt).digest("hex");
   const exact = !!entry.prompt_sha && actualSha === entry.prompt_sha;
   return {
     entry,
@@ -18241,27 +18495,27 @@ async function showLogEntry(route2, entryId, opts = {}) {
 
 // src/repos-check.ts
 import { spawnSync as spawnSync9 } from "child_process";
-import { readFileSync as readFileSync32 } from "fs";
+import { readFileSync as readFileSync33 } from "fs";
 import { basename as basename10 } from "path";
 var POSIX_SHELL = /^(?:ba|z|da|k|a|mk)?sh$|^fish$/;
 function checkHookSyntax(script, shell) {
   const spec = resolveShell(shell);
   const name = basename10(spec.bin).replace(/\.exe$/i, "").toLowerCase();
-  let run2;
+  let run3;
   if (POSIX_SHELL.test(name)) {
-    run2 = spawnSync9(spec.bin, ["-n"], { input: script, encoding: "utf8" });
+    run3 = spawnSync9(spec.bin, ["-n"], { input: script, encoding: "utf8" });
   } else if (/^(pwsh|powershell)$/.test(name)) {
     const parse3 = "$e=$null;[void][System.Management.Automation.Language.Parser]::ParseInput($env:CREW_CHECK_SCRIPT,[ref]$null,[ref]$e);if($e){$e|ForEach-Object{[Console]::Error.WriteLine($_.Message)};exit 1}";
-    run2 = spawnSync9(spec.bin, ["-NoProfile", "-NonInteractive", "-Command", parse3], {
+    run3 = spawnSync9(spec.bin, ["-NoProfile", "-NonInteractive", "-Command", parse3], {
       encoding: "utf8",
       env: { ...process.env, CREW_CHECK_SCRIPT: script }
     });
   } else {
     return { status: "unchecked", message: `no syntax check for ${spec.bin}` };
   }
-  if (run2.error) return { status: "unchecked", message: `cannot run ${spec.bin}: ${run2.error.message}` };
-  if (run2.status === 0) return { status: "ok" };
-  const message = `${run2.stderr ?? ""}${run2.stdout ?? ""}`.trim() || `${spec.bin} exited ${run2.status}`;
+  if (run3.error) return { status: "unchecked", message: `cannot run ${spec.bin}: ${run3.error.message}` };
+  if (run3.status === 0) return { status: "ok" };
+  const message = `${run3.stderr ?? ""}${run3.stdout ?? ""}`.trim() || `${spec.bin} exited ${run3.status}`;
   return { status: "error", message };
 }
 function renderSamples(cfg, dir) {
@@ -18282,7 +18536,7 @@ function checkRepoSpec(dir, opts = {}) {
   }
   let parsed;
   try {
-    parsed = parseRepoConfig(readFileSync32(file, "utf8"), file);
+    parsed = parseRepoConfig(readFileSync33(file, "utf8"), file);
   } catch (e) {
     if (!(e instanceof RepoConfigError)) throw e;
     return { ...empty, file, error: e.message, exitCode: 1 };
@@ -18557,7 +18811,7 @@ function existingRepoConfig(f) {
 }
 
 // src/repos-hooks-agent.ts
-import { spawn as spawn6, execFileSync as execFileSync8 } from "child_process";
+import { spawn as spawn7, execFileSync as execFileSync8 } from "child_process";
 import { realpathSync as realpathSync2 } from "fs";
 import { isAbsolute as isAbsolute2, relative } from "path";
 var AgentSuggestError = class extends Error {
@@ -18675,10 +18929,10 @@ async function runAgentSuggest(o) {
   const before = porcelain(o.dir);
   const timeout = AbortSignal.timeout(o.timeoutMs ?? DEFAULT_TIMEOUT_MS);
   const signal = o.signal ? AbortSignal.any([o.signal, timeout]) : timeout;
-  const run2 = await new Promise((resolve7) => {
+  const run3 = await new Promise((resolve7) => {
     let out = "";
     let err3 = "";
-    const child = spawn6(bin, args, { cwd: o.dir, env, detached: true, stdio: ["pipe", "pipe", "pipe"] });
+    const child = spawn7(bin, args, { cwd: o.dir, env, detached: true, stdio: ["pipe", "pipe", "pipe"] });
     let settled = false;
     const settle = (r) => {
       if (settled) return;
@@ -18710,18 +18964,18 @@ async function runAgentSuggest(o) {
     });
     child.stdin.end(buildAgentPrompt(o.sniff));
   });
-  if (run2.aborted || signal.aborted) {
+  if (run3.aborted || signal.aborted) {
     throw new AgentSuggestError(o.signal?.aborted ? "cancelled" : "timeout", o.signal?.aborted ? "cancelled" : "the toolchain did not answer in time");
   }
   const after = porcelain(o.dir);
   if (before !== void 0 && after !== before) {
     throw new AgentSuggestError("modified_checkout", "the checkout changed during --agent; inspect it with `git status` (the agent result was discarded)");
   }
-  const parsed = parseAgentStream(run2.out, o.dir);
-  if (run2.spawnError || run2.code !== 0 || parsed.isError) {
-    const reason = classifyFailure({ code: run2.code, ...run2.spawnError ? { spawnError: run2.spawnError } : {}, output: `${parsed.text}
-${run2.err}` });
-    throw new AgentSuggestError(reason, reason === "not_installed" ? `${bin} is not installed` : reason === "not_signed_in" ? `${o.spec.name} is not signed in` : (parsed.text || run2.err).trim().slice(0, 300) || `exited ${run2.code}`);
+  const parsed = parseAgentStream(run3.out, o.dir);
+  if (run3.spawnError || run3.code !== 0 || parsed.isError) {
+    const reason = classifyFailure({ code: run3.code, ...run3.spawnError ? { spawnError: run3.spawnError } : {}, output: `${parsed.text}
+${run3.err}` });
+    throw new AgentSuggestError(reason, reason === "not_installed" ? `${bin} is not installed` : reason === "not_signed_in" ? `${o.spec.name} is not signed in` : (parsed.text || run3.err).trim().slice(0, 300) || `exited ${run3.code}`);
   }
   const { hooks, notes } = parseAgentHooks(parsed.text);
   const differsFromSniff = HOOK_KEYS2.filter((k) => hooks[k] !== void 0 && hooks[k] !== o.sniff.hooks[k]);
@@ -18729,7 +18983,7 @@ ${run2.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename11, dirname as dirname20, join as join37 } from "path";
+import { basename as basename11, dirname as dirname20, join as join38 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -18752,8 +19006,8 @@ has something safe to work on: its test and build hooks always pass, it has no
 remote, and \`crew sample-ticket --remove\` deletes it.
 `;
 function sampleDir(existing, reposBase, workspace) {
-  if (existing.length > 0) return join37(dirname20(existing[0]), SAMPLE_REPO);
-  return join37(reposBase, workspace, SAMPLE_REPO);
+  if (existing.length > 0) return join38(dirname20(existing[0]), SAMPLE_REPO);
+  return join38(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
 function sampleDescription() {
@@ -18797,8 +19051,8 @@ function planSampleTicket(i) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync37, readFileSync as readFileSync33, readdirSync as readdirSync14 } from "fs";
-import { basename as basename12, dirname as dirname21, join as join38, resolve as resolve4 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync34, readdirSync as readdirSync14 } from "fs";
+import { basename as basename12, dirname as dirname21, join as join39, resolve as resolve4 } from "path";
 function planWorktreeSweep(target, tickets, contract) {
   const terminal = new Set(contract.statuses.resolved.filter((s) => s !== contract.statuses.verified));
   const verified = contract.statuses.verified;
@@ -18875,7 +19129,7 @@ function siblingWorktreeDirs(target) {
   for (const name of names) {
     if (!name.startsWith(stem)) continue;
     const m = DIR_NUMBER_SUFFIXED.exec(name);
-    const path = join38(parent, name);
+    const path = join39(parent, name);
     if (m && !registered.has(resolve4(path))) out.push({ path, number: m[1] });
   }
   return out;
@@ -18978,7 +19232,7 @@ function isHandBackMerge(path, base) {
   if (!msgPath) return false;
   let first;
   try {
-    first = readFileSync33(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
+    first = readFileSync34(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
   } catch {
     return false;
   }
@@ -19083,14 +19337,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync38, readdirSync as readdirSync15, rmSync as rmSync17, statSync as statSync10 } from "fs";
-import { join as join39 } from "path";
+import { existsSync as existsSync38, readdirSync as readdirSync15, rmSync as rmSync18, statSync as statSync10 } from "fs";
+import { join as join40 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join39(stateDir, "streams");
+  const dir = join40(stateDir, "streams");
   if (!existsSync38(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync15(dir).map((name) => join39(dir, name)).filter((path) => {
+  return readdirSync15(dir).map((name) => join40(dir, name)).filter((path) => {
     try {
       return statSync10(path).mtimeMs < cutoff;
     } catch {
@@ -19106,7 +19360,7 @@ function applyStreamSweep(paths, dryRun, log) {
       continue;
     }
     try {
-      rmSync17(path, { force: true });
+      rmSync18(path, { force: true });
       removed++;
       log.emit(`removed stream artifact ${path}`, { step: "worktree" });
     } catch (e) {
@@ -19118,7 +19372,7 @@ function applyStreamSweep(paths, dryRun, log) {
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
   if (!existsSync38(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync15(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join39(stateDir, name)).filter((path) => {
+  return readdirSync15(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join40(stateDir, name)).filter((path) => {
     try {
       return statSync10(path).mtimeMs < cutoff;
     } catch {
@@ -19128,12 +19382,12 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync39, existsSync as existsSync45, mkdirSync as mkdirSync29, writeFileSync as writeFileSync32, rmSync as rmSync22, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync5, statSync as statSync14, readdirSync as readdirSync20 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync40, existsSync as existsSync45, mkdirSync as mkdirSync30, writeFileSync as writeFileSync33, rmSync as rmSync23, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync6, statSync as statSync14, readdirSync as readdirSync20 } from "fs";
 import { createInterface } from "readline/promises";
 
 // src/periscope-cmd.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync24, readFileSync as readFileSync34, rmSync as rmSync18, writeFileSync as writeFileSync28 } from "fs";
-import { join as join40 } from "path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync25, readFileSync as readFileSync35, rmSync as rmSync19, writeFileSync as writeFileSync29 } from "fs";
+import { join as join41 } from "path";
 var PeriscopeError = class extends Error {
 };
 var LivePeriscopeError = class extends PeriscopeError {
@@ -19143,22 +19397,22 @@ var LivePeriscopeError = class extends PeriscopeError {
     this.data = { refused: "live_periscope_exists", ...live };
   }
 };
-var priorDir = (stateDir) => join40(stateDir, "periscope-priors");
-var priorPath = (stateDir, ticketRecordId) => join40(priorDir(stateDir), `${ticketRecordId}.json`);
+var priorDir = (stateDir) => join41(stateDir, "periscope-priors");
+var priorPath = (stateDir, ticketRecordId) => join41(priorDir(stateDir), `${ticketRecordId}.json`);
 function removePeriscopePrior(stateDir, ticketRecordId) {
-  rmSync18(priorPath(stateDir, ticketRecordId), { force: true });
+  rmSync19(priorPath(stateDir, ticketRecordId), { force: true });
 }
 function writePeriscopePrior(stateDir, ticketRecordId, prior) {
   try {
-    mkdirSync24(priorDir(stateDir), { recursive: true });
-    writeFileSync28(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
+    mkdirSync25(priorDir(stateDir), { recursive: true });
+    writeFileSync29(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
   } catch {
   }
 }
 function readPeriscopePrior(stateDir, ticketRecordId) {
   try {
     const p = priorPath(stateDir, ticketRecordId);
-    return existsSync39(p) ? JSON.parse(readFileSync34(p, "utf8")) : void 0;
+    return existsSync39(p) ? JSON.parse(readFileSync35(p, "utf8")) : void 0;
   } catch {
     return void 0;
   }
@@ -19557,7 +19811,7 @@ ${tail2(preview.output)}`);
 // src/periscope-idle.ts
 import { execFileSync as execFileSync9 } from "child_process";
 import { statSync as statSync11 } from "fs";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 var MAX_SCANNED_FILES = 2e4;
 function newestWorktreeMtime(root) {
   let listing;
@@ -19577,7 +19831,7 @@ function newestWorktreeMtime(root) {
     if (!rel) continue;
     if (++scanned > MAX_SCANNED_FILES) break;
     try {
-      const m = statSync11(join41(root, rel)).mtimeMs;
+      const m = statSync11(join42(root, rel)).mtimeMs;
       if (newest === null || m > newest) newest = m;
     } catch {
     }
@@ -19653,18 +19907,18 @@ import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync10 } from "child_process";
-import { existsSync as existsSync40, mkdirSync as mkdirSync25, readFileSync as readFileSync35, chmodSync as chmodSync3 } from "fs";
-import { dirname as dirname22, join as join42 } from "path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync26, readFileSync as readFileSync36, chmodSync as chmodSync3 } from "fs";
+import { dirname as dirname22, join as join43 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join42(stateDir, "ssh", "id_ed25519");
+  return join43(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
   if (!existsSync40(privateKeyPath)) {
-    mkdirSync25(dirname22(privateKeyPath), { recursive: true });
+    mkdirSync26(dirname22(privateKeyPath), { recursive: true });
     try {
       execFileSync10("ssh-keygen", [
         "-t",
@@ -19687,7 +19941,7 @@ function ensureShipSshKeypair(stateDir) {
   if (!existsSync40(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync35(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync36(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -19730,7 +19984,7 @@ function shipIdentityJson(s) {
 }
 
 // src/mcp-endpoint-registry.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 function endpointsUrl(api, workspaceId, id) {
   const base = `${api.baseUrl.replace(/\/+$/, "")}/api/workspaces/${workspaceId}/mcp-endpoints`;
   return id ? `${base}/${id}` : base;
@@ -19800,7 +20054,7 @@ async function probeEndpointAccess(api, workspaceId) {
 }
 var REGISTER_MCP_ENDPOINTS_HINT = "give this key's role the REGISTER_MCP_ENDPOINTS capability, e.g. via the group that holds the Crew project role";
 function registrationKey(url, mcpSecret, controlUrl) {
-  return createHash8("sha256").update(`${url}
+  return createHash9("sha256").update(`${url}
 ${mcpSecret ?? ""}
 ${controlUrl ?? ""}`).digest("hex").slice(0, 16);
 }
@@ -19849,10 +20103,10 @@ async function unregisterEndpoint(workspaceId, info, d) {
 
 // src/passenger-sync-daemon.ts
 import { createServer as createHttpServer } from "http";
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync41, mkdirSync as mkdirSync26, readFileSync as readFileSync36, writeFileSync as writeFileSync29, unlinkSync as unlinkSync4, readdirSync as readdirSync16 } from "fs";
-import { join as join43 } from "path";
+import { existsSync as existsSync41, mkdirSync as mkdirSync27, readFileSync as readFileSync37, writeFileSync as writeFileSync30, unlinkSync as unlinkSync4, readdirSync as readdirSync16 } from "fs";
+import { join as join44 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -19936,26 +20190,26 @@ function runSyncDaemonFromEnv(env = process.env) {
   return server;
 }
 var defaultSpawn2 = (cmd, args, env) => {
-  const child = spawn7(cmd, args, { detached: true, stdio: "ignore", env });
+  const child = spawn8(cmd, args, { detached: true, stdio: "ignore", env });
   child.unref();
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join43(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join44(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
   if (!existsSync41(path)) return void 0;
   try {
-    return JSON.parse(readFileSync36(path, "utf8"));
+    return JSON.parse(readFileSync37(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync26(join43(stateDir, "passengers"), { recursive: true });
-  writeFileSync29(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync27(join44(stateDir, "passengers"), { recursive: true });
+  writeFileSync30(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function removePersistedSyncDaemon(stateDir, workspaceId) {
@@ -19975,7 +20229,7 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join43(stateDir, "passengers");
+  const dir = join44(stateDir, "passengers");
   if (!existsSync41(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync16(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
@@ -20064,8 +20318,8 @@ function describeCause(err3) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync42, mkdirSync as mkdirSync27, readFileSync as readFileSync37, readdirSync as readdirSync17, rmSync as rmSync19, statSync as statSync12, writeFileSync as writeFileSync30 } from "fs";
-import { join as join44 } from "path";
+import { existsSync as existsSync42, mkdirSync as mkdirSync28, readFileSync as readFileSync38, readdirSync as readdirSync17, rmSync as rmSync20, statSync as statSync12, writeFileSync as writeFileSync31 } from "fs";
+import { join as join45 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
@@ -20153,7 +20407,7 @@ function latestMtime(path) {
   if (!stat2.isDirectory()) return 0;
   let latest = stat2.mtimeMs;
   for (const entry of readdirSync17(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join44(path, entry.name)));
+    latest = Math.max(latest, latestMtime(join45(path, entry.name)));
   }
   return latest;
 }
@@ -20165,7 +20419,7 @@ function makeStaleChecker(paths, opts = {}) {
   return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync42(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join44(stateDir, "reload-requested");
+  return join45(stateDir, "reload-requested");
 }
 function readReloadRequestedAt(stateDir) {
   try {
@@ -20175,17 +20429,17 @@ function readReloadRequestedAt(stateDir) {
   }
 }
 function daemonStampFor(stateDir) {
-  return join44(stateDir, "daemon.started");
+  return join45(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
-  mkdirSync27(stateDir, { recursive: true });
-  rmSync19(reloadSentinelFor(stateDir), { force: true });
-  writeFileSync30(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
+  mkdirSync28(stateDir, { recursive: true });
+  rmSync20(reloadSentinelFor(stateDir), { force: true });
+  writeFileSync31(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
 `);
 }
 function readDaemonStarted(stateDir) {
   try {
-    const v = JSON.parse(readFileSync37(daemonStampFor(stateDir), "utf8")).startedAt;
+    const v = JSON.parse(readFileSync38(daemonStampFor(stateDir), "utf8")).startedAt;
     return typeof v === "number" ? v : null;
   } catch {
     return null;
@@ -20250,7 +20504,7 @@ async function runOnePassUnguarded(o) {
   await hydrateApiKeys([o.route], o.getSessionStore);
   const emit = o.newEmitter();
   const decide = o.decide ?? decideCycle;
-  const spawn10 = o.spawnRoleAgent ?? runRoleAgent;
+  const spawn11 = o.spawnRoleAgent ?? runRoleAgent;
   const breaker = o.spawnBreaker ?? new SpawnBreaker();
   const ctx = { route: o.route, ship: o.ship, state: o.state, emit, getSessionStore: o.getSessionStore };
   if (o.configFile) await reconcileRouteShipName({ route: o.route, ship: o.ship, configFile: o.configFile, emit });
@@ -20354,7 +20608,7 @@ async function runOnePassUnguarded(o) {
         settle = resolve7;
       });
       const ready = (tookTicket2) => settle(tookTicket2);
-      const run2 = spawn10(role, decision, ctx, { ready }).then(() => {
+      const run3 = spawn11(role, decision, ctx, { ready }).then(() => {
         breaker.recordSuccess(role);
         clearShipAttention(o.state, `role_parked:${role}`);
         clearShipAttention(o.state, workspaceAuthKey(role));
@@ -20403,8 +20657,8 @@ async function runOnePassUnguarded(o) {
       });
       if (o.inFlight) {
         const set = o.inFlight;
-        set.add(run2);
-        void run2.finally(() => set.delete(run2));
+        set.add(run3);
+        void run3.finally(() => set.delete(run3));
       }
       const reported = TICKET_ROLES.has(role) ? await settled : true;
       const tookTicket = reported !== false;
@@ -20740,7 +20994,7 @@ async function buildEnvironment(route2, ship, ticket) {
 }
 
 // src/control-api.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import {
   chmodSync as chmodSync4,
   closeSync as closeSync5,
@@ -20749,17 +21003,17 @@ import {
   openSync as openSync5,
   readSync as readSync3,
   readdirSync as readdirSync18,
-  rmSync as rmSync20,
+  rmSync as rmSync21,
   statSync as statSync13,
   watch
 } from "fs";
 import { createConnection } from "net";
 import { createServer } from "http";
-import { basename as basename13, dirname as dirname23, join as join45 } from "path";
-import { execFile as execFile2, spawn as spawn9 } from "child_process";
+import { basename as basename13, dirname as dirname23, join as join46 } from "path";
+import { execFile as execFile2, spawn as spawn10 } from "child_process";
 
 // src/periscope-control.ts
-import { spawn as spawn8 } from "child_process";
+import { spawn as spawn9 } from "child_process";
 var reply = (status2, body) => ({ status: status2, body });
 var err = (status2, message) => reply(status2, { error: message });
 var TICKET_RE = /^(?:[A-Za-z]+-)?\d+$/;
@@ -20950,7 +21204,7 @@ async function handlePeriscopes(h, q) {
 }
 function runCrew(args, onLine, timeoutMs = 20 * 6e4) {
   return new Promise((resolve7) => {
-    const child = spawn8(process.execPath, [process.argv[1] ?? "", ...args], { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn9(process.execPath, [process.argv[1] ?? "", ...args], { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     let pending = "";
@@ -20984,7 +21238,7 @@ function runCrew(args, onLine, timeoutMs = 20 * 6e4) {
 // src/control-api.ts
 var PAUSABLE = ["dev", "design", "qa"];
 var CONTROL_SOCKET_NAME = "control.sock";
-var controlSocketFor = (stateDir) => join45(stateDir, CONTROL_SOCKET_NAME);
+var controlSocketFor = (stateDir) => join46(stateDir, CONTROL_SOCKET_NAME);
 var MAX_SOCKET_PATH = 100;
 var MAX_TAIL_BYTES = 1024 * 1024;
 var MAX_WAIT_SECONDS = 30;
@@ -21000,7 +21254,7 @@ var ControlAuth = class {
     if (!token) return "unauthorized";
     for (const k of this.o.shipKeys()) if (k && secretsMatch(token, k)) return "ok";
     const now = (this.o.now ?? Date.now)();
-    const id = createHash9("sha256").update(token).digest("hex");
+    const id = createHash10("sha256").update(token).digest("hex");
     const hit = this.cache.get(id);
     if (hit && now - hit.at < (this.o.cacheMs ?? 6e4)) return hit.verdict;
     const verdict = await this.ask(token);
@@ -21021,7 +21275,7 @@ var ControlAuth = class {
     for (const k of this.o.shipKeys()) if (k && secretsMatch(token, k)) return "ok";
     for (const k of this.o.workspaceSecrets?.(workspaceId) ?? []) if (k && secretsMatch(token, k)) return "ok";
     const now = (this.o.now ?? Date.now)();
-    const id = `${workspaceId}:${createHash9("sha256").update(token).digest("hex")}`;
+    const id = `${workspaceId}:${createHash10("sha256").update(token).digest("hex")}`;
     const hit = this.cache.get(id);
     if (hit && now - hit.at < (this.o.cacheMs ?? 6e4)) return hit.verdict;
     const verdict = await this.ask(token, [workspaceId]);
@@ -21071,7 +21325,7 @@ function candidates(live, rotated) {
   const out = [live];
   if (!rotated) return out;
   try {
-    for (const n of readdirSync18(dirname23(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join45(dirname23(live), n));
+    for (const n of readdirSync18(dirname23(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join46(dirname23(live), n));
   } catch {
   }
   return out;
@@ -21269,9 +21523,9 @@ async function route(deps, method, url, req, abort) {
   if (p === "/events" && get2) return tailReply(eventFileFor(deps.stateDir), url.searchParams, true, abort);
   if (p === "/streams" && get2) return reply2(200, { streams: liveRuns(deps.stateDir).map(describeStream) });
   if (p.startsWith("/streams/") && get2) {
-    const run2 = decodeURIComponent(p.slice("/streams/".length));
-    if (!RUN_NAME_RE.test(run2) || run2.includes("..") || /\.(pid|meta\.json|events\.jsonl)$/.test(run2)) return err2(400, "not a run name");
-    const file = join45(deps.stateDir, "streams", run2.endsWith(".jsonl") ? run2 : `${run2}.jsonl`);
+    const run3 = decodeURIComponent(p.slice("/streams/".length));
+    if (!RUN_NAME_RE.test(run3) || run3.includes("..") || /\.(pid|meta\.json|events\.jsonl)$/.test(run3)) return err2(400, "not a run name");
+    const file = join46(deps.stateDir, "streams", run3.endsWith(".jsonl") ? run3 : `${run3}.jsonl`);
     if (!existsSync43(file)) return err2(404, "no such run");
     return tailReply(file, url.searchParams, false, abort);
   }
@@ -21334,7 +21588,7 @@ async function startControlServer(deps) {
     log(`control API not started: socket path is too long for a unix socket (${path})`);
     return null;
   }
-  if (await socketIsStale(path)) rmSync20(path, { force: true });
+  if (await socketIsStale(path)) rmSync21(path, { force: true });
   else if (existsSync43(path)) {
     log(`control API not started: ${path} is in use by another process`);
     return null;
@@ -21381,7 +21635,7 @@ async function startControlServer(deps) {
         path,
         close: () => new Promise((done) => {
           server.close(() => {
-            rmSync20(path, { force: true });
+            rmSync21(path, { force: true });
             done();
           });
         })
@@ -21390,19 +21644,19 @@ async function startControlServer(deps) {
   });
 }
 var shq2 = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
-function runDetached(commands, spawnFn = spawn9) {
+function runDetached(commands, spawnFn = spawn10) {
   const script = `sleep 1; ${commands.map((c) => c.map(shq2).join(" ")).join("; ")}`;
   const child = spawnFn("/bin/sh", ["-c", script], { detached: true, stdio: "ignore" });
   child.on("error", () => {
   });
   child.unref();
 }
-function schedulerHandler(control, run2 = runDetached) {
+function schedulerHandler(control, run3 = runDetached) {
   return (action) => {
     const { startCommand: start, stopCommand: stop } = control;
     if (!start || !stop) return { accepted: false, detail: "this host has no service manager for the daemon (cron or none)" };
     const commands = action === "start" ? [start] : action === "stop" ? [stop] : [stop, start];
-    run2(commands);
+    run3(commands);
     return { accepted: true, detail: `${action} requested` };
   };
 }
@@ -21421,53 +21675,53 @@ function crewJson(args, timeoutMs = 6e4) {
 
 // src/periscope-mcp.ts
 import { lstat, mkdir, readdir, readFile, readlink, realpath, rm, stat, writeFile } from "fs/promises";
-import { basename as basename14, dirname as dirname24, isAbsolute as isAbsolute3, join as join47, relative as relative2, resolve as resolve5, sep } from "path";
+import { basename as basename14, dirname as dirname24, isAbsolute as isAbsolute3, join as join48, relative as relative2, resolve as resolve5, sep } from "path";
 import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 
 // src/periscope-endpoints.ts
 import { randomBytes as randomBytes3 } from "crypto";
-import { chmodSync as chmodSync5, existsSync as existsSync44, mkdirSync as mkdirSync28, readdirSync as readdirSync19, readFileSync as readFileSync38, rmSync as rmSync21, writeFileSync as writeFileSync31 } from "fs";
-import { join as join46 } from "path";
-var secretDir = (stateDir) => join46(stateDir, "periscope-mcp");
-var secretFile = (stateDir, id) => join46(secretDir(stateDir), `${id}.json`);
-var endpointDir = (stateDir) => join46(stateDir, "periscope-endpoints");
-var endpointFile = (stateDir, id) => join46(endpointDir(stateDir), `${id}.json`);
+import { chmodSync as chmodSync5, existsSync as existsSync44, mkdirSync as mkdirSync29, readdirSync as readdirSync19, readFileSync as readFileSync39, rmSync as rmSync22, writeFileSync as writeFileSync32 } from "fs";
+import { join as join47 } from "path";
+var secretDir = (stateDir) => join47(stateDir, "periscope-mcp");
+var secretFile = (stateDir, id) => join47(secretDir(stateDir), `${id}.json`);
+var endpointDir = (stateDir) => join47(stateDir, "periscope-endpoints");
+var endpointFile = (stateDir, id) => join47(endpointDir(stateDir), `${id}.json`);
 function mintPeriscopeSecret(stateDir, ticketRecordId) {
-  mkdirSync28(secretDir(stateDir), { recursive: true, mode: 448 });
+  mkdirSync29(secretDir(stateDir), { recursive: true, mode: 448 });
   const secret = randomBytes3(32).toString("base64url");
   const file = secretFile(stateDir, ticketRecordId);
-  writeFileSync31(file, `${JSON.stringify({ secret })}
+  writeFileSync32(file, `${JSON.stringify({ secret })}
 `, { mode: 384 });
   chmodSync5(file, 384);
   return secret;
 }
 function readPeriscopeSecret(stateDir, ticketRecordId) {
   try {
-    const v = JSON.parse(readFileSync38(secretFile(stateDir, ticketRecordId), "utf8"));
+    const v = JSON.parse(readFileSync39(secretFile(stateDir, ticketRecordId), "utf8"));
     return typeof v.secret === "string" && v.secret ? v.secret : void 0;
   } catch {
     return void 0;
   }
 }
 function removePeriscopeSecret(stateDir, ticketRecordId) {
-  rmSync21(secretFile(stateDir, ticketRecordId), { force: true });
+  rmSync22(secretFile(stateDir, ticketRecordId), { force: true });
 }
 function readPeriscopeEndpoint(stateDir, ticketRecordId) {
   try {
-    return JSON.parse(readFileSync38(endpointFile(stateDir, ticketRecordId), "utf8"));
+    return JSON.parse(readFileSync39(endpointFile(stateDir, ticketRecordId), "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePeriscopeEndpoint(stateDir, rec) {
-  mkdirSync28(endpointDir(stateDir), { recursive: true });
-  writeFileSync31(endpointFile(stateDir, rec.ticketRecordId), `${JSON.stringify(rec, null, 2)}
+  mkdirSync29(endpointDir(stateDir), { recursive: true });
+  writeFileSync32(endpointFile(stateDir, rec.ticketRecordId), `${JSON.stringify(rec, null, 2)}
 `);
 }
 function removePeriscopeEndpointRecord(stateDir, ticketRecordId) {
-  rmSync21(endpointFile(stateDir, ticketRecordId), { force: true });
+  rmSync22(endpointFile(stateDir, ticketRecordId), { force: true });
 }
 function listPeriscopeEndpoints(stateDir) {
   const dir = endpointDir(stateDir);
@@ -21574,13 +21828,13 @@ async function resolveInWorktree(root, requested) {
   let abs;
   if (isAbsolute3(requested)) {
     abs = resolve5(requested);
-    if (isInside(root, abs)) abs = join47(realRoot, relative2(root, abs));
+    if (isInside(root, abs)) abs = join48(realRoot, relative2(root, abs));
   } else {
     abs = resolve5(realRoot, requested);
   }
   if (!isInside(realRoot, abs)) throw new PathRefusal(`${requested} is outside this periscope's worktree`);
   const { real, rest } = await realAncestor(abs);
-  const final = rest ? join47(real, rest) : real;
+  const final = rest ? join48(real, rest) : real;
   if (!isInside(realRoot, final)) throw new PathRefusal(`${requested} is outside this periscope's worktree`);
   if (relative2(realRoot, final).split(sep).includes(".git")) throw new PathRefusal(".git is not reachable from a periscope");
   return final;
@@ -21648,7 +21902,7 @@ function createPeriscopeMcpServer(d, sc) {
     const entries = (await readdir(abs, { withFileTypes: true })).filter((e) => e.name !== ".git");
     const lines2 = await Promise.all(entries.map(async (e) => {
       if (e.isDirectory()) return `[DIR]  ${e.name}`;
-      const size = (await lstat(join47(abs, e.name))).size;
+      const size = (await lstat(join48(abs, e.name))).size;
       return `[FILE] ${e.name} (${size} bytes)`;
     }));
     return text(lines2.join("\n") || "(empty)");
@@ -21714,7 +21968,7 @@ function createPeriscopeMcpServer(d, sc) {
     annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
   }, async ({ path }) => {
     const parent = await inTree(dirname24(path) === "" ? "." : dirname24(path));
-    const abs = join47(parent, basename14(path));
+    const abs = join48(parent, basename14(path));
     if (basename14(path) === ".git" || abs === parent) return text("path must name a file", true);
     const st = await lstat(abs).catch(() => void 0);
     if (!st) return text(`${path} does not exist`, true);
@@ -22121,6 +22375,7 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "rotate-passenger-url",
   "run",
   "sample-ticket",
+  "sandbox",
   "selftest",
   "shell-init",
   "ship",
@@ -22200,7 +22455,7 @@ if (command === "provision") {
   process.exit(outcome.code);
 }
 if (command === "pool-member") {
-  const pool = poolConfigFrom(argv, process.env, () => readFileSync39(0, "utf8"));
+  const pool = poolConfigFrom(argv, process.env, () => readFileSync40(0, "utf8"));
   if (typeof pool === "string") {
     process.stderr.write(`crew pool-member: ${pool}
 `);
@@ -22241,9 +22496,9 @@ if (command === "passenger-sync-daemon") {
     return m ? m[1] : null;
   }, routeRelayUrl = function(route3) {
     const ws = route3.resolved?.workspaceId;
-    const slug = ws ? readPersistedTunnel(cfg.ship.stateDir, ws)?.slug : void 0;
-    if (!cfg.ship.relayHost || !slug) return null;
-    return relayBaseUrlFor(slug, cfg.ship.relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain);
+    const slug2 = ws ? readPersistedTunnel(cfg.ship.stateDir, ws)?.slug : void 0;
+    if (!cfg.ship.relayHost || !slug2) return null;
+    return relayBaseUrlFor(slug2, cfg.ship.relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain);
   }, passengerApiKeys = function(routes) {
     const keys = /* @__PURE__ */ new Map();
     for (const r of routes) {
@@ -22308,8 +22563,8 @@ if (command === "passenger-sync-daemon") {
       stateDir: cfg.ship.stateDir,
       shipName: cfg.ship.name,
       apiFor: endpointApiFor(routes),
-      urlFor: (slug) => publicUrlFor(slug, relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain),
-      controlUrlFor: (slug) => `${relayBaseUrlFor(slug, relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain)}/control`,
+      urlFor: (slug2) => publicUrlFor(slug2, relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain),
+      controlUrlFor: (slug2) => `${relayBaseUrlFor(slug2, relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain)}/control`,
       warn: (m) => emit.warn(m, { step: "passengers" })
     };
   }, releaseRefused = function() {
@@ -22329,8 +22584,20 @@ if (command === "passenger-sync-daemon") {
     const out = refreshBaseBranch(r.dir, remote, base, true);
     const unsafe = baseBranchUnsafe(out);
     return { action: out.action, unsafe, detail: unsafe ? describeUnsafeBase(out, remote, base) : out.detail };
+  }, sandboxTickDeps = function(emit2, c) {
+    return {
+      stateDir: cfg.ship.stateDir,
+      run: spawnBuildRunner(),
+      hasImage: engineHasImage(),
+      removeImage: engineRemoveImage(),
+      raise: (item) => {
+        void raiseShipAttention({ state, emit: emit2, route: c, ship: cfg.ship }, item);
+      },
+      clear: (key) => clearShipAttention(state, key),
+      log: (m) => emit2.emit(m)
+    };
   };
-  requireArmed2 = requireArmed, parseTicketNumber2 = parseTicketNumber, routeRelayUrl2 = routeRelayUrl, passengerApiKeys2 = passengerApiKeys, endpointApiFor2 = endpointApiFor, periscopeEndpointDeps2 = periscopeEndpointDeps, periscopeMcpDeps2 = periscopeMcpDeps, endpointReconcileDeps2 = endpointReconcileDeps, releaseRefused2 = releaseRefused, doctorMachineId2 = doctorMachineId, baseHealth2 = baseHealth;
+  requireArmed2 = requireArmed, parseTicketNumber2 = parseTicketNumber, routeRelayUrl2 = routeRelayUrl, passengerApiKeys2 = passengerApiKeys, endpointApiFor2 = endpointApiFor, periscopeEndpointDeps2 = periscopeEndpointDeps, periscopeMcpDeps2 = periscopeMcpDeps, endpointReconcileDeps2 = endpointReconcileDeps, releaseRefused2 = releaseRefused, doctorMachineId2 = doctorMachineId, baseHealth2 = baseHealth, sandboxTickDeps2 = sandboxTickDeps;
   let cfg;
   let firstRun;
   let firstRunFromFlags = false;
@@ -22401,7 +22668,7 @@ if (command === "passenger-sync-daemon") {
     throw e;
   }
   if (command === "credential") {
-    const r = runCredential(positional[1], readFileSync39(0, "utf8"), cfg.ship.forges, cfg.ship.stateDir);
+    const r = runCredential(positional[1], readFileSync40(0, "utf8"), cfg.ship.forges, cfg.ship.stateDir);
     process.stdout.write(r.out);
     process.stderr.write(r.err);
     process.exit(r.code);
@@ -22413,9 +22680,9 @@ if (command === "passenger-sync-daemon") {
         forges: cfg.ship.forges,
         stateDir: cfg.ship.stateDir,
         configFile: cfg.configFile,
-        readFile: (p) => readFileSync39(p, "utf8"),
-        writeFile: (p, t) => writeFileSync32(p, t),
-        stdin: () => readFileSync39(0, "utf8"),
+        readFile: (p) => readFileSync40(p, "utf8"),
+        writeFile: (p, t) => writeFileSync33(p, t),
+        stdin: () => readFileSync40(0, "utf8"),
         env: process.env
       }
     );
@@ -22435,7 +22702,7 @@ if (command === "passenger-sync-daemon") {
   const DAEMON_SUBCOMMANDS = /* @__PURE__ */ new Set(["start", "stop", "status", "restart"]);
   const worktreeArgs = command === "worktree" ? splitWorktreeArgs(positional, cfg.routes.map((r) => r.route)) : void 0;
   const named = worktreeArgs ? worktreeArgs.route : command === "daemon" && DAEMON_SUBCOMMANDS.has(positional[1] ?? "") ? positional[2] : positional[1];
-  const fleetWide = command === "inbox" || command === "connect" || command === "disconnect" || command === "deprovision" || command === "agents" || command === "skills" || command === "logbook" || command === "repos" || command === "ship" || command === "projects" || command === "periscope" || command === "whoami" || releaseFleetWide || command === "pause" || command === "resume" || command === "reload" || FLEET_CAPABLE.has(command) && !named && cfg.routes.length > 1 || worktreeArgs !== void 0 && !named && cfg.routes.length > 1;
+  const fleetWide = command === "inbox" || command === "connect" || command === "disconnect" || command === "deprovision" || command === "agents" || command === "skills" || command === "logbook" || command === "repos" || command === "ship" || command === "projects" || command === "periscope" || command === "sandbox" || command === "whoami" || releaseFleetWide || command === "pause" || command === "resume" || command === "reload" || FLEET_CAPABLE.has(command) && !named && cfg.routes.length > 1 || worktreeArgs !== void 0 && !named && cfg.routes.length > 1;
   let route2;
   try {
     route2 = fleetWide ? cfg.routes[0] : findRoute(cfg, named);
@@ -22698,7 +22965,7 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join48(homedir11(), ".config", "systemd", "user", `${label}.timer`);
+      const staleTimer = join49(homedir11(), ".config", "systemd", "user", `${label}.timer`);
       if (existsSync45(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
@@ -22761,7 +23028,7 @@ if (command === "passenger-sync-daemon") {
       for (const a of plan.actions) {
         if (a.kind === "enable") {
           if (prompter && !await prompter.confirm(`Route ${a.route} passes every check \u2014 set enabled: true in ${cfg.configFile}?`, false)) continue;
-          writeFileSync32(cfg.configFile, planEnable(readFileSync39(cfg.configFile, "utf8"), a.route));
+          writeFileSync33(cfg.configFile, planEnable(readFileSync40(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -22780,6 +23047,14 @@ ${changed2.map((c) => `  - ${c}
   async function resolvedRepos(c) {
     return Promise.all(reposOf(c).map((t) => resolveOneRepo(c, t)));
   }
+  async function sandboxReposOf(routes) {
+    const out = /* @__PURE__ */ new Map();
+    for (const c of routes) {
+      const { settled } = await settleRepos(reposOf(c), (t) => t.name, (t) => resolveOneRepo(c, t));
+      for (const r of settled) if (r.config.sandbox && !out.has(r.name)) out.set(r.name, { name: r.name, decl: r.config.sandbox });
+    }
+    return [...out.values()];
+  }
   async function resolveOneRepo(c, t) {
     {
       const id = repoIdForName(c, t.name);
@@ -23884,7 +24159,7 @@ ${cu.tail.trimEnd()}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join48(CREW_HOME, "src"), join48(CREW_HOME, "dist"), join48(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join49(CREW_HOME, "src"), join49(CREW_HOME, "dist"), join49(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -23950,6 +24225,7 @@ ${cu.tail.trimEnd()}
       });
       if (controlServer) emit.emit(`control API listening on ${controlServer.path}`);
       const inFlight = /* @__PURE__ */ new Set();
+      let sandboxBuilding = false;
       const stopReason = await runDaemonLoop({
         inFlight,
         onStaleDeferred: ({ runs, waitedMs }) => emit.warn(
@@ -23995,6 +24271,12 @@ ${cu.tail.trimEnd()}
         ),
         checkStale: makeStaleChecker(watchPaths, { reloadSentinel: reloadSentinelFor(cfg.ship.stateDir) }),
         onPass: (result) => {
+          if (!sandboxBuilding) {
+            sandboxBuilding = true;
+            void sandboxReposOf(cfg.routes.filter((r) => r.enabled)).then((repos) => repos.length ? sandboxBuildTick(repos, sandboxTickDeps(emit, route2)) : null).catch((err3) => emit.warn(`sandbox image build tick failed: ${err3 instanceof Error ? err3.message : String(err3)}`)).finally(() => {
+              sandboxBuilding = false;
+            });
+          }
           if (result.started.length) emit.emit(`daemon pass started: ${result.started.join(", ")}`);
           for (const s of result.skipped) emit.emit(`daemon pass skipped ${s.role} \u2014 ${s.reason}`);
         }
@@ -24097,9 +24379,9 @@ ${cu.tail.trimEnd()}
 `);
         process.exit(2);
       }
-      let run2;
+      let run3;
       try {
-        run2 = await runAgentsSync(target, {
+        run3 = await runAgentsSync(target, {
           userAgent: cfg.ship.userAgent,
           stateDir: cfg.ship.stateDir,
           dryRun,
@@ -24117,7 +24399,7 @@ ${cu.tail.trimEnd()}
         }
         throw e;
       }
-      const { personaResult, skillResult } = run2;
+      const { personaResult, skillResult } = run3;
       if (flag("revoke-seat-keys")) {
         for (const o of await revokeSeatKeys(target, { userAgent: cfg.ship.userAgent, dryRun })) {
           process.stdout.write(`${describeRevokeOutcome(o)}
@@ -24138,7 +24420,7 @@ ${cu.tail.trimEnd()}
           }
         }
       }
-      if (run2.diverged) process.exitCode = 1;
+      if (run3.diverged) process.exitCode = 1;
       break;
     }
     case "skills": {
@@ -24180,10 +24462,10 @@ ${cu.tail.trimEnd()}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync45(resolvedPath) ? JSON.parse(readFileSync39(resolvedPath, "utf8")) : {};
+        const raw = existsSync45(resolvedPath) ? JSON.parse(readFileSync40(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
-        mkdirSync29(dirOf2(resolvedPath), { recursive: true });
-        writeFileSync32(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        mkdirSync30(dirOf2(resolvedPath), { recursive: true });
+        writeFileSync33(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (result.outcomes.some((o) => o.action === "diverged")) process.exitCode = 1;
@@ -24206,7 +24488,7 @@ ${cu.tail.trimEnd()}
         throw e;
       }
       const oldName = cfg.ship.name;
-      writeFileSync32(cfg.configFile, setShipNameInYaml(readFileSync39(cfg.configFile, "utf8"), newName));
+      writeFileSync33(cfg.configFile, setShipNameInYaml(readFileSync40(cfg.configFile, "utf8"), newName));
       cfg.ship.name = newName;
       let renameMachineId;
       try {
@@ -24253,7 +24535,7 @@ ${cu.tail.trimEnd()}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list" && sub !== "clone" && sub !== "hooks" && sub !== "check") usage2();
-      const configText = readFileSync39(cfg.configFile, "utf8");
+      const configText = readFileSync40(cfg.configFile, "utf8");
       if (sub === "check") {
         try {
           const routeArg = value("route") ?? positional[2];
@@ -24293,7 +24575,7 @@ ${cu.tail.trimEnd()}
             }
           }, read: (r) => {
             try {
-              return readFileSync39(resolvePath(dir, r), "utf8");
+              return readFileSync40(resolvePath(dir, r), "utf8");
             } catch {
               return void 0;
             }
@@ -24335,19 +24617,19 @@ ${cu.tail.trimEnd()}
           let cleared;
           if (clear2) {
             const plan = clearRouteHooks(configText, a.route, a.name);
-            if (plan.removed.length > 0) writeFileSync32(cfg.configFile, plan.text);
+            if (plan.removed.length > 0) writeFileSync33(cfg.configFile, plan.text);
             cleared = { file: cfg.configFile, removed: plan.removed };
           }
           if (write && suggestion.source === null && recipeIds.length === 0 && hookSpecs.length === 0) throw new ReposError(`nothing to write: ${suggestion.notes[0]}`);
           if (write === "route") {
             const plan = planRouteHooks(configText, a.route, a.name, picked.hooks, { replace: flag("replace") });
-            writeFileSync32(cfg.configFile, plan.text);
+            writeFileSync33(cfg.configFile, plan.text);
             written = { target: "route", file: cfg.configFile, hooks: plan.written, kept: plan.kept, replaced: plan.replaced };
           } else if (write === "repo") {
             const have = existingRepoConfig(files);
             if (have) throw new ReposError(`${resolvePath(dir, have)} already exists; not overwriting it`);
             const file = resolvePath(dir, ".crew.yaml");
-            writeFileSync32(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
+            writeFileSync33(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
             written = { target: "repo", file, hooks: Object.keys(picked.hooks), kept: [], replaced: [] };
           }
           if (flag("json")) {
@@ -24444,7 +24726,7 @@ ${cu.tail.trimEnd()}
       let resolvedRemotes;
       if (existsSync45(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync39(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync40(resolvedFile, "utf8"));
         } catch {
         }
       }
@@ -24465,7 +24747,7 @@ ${cu.tail.trimEnd()}
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
-                  return Object.keys(parseRepoConfig(readFileSync39(resolvePath(d, f), "utf8"), f).hooks).length > 0;
+                  return Object.keys(parseRepoConfig(readFileSync40(resolvePath(d, f), "utf8"), f).hooks).length > 0;
                 } catch {
                   return false;
                 }
@@ -24514,7 +24796,7 @@ ${cu.tail.trimEnd()}
             throw new ReposError(`${e.message}${authHint}
   crew.yaml was not changed`);
           }
-          writeFileSync32(cfg.configFile, plan2.text);
+          writeFileSync33(cfg.configFile, plan2.text);
           if (plan2.droppedDir) process.stderr.write(`crew repos: dropped dir: ${plan2.droppedDir} from route ${routeName} \u2014 it is not a checkout (the clone base); checkouts now live under repos:
 `);
           say("attached", { route: routeName, name: plan2.name, dir: plan2.target, mode: plan2.mode }, `cloned and attached ${plan2.target} to ${routeName} as ${plan2.mode === "dir" ? "dir" : `repos.${plan2.name}`} in ${cfg.configFile}`);
@@ -24574,14 +24856,14 @@ ${cu.tail.trimEnd()}
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
           if (existsSync45(resolvedFile)) {
-            const raw = JSON.parse(readFileSync39(resolvedFile, "utf8"));
+            const raw = JSON.parse(readFileSync40(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
-            writeFileSync32(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync33(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        writeFileSync32(cfg.configFile, plan.text);
+        writeFileSync33(cfg.configFile, plan.text);
         process.stdout.write(`added ${top} to ${routeName} as ${plan.mode === "dir" ? "dir" : `repos.${plan.name}`} in ${cfg.configFile}
 `);
       } catch (e) {
@@ -24950,7 +25232,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.exit(2);
         }
         if (found.shipNameAdopted && !dryRun) {
-          writeFileSync32(cfg.configFile, setShipNameInYaml(readFileSync39(cfg.configFile, "utf8"), found.shipNameAdopted));
+          writeFileSync33(cfg.configFile, setShipNameInYaml(readFileSync40(cfg.configFile, "utf8"), found.shipNameAdopted));
           cfg.ship.name = found.shipNameAdopted;
         }
         if (found.shipRow) {
@@ -24996,7 +25278,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         const hadPreviousFile = existsSync45(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync39(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync40(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -25126,12 +25408,12 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.stderr.write(`(dry run) would write resolved ids to ${resolvedPath}
 `);
         } else {
-          mkdirSync29(dirname25(resolvedPath), { recursive: true });
+          mkdirSync30(dirname25(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
-          writeFileSync32(tmpPath, `${JSON.stringify(resolved, null, 2)}
+          writeFileSync33(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
-          renameSync5(tmpPath, resolvedPath);
+          renameSync6(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
 `);
         }
@@ -25175,8 +25457,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             process.stderr.write(`(dry run) would write the minted API key to ${apiKeyFile}
 `);
           } else {
-            mkdirSync29(dirname25(apiKeyFile), { recursive: true });
-            writeFileSync32(apiKeyFile, `${apiKeyVar}=${apiKey}
+            mkdirSync30(dirname25(apiKeyFile), { recursive: true });
+            writeFileSync33(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
 `);
@@ -25309,7 +25591,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           if (syncRoute?.resolved) {
             try {
               process.stderr.write("\n");
-              const run2 = await runAgentsSync(syncRoute, {
+              const run3 = await runAgentsSync(syncRoute, {
                 userAgent: cfg.ship.userAgent,
                 stateDir: cfg.ship.stateDir,
                 say: (l) => process.stderr.write(`  ${l}
@@ -25324,19 +25606,19 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
                 if (p.state === "forbidden") process.stderr.write(`  ${describeSeatForbidden(p.role, p.tables)}
 `);
               }
-              if (run2.readOnly) {
-                const missing = run2.personaResult.outcomes.some((p) => p.action === "missing");
+              if (run3.readOnly) {
+                const missing = run3.personaResult.outcomes.some((p) => p.action === "missing");
                 process.stderr.write(missing ? "  A workspace admin has to open the Crew app or run `crew agents sync` once before this ship's seats can run.\n" : "  Seats are linked to the workspace's existing personas.\n");
               }
-              connectEvents.emit("agents_synced", run2.readOnly ? "agents linked (read-only key)" : "agents synced", {
+              connectEvents.emit("agents_synced", run3.readOnly ? "agents linked (read-only key)" : "agents synced", {
                 route: route3,
-                admin: !run2.readOnly,
-                personas: run2.personaResult.outcomes,
-                skills: run2.skillResult?.outcomes ?? [],
-                diverged: run2.diverged
+                admin: !run3.readOnly,
+                personas: run3.personaResult.outcomes,
+                skills: run3.skillResult?.outcomes ?? [],
+                diverged: run3.diverged
               });
               for (const m of minted) connectEvents.emit("seat_key", describeMintOutcome(m), { route: route3, ...m });
-              if (run2.diverged) process.exitCode = 1;
+              if (run3.diverged) process.exitCode = 1;
             } catch (e) {
               if (e instanceof AgentsSyncError || e instanceof SkillSyncError) skip(e.message);
               else throw e;
@@ -25724,6 +26006,70 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       if (!planIsUsable(planWt)) process.exitCode = 1;
       break;
     }
+    case "sandbox": {
+      const subS = positional[1];
+      if (subS !== "build" && subS !== "images") {
+        process.stderr.write("crew sandbox build [REPO] [--route ROUTE] [--json]\ncrew sandbox images [--route ROUTE] [--json]\n");
+        process.exit(2);
+      }
+      const jsonS = flag("json");
+      let routesS;
+      try {
+        routesS = value("route") ? [findRoute(cfg, value("route"))] : cfg.routes.filter((r) => r.enabled);
+      } catch (e) {
+        if (e instanceof ConfigError) {
+          process.stderr.write(`crew: ${e.message}
+`);
+          process.exit(2);
+        }
+        throw e;
+      }
+      const declared = await sandboxReposOf(routesS);
+      if (subS === "images") {
+        const stateS = readSandboxState(cfg.ship.stateDir);
+        const rows = declared.map((r) => {
+          const plan = planSandbox(r.name, r.decl);
+          return { repo: r.name, wants: plan.tag, tags: stateS[r.name]?.tags ?? [], ...sandboxImageStatus(stateS, plan) };
+        });
+        if (jsonS) {
+          process.stdout.write(`${JSON.stringify(rows, null, 2)}
+`);
+          break;
+        }
+        if (rows.length === 0) process.stdout.write("no repository declares a sandbox: section in its .crew.yaml\n");
+        for (const r of rows) {
+          process.stdout.write(`${r.repo}: ${r.status} \u2014 ${r.detail}
+`);
+          for (const t of r.tags) {
+            const ageH = Math.max(0, Math.round((Date.now() - Date.parse(t.builtAt)) / 36e5));
+            process.stdout.write(`  ${t.tag}  built ${t.builtAt} (${ageH}h ago)
+`);
+          }
+        }
+        break;
+      }
+      const only = positional[2];
+      const targets = only ? declared.filter((r) => r.name === only) : declared;
+      if (targets.length === 0) {
+        process.stderr.write(only ? `crew: no repository "${only}" declares a sandbox: section
+` : "crew: no repository declares a sandbox: section in its .crew.yaml\n");
+        process.exit(2);
+      }
+      const emitS = new Emitter({ route: routesS[0].route, eventFile: eventFileFor(cfg.ship.stateDir), rotateBytes: cfg.ship.eventsRotateBytes, logFile: cfg.ship.logFile, console: (l) => process.stderr.write(`${l}
+`) });
+      const depsS = sandboxTickDeps(emitS, routesS[0]);
+      let failed = false;
+      for (const t of targets) {
+        await sandboxBuildTick([t], depsS, true);
+        const after = readSandboxState(cfg.ship.stateDir);
+        const st = sandboxImageStatus(after, planSandbox(t.name, t.decl));
+        if (st.status === "failed") failed = true;
+        process.stdout.write(`${t.name}: ${st.status} \u2014 ${st.detail}
+`);
+      }
+      if (failed) process.exit(1);
+      break;
+    }
     case "periscope": {
       const subP = positional[1];
       if (subP !== "up" && subP !== "start" && subP !== "down" && subP !== "end" && subP !== "list") {
@@ -26006,10 +26352,10 @@ ${where.join("\n")}`);
           },
           prepare: async (path) => {
             for (const f of repoP.config.worktrees.copy) {
-              const src = join48(repoP.dir, f);
+              const src = join49(repoP.dir, f);
               if (!existsSync45(src)) continue;
-              mkdirSync29(dirOf2(join48(path, f)), { recursive: true });
-              copyFileSync2(src, join48(path, f));
+              mkdirSync30(dirOf2(join49(path, f)), { recursive: true });
+              copyFileSync2(src, join49(path, f));
             }
             const setup = repoP.config.hooks.setup;
             return setup ? runScript(setup, { cwd: path, shell: shellP, onLine: (l) => {
@@ -26283,9 +26629,9 @@ ${where.join("\n")}`);
           } };
           const store = resetStore;
           const h = hostFromUrl4(r.baseUrl);
-          const [slug] = splitRoute(r.route);
-          const session = await store.get(h, slug);
-          return { stored: Boolean(session?.apiKey), clear: () => store.clear(h, slug) };
+          const [slug2] = splitRoute(r.route);
+          const session = await store.get(h, slug2);
+          return { stored: Boolean(session?.apiKey), clear: () => store.clear(h, slug2) };
         },
         async hostSessions(stateDir) {
           const store = resetStore;
@@ -26304,7 +26650,7 @@ ${where.join("\n")}`);
       };
       const droppedRoutes = [];
       try {
-        const rawCfg = parseYaml2(readFileSync39(cfg.configFile, "utf8"));
+        const rawCfg = parseYaml2(readFileSync40(cfg.configFile, "utf8"));
         for (const r of rawCfg?.routes ?? []) {
           if (typeof r?.route !== "string" || cfg.routes.some((x) => x.route === r.route)) continue;
           try {
@@ -26357,8 +26703,8 @@ ${where.join("\n")}`);
         process.stdout.write("crew reload: no daemon unit is running \u2014 nothing to reload (the next run reads crew.yaml fresh)\n");
         break;
       }
-      mkdirSync29(cfg.ship.stateDir, { recursive: true });
-      writeFileSync32(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
+      mkdirSync30(cfg.ship.stateDir, { recursive: true });
+      writeFileSync33(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
       process.stdout.write(
         "crew reload: requested \u2014 the daemon relaunches with the new config once its running agents end (it starts no new work meanwhile); if it is busy, `crew reload --now` forces the relaunch and interrupts them\n"
@@ -26411,7 +26757,7 @@ ${where.join("\n")}`);
     }
     case "log": {
       try {
-        const text2 = readFileSync39(cfg.ship.logFile, "utf8").split("\n");
+        const text2 = readFileSync40(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text2.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -26434,7 +26780,7 @@ ${where.join("\n")}`);
       };
       if (!route2.resolved) fail(`route ${route2.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route2, cfg.ship);
-      const configText = readFileSync39(cfg.configFile, "utf8");
+      const configText = readFileSync40(cfg.configFile, "utf8");
       const cfgBase = dirname25(cfg.configFile);
       const configured2 = configuredRepos(configText, route2.route, cfgBase);
       const dir = configured2.find((r) => r.name === SAMPLE_REPO)?.dir ?? sampleDir(configured2.map((r) => r.dir), route2.reposBasePath, route2.route.split("/")[0]);
@@ -26463,7 +26809,7 @@ ${where.join("\n")}`);
         }
         if (configured2.some((r) => r.dir === dir)) {
           try {
-            writeFileSync32(cfg.configFile, planRepoRemove(configText, cfgBase, route2.route, dir).text);
+            writeFileSync33(cfg.configFile, planRepoRemove(configText, cfgBase, route2.route, dir).text);
           } catch (e) {
             if (e instanceof ReposError) fail(e.message);
             throw e;
@@ -26472,28 +26818,28 @@ ${where.join("\n")}`);
         if (row) {
           await tracker.deleteRepoRow(row.id);
           if (existsSync45(resolvedFile)) {
-            const raw = JSON.parse(readFileSync39(resolvedFile, "utf8"));
+            const raw = JSON.parse(readFileSync40(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
-            writeFileSync32(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync33(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        if (existsSync45(join48(dir, ".git")) && basename15(dir) === SAMPLE_REPO) rmSync22(dir, { recursive: true, force: true });
+        if (existsSync45(join49(dir, ".git")) && basename15(dir) === SAMPLE_REPO) rmSync23(dir, { recursive: true, force: true });
         say("removed", { dir, closed }, `removed the sample repo${closed.length ? `, closed ${closed.join(", ")}` : ""}`);
         break;
       }
       const projectId = route2.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
-      const fresh = !existsSync45(join48(dir, ".git"));
+      const fresh = !existsSync45(join49(dir, ".git"));
       if (existsSync45(dir) && fresh && readdirSync20(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
       if (dryRun) {
         say("dry-run", { dir, newCheckout: fresh, repoRow: row?.id ?? null }, `would ${fresh ? "create" : "reuse"} ${dir}${row ? "" : ", create the Repos row"}, and file one ${tracker.contract.statuses.approved} ticket`);
         break;
       }
       if (fresh) {
-        mkdirSync29(dir, { recursive: true });
-        writeFileSync32(join48(dir, "README.md"), SAMPLE_README);
-        writeFileSync32(join48(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        mkdirSync30(dir, { recursive: true });
+        writeFileSync33(join49(dir, "README.md"), SAMPLE_README);
+        writeFileSync33(join49(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync10("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -26512,16 +26858,16 @@ ${where.join("\n")}`);
         });
         repoId = (await tracker.createRepoRow(payload)).id;
         if (existsSync45(resolvedFile)) {
-          const raw = JSON.parse(readFileSync39(resolvedFile, "utf8"));
+          const raw = JSON.parse(readFileSync40(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
-          writeFileSync32(resolvedFile, `${JSON.stringify(raw, null, 2)}
+          writeFileSync33(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
         }
       }
       if (!configured2.some((r) => r.dir === dir)) {
         try {
-          writeFileSync32(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route2.route, path: dir, name: SAMPLE_REPO }).text);
+          writeFileSync33(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route2.route, path: dir, name: SAMPLE_REPO }).text);
         } catch (e) {
           if (e instanceof ReposError) fail(e.message);
           throw e;
@@ -26964,7 +27310,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
         const unitPlan = planInstall(cfg.ship, CREW_HOME, host, detectSystemd(), "run", installContext());
         const abandons = unitAbandonsAgents(unitPlan, (p) => {
           try {
-            return readFileSync39(p, "utf8");
+            return readFileSync40(p, "utf8");
           } catch {
             return null;
           }
@@ -27386,13 +27732,13 @@ ${foreign.join("\n")}
         if (cfg.ship.relayHost) {
           for (const r of passengerRoutes) {
             const ws = r.resolved?.workspaceId;
-            const slug = ws ? readPersistedTunnel(cfg.ship.stateDir, ws)?.slug : void 0;
+            const slug2 = ws ? readPersistedTunnel(cfg.ship.stateDir, ws)?.slug : void 0;
             if (!ws) continue;
             process.stdout.write(
-              `                   ${r.route} url: ${slug ? publicUrlFor(slug, cfg.ship.relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain) : "not minted yet (first tunnel cycle creates it)"}
+              `                   ${r.route} url: ${slug2 ? publicUrlFor(slug2, cfg.ship.relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain) : "not minted yet (first tunnel cycle creates it)"}
 `
             );
-            const controlUrl = slug && readPersistedTunnel(cfg.ship.stateDir, ws)?.controlSocket ? `${relayBaseUrlFor(slug, cfg.ship.relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain)}/control` : void 0;
+            const controlUrl = slug2 && readPersistedTunnel(cfg.ship.stateDir, ws)?.controlSocket ? `${relayBaseUrlFor(slug2, cfg.ship.relayHost, cfg.ship.relayHttpPort, cfg.ship.relayPublicDomain)}/control` : void 0;
             process.stdout.write(`                   ${r.route} control url: ${controlUrl ?? "none (the tunnel carries passengers only)"}
 `);
             const api = endpointApiFor([r])(ws);
@@ -27411,6 +27757,15 @@ ${foreign.join("\n")}
           );
         }
       }
+      {
+        const declaredS = await sandboxReposOf(cfg.routes.filter((r) => r.enabled));
+        const stateS = readSandboxState(cfg.ship.stateDir);
+        for (const r of declaredS) {
+          const st = sandboxImageStatus(stateS, planSandbox(r.name, r.decl));
+          process.stdout.write(`sandbox image:    ${r.name}: ${st.status.toUpperCase()} \u2014 ${st.detail}
+`);
+        }
+      }
       for (const e of listPeriscopeEndpoints(cfg.ship.stateDir)) {
         const secret = readPeriscopeSecret(cfg.ship.stateDir, e.ticketRecordId) ? "live" : "ended, awaiting removal";
         process.stdout.write(`periscope mcp:     ${e.ticket} ${e.route} ${e.url} (${secret}, attached only)
@@ -27469,3 +27824,4 @@ var endpointReconcileDeps2;
 var releaseRefused2;
 var doctorMachineId2;
 var baseHealth2;
+var sandboxTickDeps2;