@tablation/crew 0.103.0 → 0.104.0

package/dist/cli.js

@@ -2678,6 +2678,23 @@ function parseCloneScheme(v) {
   if (v === "ssh" || v === "https") return v;
   throw new ConfigError(`ship.cloneScheme must be "ssh" or "https", got ${JSON.stringify(v)}`);
 }
+function parseShipRunner(v) {
+  if (v === void 0 || v === null || v === "") return void 0;
+  if (v === "host" || v === "sandbox") return v;
+  throw new ConfigError(`ship.runner must be "host" or "sandbox", got ${JSON.stringify(v)}`);
+}
+var SANDBOX_KEYS = ["bin", "image", "policy", "cacheVolume", "mirrorDir", "workDir", "agentBin", "forgeTokenVar"];
+function parseShipSandbox(v) {
+  if (v === void 0 || v === null) return void 0;
+  if (typeof v !== "object" || Array.isArray(v)) throw new ConfigError("ship.sandbox must be a map of settings");
+  const out = {};
+  for (const [k, val] of Object.entries(v)) {
+    if (!SANDBOX_KEYS.includes(k)) throw new ConfigError(`ship.sandbox: unknown setting "${k}" (known: ${SANDBOX_KEYS.join(", ")})`);
+    if (typeof val !== "string" || !val) throw new ConfigError(`ship.sandbox.${k} must be a non-empty string`);
+    out[k] = val;
+  }
+  return out;
+}
 function parseShipEnv(v) {
   if (v === void 0 || v === null) return void 0;
   if (typeof v !== "object" || Array.isArray(v)) throw new ConfigError("ship.env must be a map of variable name to value");
@@ -3124,6 +3141,8 @@ Create the first of those:
   if (dupe) missing.add(`routes: duplicate route "${dupe}" \u2014 a route addresses itself, so it must be unique`);
   missing.throwIfAny(file);
   configureSecretStore({ mode: secretStore, stateDir });
+  const shipRunner = parseShipRunner(shipRaw.runner);
+  const shipSandbox = parseShipSandbox(shipRaw.sandbox);
   return {
     ship: {
       name: shipRaw.name ?? "this ship",
@@ -3133,6 +3152,7 @@ Create the first of those:
         model: shipRaw.agent?.model ?? "claude-sonnet-5",
         maxThinkingTokens
       },
+      ...shipRunner ? { runner: shipRunner, ...shipSandbox ? { sandbox: shipSandbox } : {} } : {},
       ...toolchains.length > 0 ? { toolchains } : {},
       ...shipToolchain !== void 0 ? { toolchain: shipToolchain } : {},
       ...pair ? { pair } : {},
@@ -5418,17 +5438,17 @@ function roleCapWarnings(ship) {
 }
 
 // src/selftest.ts
-import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync22, mkdirSync as mkdirSync13, mkdtempSync, readFileSync as readFileSync20, rmSync as rmSync12, writeFileSync as writeFileSync14 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join23 } from "path";
+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";
 
 // src/agent.ts
-import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
-import { readFileSync as readFileSync19, existsSync as existsSync21, statSync as statSync7, mkdirSync as mkdirSync12, writeFileSync as writeFileSync13, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
+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 { StringDecoder } from "string_decoder";
 import { finished } from "stream/promises";
-import { join as join22, dirname as dirname8, basename as basename7 } from "path";
+import { join as join23, dirname as dirname8, basename as basename8 } from "path";
 import { createHash as createHash4 } from "crypto";
 
 // src/state.ts
@@ -9457,6 +9477,13 @@ function skillMarkerWarnings(promptsDir, personaPrompts) {
   return out;
 }
 
+// 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 { promisify } from "util";
+
 // src/run-limit.ts
 var DEFAULT_MAX_RUN_MINUTES = 240;
 var KILL_GRACE_MS = 5e3;
@@ -9506,6 +9533,186 @@ function runKilledComment(b) {
 The agent run on this ticket was stopped at its wall-clock limit of ${b.limitMinutes} minutes before it handed on${b.branch ? `; its branch is \`${b.branch}\`` : ""}. ${tree} The worktree is left as it was. The next run on this seat resumes from it rather than starting over.`;
 }
 
+// src/runner.ts
+var execFileP = promisify(execFile);
+var DEFAULT_SANDBOX_CONFIG = {
+  bin: "openshell",
+  mirrorDir: "/cache",
+  workDir: "/sandbox/work"
+};
+var SANDBOX_STDIN_LIMIT = 4 * 1024 * 1024 - 64 * 1024;
+var SANDBOX_PROMPT_PATH = "/sandbox/prompt.txt";
+var HostRunner = class {
+  kind = "host";
+  start(plan, o) {
+    const child = spawn2(plan.bin, plan.args, {
+      cwd: plan.cwd,
+      env: o.env,
+      stdio: ["pipe", o.streamFd, "inherit"],
+      detached: true
+    });
+    return { child, handle: { runner: "host", pid: child.pid } };
+  }
+  async kill(handle) {
+    if (handle.pid !== void 0) await killRunGroup(handle.pid);
+  }
+  isAlive(handle) {
+    if (handle.pid === void 0) return false;
+    try {
+      process.kill(handle.pid, 0);
+      return true;
+    } catch (e) {
+      return e.code === "EPERM";
+    }
+  }
+  reattach(meta) {
+    return { runner: "host", pid: meta.pid };
+  }
+  async release() {
+  }
+};
+function shQuote2(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function sandboxName(plan, now = Date.now()) {
+  const base = [plan.route, plan.role, plan.ticket ?? ""].join("-").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `crew-${base.slice(0, 36)}-${now.toString(36)}`.replace(/-+/g, "-");
+}
+var SandboxRunner = class {
+  kind = "sandbox";
+  cfg;
+  /** Injected for tests; the real one reads the plan's checkout. */
+  originOf;
+  constructor(cfg = {}, originOf = gitOrigin) {
+    this.cfg = { ...DEFAULT_SANDBOX_CONFIG, ...cfg };
+    this.originOf = originOf;
+  }
+  os(args, o = {}) {
+    return execFileP(this.cfg.bin, args, { env: o.env ?? process.env, maxBuffer: 16 * 1024 * 1024 });
+  }
+  async start(plan, o) {
+    const origin = this.originOf(plan.cwd);
+    if (!origin) throw new Error(`cannot find the origin remote of ${plan.cwd}, so there is nothing to clone into the sandbox`);
+    const repoName = basename7(origin).replace(/\.git$/, "");
+    const name = sandboxName(plan);
+    const { cfg } = this;
+    const secretKeys = Object.keys(plan.setEnv);
+    if (cfg.forgeTokenVar && o.env[cfg.forgeTokenVar] !== void 0 && !secretKeys.includes(cfg.forgeTokenVar)) secretKeys.push(cfg.forgeTokenVar);
+    const createEnv = { ...process.env, ...plan.setEnv };
+    if (cfg.forgeTokenVar && o.env[cfg.forgeTokenVar] !== void 0) createEnv[cfg.forgeTokenVar] = o.env[cfg.forgeTokenVar];
+    const create2 = ["sandbox", "create", "--name", name, "--detach"];
+    if (cfg.policy) create2.push("--policy", cfg.policy);
+    if (cfg.image) create2.push("--from", cfg.image);
+    if (cfg.cacheVolume) {
+      create2.push("--driver-config-json", JSON.stringify({
+        docker: { mounts: [{ type: "volume", source: cfg.cacheVolume, target: cfg.mirrorDir, read_only: true }] }
+      }));
+    }
+    for (const k of secretKeys) create2.push("--env-from", k);
+    const maxSeconds = Math.max(60, Math.ceil((plan.maxRunMinutes ?? 0) * 60) + 600);
+    create2.push("--", "sleep", String(plan.maxRunMinutes ? maxSeconds : 86400));
+    const t0 = Date.now();
+    try {
+      await this.os(create2, { env: createEnv });
+    } catch (e) {
+      await this.deleteQuietly(name);
+      throw new Error(`openshell could not create the sandbox: ${describeExecError(e)}`);
+    }
+    o.emit.emit(`sandbox_created: ${name}`, { role: plan.role, data: { event: "sandbox_created", sandbox: name, ms: Date.now() - t0 } });
+    const handle = { runner: "sandbox", sandbox: name, sandboxBin: cfg.bin };
+    try {
+      const branch = `crew-run-${name.slice(-8)}`;
+      const clone = [
+        `git clone --quiet --shared ${shQuote2(`${cfg.mirrorDir}/${repoName}.git`)} ${shQuote2(cfg.workDir)}`,
+        `cd ${shQuote2(cfg.workDir)}`,
+        `git remote set-url origin ${shQuote2(origin)}`,
+        `git checkout --quiet -b ${shQuote2(branch)}`
+      ].join(" && ");
+      await this.os(["sandbox", "exec", "-n", name, "--no-login-shell", "--", "sh", "-c", clone]);
+      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-"));
+        try {
+          const file = join22(tmp, "prompt.txt");
+          writeFileSync13(file, plan.prompt, { mode: 384 });
+          await this.os(["sandbox", "upload", name, file, SANDBOX_PROMPT_PATH]);
+        } finally {
+          rmSync12(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], {
+        env: process.env,
+        stdio: ["pipe", o.streamFd, "inherit"],
+        detached: true
+      });
+      return { child, handle: { ...handle, pid: child.pid }, ...viaUpload ? { promptDelivered: true } : {} };
+    } catch (e) {
+      await this.release(handle, o.emit);
+      throw new Error(`could not prepare the sandbox ${name}: ${describeExecError(e)}`);
+    }
+  }
+  async kill(handle) {
+    if (handle.sandbox) await this.deleteQuietly(handle.sandbox, handle.sandboxBin);
+    if (handle.pid !== void 0) await killRunGroup(handle.pid, { graceMs: 2e3 });
+  }
+  isAlive(handle) {
+    return new HostRunner().isAlive(handle);
+  }
+  reattach(meta) {
+    return { runner: "sandbox", pid: meta.pid, sandbox: meta.sandbox, sandboxBin: meta.sandboxBin };
+  }
+  async release(handle, emit) {
+    if (!handle.sandbox) return;
+    const t0 = Date.now();
+    await this.deleteQuietly(handle.sandbox, handle.sandboxBin);
+    emit.emit(`sandbox_deleted: ${handle.sandbox}`, { data: { event: "sandbox_deleted", sandbox: handle.sandbox, ms: Date.now() - t0 } });
+  }
+  async deleteQuietly(name, bin = this.cfg.bin) {
+    try {
+      await execFileP(bin, ["sandbox", "delete", name], { timeout: 6e4 });
+    } catch {
+    }
+  }
+};
+function describeExecError(e) {
+  const err3 = e;
+  return (err3.stderr?.trim() || err3.message || String(e)).split("\n").slice(-3).join(" / ");
+}
+function gitOrigin(cwd) {
+  try {
+    return execFileSync5("git", ["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+function runnerFor(kind, sandbox) {
+  return kind === "sandbox" ? new SandboxRunner(sandbox) : new HostRunner();
+}
+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 })) {
+  const bin = cfg.bin ?? DEFAULT_SANDBOX_CONFIG.bin;
+  let version;
+  try {
+    version = run2(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"]);
+  } catch (e) {
+    const err3 = e;
+    return {
+      ok: false,
+      detail: `${version}: the gateway does not answer (${(err3.stderr || err3.message).trim().split("\n").filter(Boolean).slice(0, 2).join(" / ")}). Start it; on Docker Desktop its docker section needs supervisor_network_mode = "bridge", and allow_driver_config = true for the cache volume mount.`
+    };
+  }
+  return { ok: true, detail: version };
+}
+
 // src/agent.ts
 var DIGEST_MAX_AGE_SECONDS = 600;
 var LEGACY_TOOLCHAIN_HARNESS = "claude";
@@ -9556,13 +9763,13 @@ function streamShowsAllowanceRefusal(streamPath) {
   }
   return false;
 }
-var digestPathFor = (stateDir, routeLabel, role, runId) => join22(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPathFor = (stateDir, routeLabel, role, runId) => join23(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
 function planAgentRun(o) {
-  const briefPath = join22(o.route.promptsDir, "personas", `lane-${o.role}.md`);
+  const briefPath = join23(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 = join22(o.route.promptsDir, "personas", "common.md");
+  const commonPath = join23(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);
@@ -9597,7 +9804,7 @@ function planAgentRun(o) {
     digest
   });
   const promptSha = createHash4("sha256").update(expanded.text).digest("hex");
-  const streamsDir = join22(o.stateDir, "streams");
+  const streamsDir = join23(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;
@@ -9658,6 +9865,7 @@ function planAgentRun(o) {
     workspaceAuth: toolchain.auth === "workspace",
     provider: toolchainProvider(toolchain),
     maxRunMinutes: resolveMaxRunMinutes(o.route.maxRunMinutes, toolchain.maxRunMinutes),
+    ...o.ship.runner === "sandbox" ? { runner: "sandbox", ...o.ship.sandbox ? { sandboxConfig: o.ship.sandbox } : {} } : {},
     resolution: { toolchain: seat.toolchainWhy, model: seat.modelWhy },
     warnings: [...seat.warnings ?? [], ...expanded.warnings],
     prompt,
@@ -9682,8 +9890,8 @@ function planAgentRun(o) {
     digestAttached: digest !== void 0,
     digestAgeSeconds: ageSeconds,
     model,
-    streamPath: join22(streamsDir, `${base}.jsonl`),
-    eventsPath: join22(streamsDir, `${base}.events.jsonl`),
+    streamPath: join23(streamsDir, `${base}.jsonl`),
+    eventsPath: join23(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
     ticketRecordId: o.ticketRecordId ?? null,
     repo: o.repo ?? null,
@@ -9747,7 +9955,7 @@ function identityOf(plan, adapterHarness) {
     promptSha: plan.promptSha
   };
 }
-async function killForDeadline(pid, emit, role, ticket, spawnedAt, limitMinutes) {
+async function killForDeadline(kill, pid, emit, role, ticket, spawnedAt, limitMinutes) {
   const elapsedMs = Date.now() - Date.parse(spawnedAt);
   const limit = limitMinutes ?? Math.round(elapsedMs / 6e4);
   emit.emit(`run_killed: ${role} run exceeded its wall-clock limit of ${limit} min (ran ${Math.round(elapsedMs / 6e4)} min)`, {
@@ -9755,7 +9963,7 @@ async function killForDeadline(pid, emit, role, ticket, spawnedAt, limitMinutes)
     ...ticket ? { ticket } : {},
     data: { event: "run_killed", reason: WALL_CLOCK_REASON, limitMinutes: limit, elapsedMs, pid }
   });
-  await killRunGroup(pid);
+  await kill();
   return { limitMinutes: limit, elapsedMs };
 }
 var withoutKey = ({ apiKey: _apiKey, ...rest }) => rest;
@@ -9943,7 +10151,7 @@ var RunObserver = class {
 };
 function writeRunMeta(id, startedAt, liveTicket, extra) {
   try {
-    writeFileSync13(`${id.streamPath}.meta.json`, JSON.stringify({
+    writeFileSync14(`${id.streamPath}.meta.json`, JSON.stringify({
       route: id.route,
       role: id.role,
       hint: id.ticket,
@@ -10050,7 +10258,7 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey, hintMoved)
       if (sent.counterWarning) emit.warn(sent.counterWarning, { step: "agent" });
       if (sent.counterRetry) {
         try {
-          queueTicketCounters(stateDirOfStream(id.streamPath), basename7(id.streamPath, ".jsonl"), {
+          queueTicketCounters(stateDirOfStream(id.streamPath), basename8(id.streamPath, ".jsonl"), {
             version: 1,
             route: id.route,
             role: id.role,
@@ -10065,7 +10273,7 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey, hintMoved)
     } catch (e) {
       if (e instanceof AgentLogUnreachableError) {
         try {
-          queueAgentRun(stateDirOfStream(id.streamPath), basename7(id.streamPath, ".jsonl"), {
+          queueAgentRun(stateDirOfStream(id.streamPath), basename8(id.streamPath, ".jsonl"), {
             version: 1,
             route: id.route,
             role: id.role,
@@ -10095,102 +10303,125 @@ async function finishRun(id, obs, emit, startedAt, end, agentLogKey, hintMoved)
 }
 function spawnAgent(plan, emit, hintMoved) {
   const adapter = adapterFor(plan.harness ?? LEGACY_TOOLCHAIN_HARNESS);
+  const runner = runnerFor(plan.runner, plan.sandboxConfig);
   const started = Date.now();
   const startedAt = new Date(started).toISOString();
   for (const w of plan.warnings ?? []) emit.warn(w, { step: "agent", role: plan.role });
   const eventsSink = openSink(plan.eventsPath);
   const id = identityOf(plan, adapter.harness);
-  return new Promise((resolve7, reject) => {
-    let streamFd;
-    try {
-      mkdirSync12(dirname8(plan.streamPath), { recursive: true });
-      streamFd = openSync3(plan.streamPath, "a");
-    } catch (e) {
-      void endSink(eventsSink);
-      reject(new AgentSpawnError(`cannot open the stream file ${plan.streamPath}: ${e.message}`));
-      return;
-    }
-    const child = spawn2(plan.bin, plan.args, {
-      cwd: plan.cwd,
-      env: { ...scrubbedEnv(process.env, adapter.harness), ...plan.setEnv },
-      stdio: ["pipe", streamFd, "inherit"],
-      detached: true
-    });
+  let streamFd;
+  try {
+    mkdirSync12(dirname8(plan.streamPath), { recursive: true });
+    streamFd = openSync3(plan.streamPath, "a");
+  } catch (e) {
+    void endSink(eventsSink);
+    return Promise.reject(new AgentSpawnError(`cannot open the stream file ${plan.streamPath}: ${e.message}`));
+  }
+  const failed = (e) => {
+    void endSink(eventsSink);
+    return Promise.reject(new AgentSpawnError(`cannot run ${plan.bin}: ${e.message}`));
+  };
+  let begun;
+  try {
+    begun = runner.start(plan, { env: { ...scrubbedEnv(process.env, adapter.harness), ...plan.setEnv }, streamFd, emit });
+  } catch (e) {
     closeSync3(streamFd);
-    const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const deadline = deadlineFor(spawnedAt, plan.maxRunMinutes);
-    if (child.pid !== void 0) {
-      const sidecar = {
-        pid: child.pid,
-        ownerPid: process.pid,
-        spawnedAt,
-        role: plan.role,
-        route: plan.route,
-        ...deadline ? { deadline, maxRunMinutes: plan.maxRunMinutes } : {},
-        ticket: plan.ticket ?? null,
-        ticketRecordId: plan.ticketRecordId ?? null,
-        repo: plan.repo ?? null,
-        routeName: plan.routeName,
-        model: plan.model,
-        toolchain: id.toolchain,
-        harness: id.harness,
-        provider: id.provider,
-        eventsPath: plan.eventsPath,
-        agentLog: id.agentLog,
-        promptVersion: plan.promptVersion,
-        promptSha: plan.promptSha
-      };
-      try {
-        writeFileSync13(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
-      } catch {
+    return failed(e);
+  }
+  if (begun instanceof Promise) {
+    return begun.then(
+      (run2) => {
+        closeSync3(streamFd);
+        return supervise(run2);
+      },
+      (e) => {
+        closeSync3(streamFd);
+        return failed(e);
       }
-    }
-    const obs = new RunObserver(id, adapter, eventsSink, emit.cycle);
-    const meta = { pid: child.pid ?? null, ...deadline ? { deadline } : {} };
-    obs.onClaim = () => writeRunMeta(id, startedAt, obs.liveTicket, meta);
-    if (child.pid !== void 0) writeRunMeta(id, startedAt, obs.liveTicket, meta);
-    const tail3 = new FileTail(plan.streamPath);
-    const timer = setInterval(() => obs.feed(tail3.poll()), TAIL_POLL_MS);
-    let killed;
-    const limitTimer = child.pid !== void 0 && deadline ? setTimeout(() => {
-      const pid = child.pid;
-      void killForDeadline(pid, emit, plan.role, obs.liveTicket ?? plan.ticket ?? null, spawnedAt, plan.maxRunMinutes).then((k) => {
-        killed = k;
-      });
-    }, Math.max(0, msUntilDeadline(deadline) ?? 0)) : void 0;
-    let spawnFailed = false;
-    child.on("error", (err3) => {
-      spawnFailed = true;
-      clearInterval(timer);
-      clearTimeout(limitTimer);
-      reject(new AgentSpawnError(`cannot run ${plan.bin}: ${err3.message}`));
-    });
-    child.on("close", async (code) => {
-      clearInterval(timer);
-      clearTimeout(limitTimer);
-      obs.feed(tail3.poll());
-      obs.end();
-      await endSink(eventsSink);
-      if (spawnFailed) return;
-      if (limitTimer && !killed && !obs.sawResult && msUntilDeadline(deadline) <= 0) {
-        killed = { limitMinutes: plan.maxRunMinutes ?? 0, elapsedMs: Date.now() - Date.parse(spawnedAt) };
+    );
+  }
+  closeSync3(streamFd);
+  return supervise(begun);
+  function supervise({ child, handle, promptDelivered }) {
+    return new Promise((resolve7, reject) => {
+      const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const deadline = deadlineFor(spawnedAt, plan.maxRunMinutes);
+      if (child.pid !== void 0) {
+        const sidecar = {
+          pid: child.pid,
+          ownerPid: process.pid,
+          spawnedAt,
+          role: plan.role,
+          route: plan.route,
+          ...deadline ? { deadline, maxRunMinutes: plan.maxRunMinutes } : {},
+          ...handle.runner === "sandbox" ? { runner: "sandbox", sandbox: handle.sandbox, sandboxBin: handle.sandboxBin } : {},
+          ticket: plan.ticket ?? null,
+          ticketRecordId: plan.ticketRecordId ?? null,
+          repo: plan.repo ?? null,
+          routeName: plan.routeName,
+          model: plan.model,
+          toolchain: id.toolchain,
+          harness: id.harness,
+          provider: id.provider,
+          eventsPath: plan.eventsPath,
+          agentLog: id.agentLog,
+          promptVersion: plan.promptVersion,
+          promptSha: plan.promptSha
+        };
+        try {
+          writeFileSync14(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
+        } catch {
+        }
       }
-      const { ms: ms3, handoffPending } = await finishRun(
-        id,
-        obs,
-        emit,
-        startedAt,
-        { code: code ?? 1, ...killed ? { interrupted: WALL_CLOCK_REASON } : {} },
-        plan.agentLog?.apiKey,
-        hintMoved
-      );
-      resolve7({ code: code ?? 1, ms: ms3, ...handoffPending ? { handoffPending } : {}, ...killed ? { killed } : {} });
-    });
-    child.stdin?.on("error", (err3) => {
-      emit.warn(`agent closed stdin before the prompt was delivered: ${err3.message}`, { step: "agent" });
+      const obs = new RunObserver(id, adapter, eventsSink, emit.cycle);
+      const meta = { pid: child.pid ?? null, ...deadline ? { deadline } : {} };
+      obs.onClaim = () => writeRunMeta(id, startedAt, obs.liveTicket, meta);
+      if (child.pid !== void 0) writeRunMeta(id, startedAt, obs.liveTicket, meta);
+      const tail3 = new FileTail(plan.streamPath);
+      const timer = setInterval(() => obs.feed(tail3.poll()), TAIL_POLL_MS);
+      let killed;
+      const limitTimer = child.pid !== void 0 && deadline ? setTimeout(() => {
+        void killForDeadline(() => runner.kill(handle, WALL_CLOCK_REASON), child.pid, emit, plan.role, obs.liveTicket ?? plan.ticket ?? null, spawnedAt, plan.maxRunMinutes).then((k) => {
+          killed = k;
+        });
+      }, Math.max(0, msUntilDeadline(deadline) ?? 0)) : void 0;
+      let spawnFailed = false;
+      child.on("error", (err3) => {
+        spawnFailed = true;
+        clearInterval(timer);
+        clearTimeout(limitTimer);
+        void runner.release(handle, emit);
+        reject(new AgentSpawnError(`cannot run ${plan.bin}: ${err3.message}`));
+      });
+      child.on("close", async (code) => {
+        clearInterval(timer);
+        clearTimeout(limitTimer);
+        obs.feed(tail3.poll());
+        obs.end();
+        await endSink(eventsSink);
+        if (spawnFailed) return;
+        await runner.release(handle, emit);
+        if (limitTimer && !killed && !obs.sawResult && msUntilDeadline(deadline) <= 0) {
+          killed = { limitMinutes: plan.maxRunMinutes ?? 0, elapsedMs: Date.now() - Date.parse(spawnedAt) };
+        }
+        const { ms: ms3, handoffPending } = await finishRun(
+          id,
+          obs,
+          emit,
+          startedAt,
+          { code: code ?? 1, ...killed ? { interrupted: WALL_CLOCK_REASON } : {} },
+          plan.agentLog?.apiKey,
+          hintMoved
+        );
+        resolve7({ code: code ?? 1, ms: ms3, ...handoffPending ? { handoffPending } : {}, ...killed ? { killed } : {} });
+      });
+      child.stdin?.on("error", (err3) => {
+        emit.warn(`agent closed stdin before the prompt was delivered: ${err3.message}`, { step: "agent" });
+      });
+      if (promptDelivered) child.stdin?.end();
+      else child.stdin?.end(plan.prompt);
     });
-    child.stdin?.end(plan.prompt);
-  });
+  }
 }
 async function reattachRun(streamPath, sc, emit, o = {}) {
   const adapter = adapterFor(sc.harness);
@@ -10202,6 +10433,7 @@ async function reattachRun(streamPath, sc, emit, o = {}) {
   obs.muted = true;
   obs.feed(tail3.poll());
   obs.muted = false;
+  const runner = runnerOfSidecar(sc);
   const adopted = isAlive(sc);
   let killed;
   if (adopted) {
@@ -10210,7 +10442,7 @@ async function reattachRun(streamPath, sc, emit, o = {}) {
     while (isAlive(sc)) {
       obs.feed(tail3.poll());
       if (!killed && (msUntilDeadline(sc.deadline) ?? 1) <= 0) {
-        killed = await killForDeadline(sc.pid, emit, sc.role, obs.liveTicket ?? sc.ticket, sc.spawnedAt, sc.maxRunMinutes);
+        killed = await killForDeadline(() => runner.kill(runner.reattach(sc), WALL_CLOCK_REASON), sc.pid, emit, sc.role, obs.liveTicket ?? sc.ticket, sc.spawnedAt, sc.maxRunMinutes);
         continue;
       }
       await new Promise((r) => setTimeout(r, pollMs));
@@ -10219,6 +10451,7 @@ async function reattachRun(streamPath, sc, emit, o = {}) {
   obs.feed(tail3.poll());
   obs.end();
   await endSink(eventsSink);
+  await runner.release(runner.reattach(sc), emit);
   const interrupted = killed ? WALL_CLOCK_REASON : obs.sawResult ? void 0 : adopted ? "no-result" : "daemon-exit";
   const { ms: ms3, ticket } = await finishRun(
     id,
@@ -10528,7 +10761,7 @@ var realDeps = {
         resolve7(r);
       }
     };
-    const child = spawn3(o.bin, o.args, { cwd: o.cwd, env: o.env, stdio: ["pipe", "pipe", "pipe"], detached: true });
+    const child = spawn4(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");
@@ -10673,7 +10906,7 @@ async function runSelftest(i, deps = realDeps) {
     ...adapter.runEnv(spec),
     [KEY_VAR]: i.apiKey
   };
-  const cwd = mkdtempSync(join23(tmpdir2(), "crew-selftest-"));
+  const cwd = mkdtempSync2(join24(tmpdir3(), "crew-selftest-"));
   try {
     const run2 = await deps.run({
       bin: invocation.bin,
@@ -10695,7 +10928,7 @@ async function runSelftest(i, deps = realDeps) {
     return finish({ ok: false, failure, detail, ...usage2 });
   } finally {
     try {
-      rmSync12(cwd, { recursive: true, force: true });
+      rmSync13(cwd, { recursive: true, force: true });
     } catch {
     }
   }
@@ -10706,7 +10939,7 @@ 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) => join23(stateDir, "selftest.json");
+var fileFor2 = (stateDir) => join24(stateDir, "selftest.json");
 function readSelftest(stateDir) {
   try {
     const p = fileFor2(stateDir);
@@ -10719,7 +10952,7 @@ function recordSelftest(stateDir, results) {
   const all = readSelftest(stateDir);
   for (const r of results) all[r.toolchain] = r;
   mkdirSync13(stateDir, { recursive: true });
-  writeFileSync14(fileFor2(stateDir), `${JSON.stringify(all, null, 2)}
+  writeFileSync15(fileFor2(stateDir), `${JSON.stringify(all, null, 2)}
 `);
 }
 function doctorSelftestLines(stored, toolchains) {
@@ -10731,7 +10964,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve6, dirname as dirname25, join as join47, basename as basename14 } from "path";
+import { resolve as resolve6, dirname as dirname25, join as join48, 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";
@@ -10928,10 +11161,10 @@ function rosterMarkdown(roster, meId) {
 }
 
 // src/connect-resume.ts
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync21, rmSync as rmSync13, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname9, join as join24 } from "path";
+import { mkdirSync as mkdirSync14, readFileSync as readFileSync21, rmSync as rmSync14, writeFileSync as writeFileSync16 } from "fs";
+import { dirname as dirname9, join as join25 } from "path";
 function lastSessionFile(stateDir) {
-  return join24(stateDir, "connect-session.json");
+  return join25(stateDir, "connect-session.json");
 }
 function readPointers(stateDir) {
   try {
@@ -10950,7 +11183,7 @@ function readPointers(stateDir) {
 function writePointers(stateDir, pointers) {
   const file = lastSessionFile(stateDir);
   mkdirSync14(dirname9(file), { recursive: true });
-  writeFileSync15(file, `${JSON.stringify(pointers, null, 2)}
+  writeFileSync16(file, `${JSON.stringify(pointers, null, 2)}
 `, { mode: 384 });
 }
 function rememberSession(stateDir, host, workspaceSlug) {
@@ -10967,7 +11200,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 rmSync13(lastSessionFile(stateDir), { force: true });
+    else rmSync14(lastSessionFile(stateDir), { force: true });
   } catch {
   }
 }
@@ -11007,7 +11240,7 @@ function forgetSession(stateDir, host) {
   try {
     const { [host]: _gone, ...rest } = readPointers(stateDir);
     if (Object.keys(rest).length) writePointers(stateDir, rest);
-    else rmSync13(lastSessionFile(stateDir), { force: true });
+    else rmSync14(lastSessionFile(stateDir), { force: true });
   } catch {
   }
 }
@@ -11035,11 +11268,11 @@ async function signOutSessions(o) {
 }
 
 // src/reset.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync15, readFileSync as readFileSync22, readdirSync as readdirSync9, rmSync as rmSync14, statSync as statSync8, writeFileSync as writeFileSync16 } from "fs";
-import { dirname as dirname10, join as join25 } from "path";
+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 { hostFromUrl as hostFromUrl3 } from "@tablation/client";
 function clonedCheckoutsFile(stateDir) {
-  return join25(stateDir, "cloned-checkouts.json");
+  return join26(stateDir, "cloned-checkouts.json");
 }
 function readClonedCheckouts(stateDir) {
   try {
@@ -11054,7 +11287,7 @@ function recordClonedCheckout(stateDir, dir) {
   if (known.includes(dir)) return;
   const file = clonedCheckoutsFile(stateDir);
   mkdirSync15(dirname10(file), { recursive: true });
-  writeFileSync16(file, `${JSON.stringify([...known, dir], null, 2)}
+  writeFileSync17(file, `${JSON.stringify([...known, dir], null, 2)}
 `);
 }
 var mark = (dryRun) => dryRun ? "would-remove" : "removed";
@@ -11109,7 +11342,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) rmSync14(o.configFile, { force: true });
+    if (!o.dryRun) rmSync15(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" });
@@ -11125,21 +11358,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) rmSync14(dir, { recursive: true, force: true });
+  if (!dryRun) rmSync15(dir, { recursive: true, force: true });
   return { step: "checkout", target: dir, action: mark(dryRun) };
 }
 function removeState(stateDir, dryRun) {
   const out = [];
-  const targets = [join25(stateDir, "resolved"), join25(stateDir, "keys"), clonedCheckoutsFile(stateDir), join25(stateDir, "connect-session.json"), join25(stateDir, "reload-requested"), join25(stateDir, "daemon.started")];
+  const targets = [join26(stateDir, "resolved"), join26(stateDir, "keys"), clonedCheckoutsFile(stateDir), join26(stateDir, "connect-session.json"), join26(stateDir, "reload-requested"), join26(stateDir, "daemon.started")];
   try {
     for (const name of readdirSync9(stateDir)) {
-      if (name.startsWith(".") && statSync8(join25(stateDir, name)).isFile()) targets.push(join25(stateDir, name));
+      if (name.startsWith(".") && statSync8(join26(stateDir, name)).isFile()) targets.push(join26(stateDir, name));
     }
   } catch {
   }
   for (const t of targets) {
     if (!existsSync23(t)) continue;
-    if (!dryRun) rmSync14(t, { recursive: true, force: true });
+    if (!dryRun) rmSync15(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" });
@@ -11153,7 +11386,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) rmSync14(join25(stateDir, n), { recursive: true, force: true });
+  if (!dryRun) for (const n of names) rmSync15(join26(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) {
@@ -11239,7 +11472,7 @@ 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 join26 } from "path";
+import { join as join27 } 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.";
@@ -11266,13 +11499,13 @@ function runFinished(streamPath) {
   }
 }
 function orphanedStreams(o) {
-  const dir = join26(o.stateDir, "streams");
+  const dir = join27(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 = join26(dir, name);
+    const streamPath = join27(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || sidecar.route !== o.routeLabel) continue;
@@ -11326,14 +11559,14 @@ async function reconcileRuns(o) {
 
 // src/live-runs.ts
 import { existsSync as existsSync25, readdirSync as readdirSync11 } from "fs";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function liveRuns(stateDir, isAlive = runIsAlive) {
-  const dir = join27(stateDir, "streams");
+  const dir = join28(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 = join27(dir, name);
+    const streamPath = join28(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || !isAlive(sidecar)) continue;
@@ -11395,11 +11628,11 @@ function describeRun(run2, route2, seatIds, worktreeOf = (d, n) => {
 }
 
 // src/passenger-containers.ts
-import { execFileSync as execFileSync5 } from "child_process";
+import { execFileSync as execFileSync6 } from "child_process";
 import { createHash as createHash5 } from "crypto";
 var realExec = (cmd, args, opts) => {
   try {
-    return execFileSync5(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: opts?.timeoutMs });
+    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(" / ");
@@ -11708,9 +11941,9 @@ function realDeprovisionDeps(cfg, emit, crewHome, getStore) {
 }
 
 // src/pool-member.ts
-import { mkdirSync as mkdirSync16, readFileSync as readFileSync24, renameSync as renameSync3, writeFileSync as writeFileSync17 } from "fs";
+import { mkdirSync as mkdirSync16, readFileSync as readFileSync24, renameSync as renameSync3, writeFileSync as writeFileSync18 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname11, join as join28 } from "path";
+import { dirname as dirname11, join as join29 } from "path";
 var POOL_EXIT = { ok: 0, failed: 1, credential: 2 };
 function backoffMs(attempt) {
   return Math.min(6e4, 5e3 * 2 ** Math.max(0, attempt));
@@ -11899,10 +12132,10 @@ async function runPoolMember(deps) {
   }
 }
 function defaultMemberDir(env = process.env) {
-  return env.CREW_POOL_DIR ?? join28(env.XDG_STATE_HOME ?? join28(homedir8(), ".local", "state"), "crew-pool-member");
+  return env.CREW_POOL_DIR ?? join29(env.XDG_STATE_HOME ?? join29(homedir8(), ".local", "state"), "crew-pool-member");
 }
 function fileMemberStore(dir) {
-  const file = join28(dir, "member.json");
+  const file = join29(dir, "member.json");
   return {
     read() {
       try {
@@ -11914,7 +12147,7 @@ function fileMemberStore(dir) {
     write(f) {
       mkdirSync16(dirname11(file), { recursive: true, mode: 448 });
       const tmp = `${file}.tmp`;
-      writeFileSync17(tmp, `${JSON.stringify(f)}
+      writeFileSync18(tmp, `${JSON.stringify(f)}
 `, { mode: 384 });
       renameSync3(tmp, file);
     }
@@ -11970,18 +12203,18 @@ import { existsSync as existsSync30 } from "fs";
 import { hostname as hostname3 } from "os";
 
 // src/machine-id.ts
-import { execFileSync as execFileSync6 } from "child_process";
+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 writeFileSync18 } from "fs";
-import { dirname as dirname12, join as join29 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync17, readFileSync as readFileSync25, writeFileSync as writeFileSync19 } from "fs";
+import { dirname as dirname12, join as join30 } from "path";
 function machineIdPathFor(stateDir) {
-  return join29(stateDir, "machine-id");
+  return join30(stateDir, "machine-id");
 }
 var sha256 = (s) => createHash6("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
   try {
     if (platform2 === "darwin") {
-      const out = execFileSync6("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+      const out = execFileSync7("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"]
       });
@@ -12008,7 +12241,7 @@ function ensureMachineId(stateDir, opts = {}) {
   if (!raw) return void 0;
   const hashed = sha256(raw);
   mkdirSync17(dirname12(path), { recursive: true });
-  writeFileSync18(path, `${hashed}
+  writeFileSync19(path, `${hashed}
 `, { mode: 384 });
   return hashed;
 }
@@ -12021,7 +12254,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 writeFileSync19 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync26, writeFileSync as writeFileSync20 } from "fs";
 import { hostname as hostname2 } from "os";
 import { parseDocument as parseDocument3 } from "yaml";
 
@@ -12030,7 +12263,7 @@ import { parseDocument as parseDocument2 } from "yaml";
 
 // src/repos-cmd.ts
 import { homedir as homedir9 } from "os";
-import { basename as basename8, join as join30, resolve as resolve3 } from "path";
+import { basename as basename9, join as join31, resolve as resolve3 } from "path";
 import { isMap, isSeq, parseDocument, stringify } from "yaml";
 var ReposError = class extends Error {
 };
@@ -12102,7 +12335,7 @@ function configuredRepos(text2, route2, base) {
     });
   }
   const dir = m.get("dir");
-  return dir ? [{ name: basename8(String(dir)), dir: expandDir(String(dir), base) }] : [];
+  return dir ? [{ name: basename9(String(dir)), dir: expandDir(String(dir), base) }] : [];
 }
 function cloneBaseOf(text2, route2, base, isCheckout) {
   const m = routeMapOf(parseDocument(text2), route2);
@@ -12191,7 +12424,7 @@ function planRepoAdd(i) {
     throw new ReposError(`${target} is already configured on route ${i.route}`);
   }
   const matched = matchRepoName(i.origin, i.resolved);
-  const name = matched ?? i.name ?? normalizeRemote(i.origin)?.split("/").pop() ?? basename8(target);
+  const name = matched ?? i.name ?? normalizeRemote(i.origin)?.split("/").pop() ?? basename9(target);
   let warning;
   if (!matched) {
     const known = Object.values(i.resolved?.repoNames ?? {});
@@ -12308,7 +12541,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) : join30(expandDir(basePath, i.base), i.route.split("/")[0], name);
+  const target = i.dir ? expandDir(i.dir, i.base) : join31(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 } : {} };
@@ -12587,7 +12820,7 @@ function realProvisionDeps(crewHome) {
       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;
-      writeFileSync19(file, planEnable(text2, route2));
+      writeFileSync20(file, planEnable(text2, route2));
       return true;
     },
     installState() {
@@ -12634,7 +12867,7 @@ function realProvisionDeps(crewHome) {
       const doc = parseDocument3(readFileSync26(file, "utf8"));
       if (doc.getIn(["ship", key]) === value2) return false;
       doc.setIn(["ship", key], value2);
-      writeFileSync19(file, doc.toString());
+      writeFileSync20(file, doc.toString());
       return true;
     },
     storedToken(host) {
@@ -12650,12 +12883,12 @@ host=${host}
 }
 
 // src/tunnel.ts
-import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync29, mkdirSync as mkdirSync18, readFileSync as readFileSync27, writeFileSync as writeFileSync20, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
+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 { randomInt } from "crypto";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
-var defaultSpawn = (cmd, args) => spawn4(cmd, args, DEFAULT_SPAWN_OPTIONS);
+var defaultSpawn = (cmd, args) => spawn5(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
 var SLUG_LENGTH = 12;
 function generateTunnelSlug() {
@@ -12725,7 +12958,7 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join31(stateDir, "passengers", `${workspaceId}.json`);
+  return join32(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
@@ -12738,8 +12971,8 @@ function readPersistedTunnel(stateDir, workspaceId) {
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync18(join31(stateDir, "passengers"), { recursive: true });
-  writeFileSync20(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync18(join32(stateDir, "passengers"), { recursive: true });
+  writeFileSync21(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function updatePersistedTunnel(stateDir, workspaceId, patch2) {
@@ -12841,7 +13074,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join31(stateDir, "passengers");
+  const dir = join32(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));
 }
@@ -13708,8 +13941,8 @@ ${waiting.map((t) => `| ${displayKey2(t)} | ${t.status} | ${blockers(t, i)} |`).
 }
 
 // src/poll.ts
-import { writeFileSync as writeFileSync21 } from "fs";
-import { join as join32 } from "path";
+import { writeFileSync as writeFileSync22 } from "fs";
+import { join as join33 } from "path";
 
 // src/stalled.ts
 var STALLED_AFTER_CYCLES = 30;
@@ -14016,7 +14249,7 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route2, role, runId) => join32(stateDir, `digest-${route2}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPath = (stateDir, route2, role, runId) => join33(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));
@@ -14094,7 +14327,7 @@ function writeDigest(o, d, role, stateDir, runId, own) {
 
 ${body}` : body;
     const path = digestPath(stateDir, routeSlug(o.route.route), role, runId);
-    writeFileSync21(path, text2);
+    writeFileSync22(path, text2);
     o.emit.emit(`queue digest written for ${role} (${Buffer.byteLength(text2)} bytes)`, {
       data: { role, bytes: Buffer.byteLength(text2) }
     });
@@ -14202,7 +14435,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 writeFileSync22 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync19, readFileSync as readFileSync28, writeFileSync as writeFileSync23 } from "fs";
 import { dirname as dirname14 } from "path";
 var REFRESH_COOLDOWN_MS = 2 * 6e4;
 var UNSERVABLE_PASSES_BEFORE_ATTENTION = 3;
@@ -14236,7 +14469,7 @@ function persistRepoRows(stateDir, routeName, rows) {
   const raw = JSON.parse(readFileSync28(path, "utf8"));
   applyRepoRows(raw, rows);
   mkdirSync19(dirname14(path), { recursive: true });
-  writeFileSync22(path, `${JSON.stringify(raw, null, 2)}
+  writeFileSync23(path, `${JSON.stringify(raw, null, 2)}
 `);
 }
 async function refreshUnknownRepos(o) {
@@ -14686,8 +14919,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 join33 } from "path";
-import { accessSync as accessSync3, constants as constants3, existsSync as existsSync32, mkdirSync as mkdirSync20, writeFileSync as writeFileSync23 } from "fs";
+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 { stringify as stringify2 } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
 function shouldRunWizard(opts) {
@@ -14709,7 +14942,7 @@ function defaultIsExecutable(p) {
 function findOnPath2(name, pathEnv, isExecutable = defaultIsExecutable) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join33(dir, name);
+    const candidate = join34(dir, name);
     if (isExecutable(candidate)) return candidate;
   }
   return void 0;
@@ -14772,7 +15005,7 @@ ${routeBlock}`;
 function writeNewConfig(path, text2) {
   mkdirSync20(dirname15(path), { recursive: true });
   try {
-    writeFileSync23(path, text2, { mode: 384, flag: "wx" });
+    writeFileSync24(path, text2, { mode: 384, flag: "wx" });
     return true;
   } catch (e) {
     if (e.code === "EEXIST") return false;
@@ -14806,7 +15039,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 join34 } from "path";
+import { dirname as dirname16, join as join35 } from "path";
 import { delimiter as delimiter2 } from "path";
 var CHOICE_EXIT_CODE = 3;
 function createEmitter(json2, write) {
@@ -14845,12 +15078,12 @@ function agentBinSearchDirs(home, pathEnv, extraPath) {
   const dirs = [
     ...pathEnv.split(delimiter2),
     ...(extraPath ?? "").split(delimiter2),
-    join34(home, ".local/bin"),
-    join34(home, ".claude/local"),
+    join35(home, ".local/bin"),
+    join35(home, ".claude/local"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
-    join34(home, ".npm-global/bin"),
-    join34(home, ".volta/bin")
+    join35(home, ".npm-global/bin"),
+    join35(home, ".volta/bin")
   ];
   return [...new Set(dirs.filter(Boolean))];
 }
@@ -14886,9 +15119,9 @@ function flagWizardAnswers(f, env) {
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync29, writeFileSync as writeFileSync24, existsSync as existsSync33, copyFileSync, mkdirSync as mkdirSync21, mkdtempSync as mkdtempSync2, rmSync as rmSync15 } from "fs";
-import { dirname as dirname17, join as join35 } from "path";
-import { tmpdir as tmpdir3 } from "os";
+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";
 
 // src/release.ts
 function describeUnplaceable(unplaceable, verifiedStatus) {
@@ -15628,7 +15861,7 @@ async function bump(o, size) {
     }
     return printed;
   }
-  const files = o.repo.release.versionFiles.map((f) => join35(o.cwd, f));
+  const files = o.repo.release.versionFiles.map((f) => join36(o.cwd, f));
   const first = files[0];
   if (!existsSync33(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
@@ -15653,21 +15886,21 @@ async function bump(o, size) {
       o.emit.error(`no version field in ${f}`);
       return null;
     }
-    writeFileSync24(f, out);
+    writeFileSync25(f, out);
   }
   return version;
 }
 function writeChangelog(o, version, entries) {
   const file = o.repo.release.changelog;
   if (!file || entries.length === 0) return;
-  const path = join35(o.cwd, file);
+  const path = join36(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";
-  writeFileSync24(path, insertChangelogSection(existing, section));
+  writeFileSync25(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
   if (!o.repo.hooks.released) return void 0;
@@ -15750,7 +15983,7 @@ function closeReleaseCheckout(cwd, root, dir, branch, run2 = gitOk) {
     run2(cwd, ["worktree", "remove", "--force", dir]);
   } finally {
     try {
-      rmSync15(root, { recursive: true, force: true });
+      rmSync16(root, { recursive: true, force: true });
     } finally {
       run2(cwd, ["worktree", "prune"]);
       run2(cwd, ["branch", "-D", branch]);
@@ -15760,8 +15993,8 @@ function closeReleaseCheckout(cwd, root, dir, branch, run2 = gitOk) {
 function openReleaseCheckout(o) {
   const { remote, base } = o.repo.branch;
   const branch = `crew/release-${Date.now()}`;
-  const root = mkdtempSync2(join35(tmpdir3(), "crew-release-"));
-  const dir = join35(root, "checkout");
+  const root = mkdtempSync3(join36(tmpdir4(), "crew-release-"));
+  const dir = join36(root, "checkout");
   o.emit.emit(`release checkout: ${dir}`, { step: "release" });
   const close = () => closeReleaseCheckout(o.cwd, root, dir, branch);
   try {
@@ -15771,10 +16004,10 @@ function openReleaseCheckout(o) {
     throw e;
   }
   for (const f of o.repo.worktrees.copy) {
-    const src = join35(o.cwd, f);
+    const src = join36(o.cwd, f);
     if (!existsSync33(src)) continue;
-    mkdirSync21(dirname17(join35(dir, f)), { recursive: true });
-    copyFileSync(src, join35(dir, f));
+    mkdirSync21(dirname17(join36(dir, f)), { recursive: true });
+    copyFileSync(src, join36(dir, f));
   }
   return { dir, branch, close };
 }
@@ -15919,7 +16152,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(tmpdir3());
+  const swept = sweepStaleReleaseRoots(tmpdir4());
   if (swept.length > 0) o.emit.emit(scoped(`removed ${swept.length} stale crew-release-* temp dir(s)`), { step: "release" });
   try {
     checkout = openReleaseCheckout(o);
@@ -17092,7 +17325,7 @@ function nextRoles(decision, ran) {
 }
 
 // src/ship-name.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync30, renameSync as renameSync4, writeFileSync as writeFileSync25 } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync30, renameSync as renameSync4, writeFileSync as writeFileSync26 } from "fs";
 import { dirname as dirname18 } from "path";
 import { parseDocument as parseDocument5 } from "yaml";
 var ShipNameError = class extends Error {
@@ -17174,7 +17407,7 @@ function writeSyncedName(resolvedFile, name) {
   raw.shipName = name;
   mkdirSync22(dirname18(resolvedFile), { recursive: true });
   const tmp = `${resolvedFile}.tmp${process.pid}`;
-  writeFileSync25(tmp, `${JSON.stringify(raw, null, 2)}
+  writeFileSync26(tmp, `${JSON.stringify(raw, null, 2)}
 `);
   renameSync4(tmp, resolvedFile);
 }
@@ -17206,7 +17439,7 @@ async function reconcileShipName(i) {
   if (result.status !== "ok") return result;
   if (result.action === "adopt" || result.action === "row-wins") {
     const text2 = readFileSync30(i.configFile, "utf8");
-    writeFileSync25(i.configFile, setShipNameInYaml(text2, result.name));
+    writeFileSync26(i.configFile, setShipNameInYaml(text2, result.name));
     i.ship.name = result.name;
     if (result.action === "row-wins") {
       i.emit?.warn(
@@ -17865,7 +18098,7 @@ function describeCapability(i) {
 }
 
 // src/agents-sync-run.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync23, readFileSync as readFileSync31, writeFileSync as writeFileSync26 } from "fs";
+import { existsSync as existsSync36, mkdirSync as mkdirSync23, readFileSync as readFileSync31, writeFileSync as writeFileSync27 } from "fs";
 import { dirname as dirname19 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
@@ -17904,7 +18137,7 @@ async function runAgentsSync(target, o) {
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
     mkdirSync23(dirname19(resolvedPath), { recursive: true });
-    writeFileSync26(resolvedPath, `${JSON.stringify(raw, null, 2)}
+    writeFileSync27(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
     if (target.resolved) {
       target.resolved.agentPersonas = personaResult.agentPersonas;
@@ -18009,11 +18242,11 @@ async function showLogEntry(route2, entryId, opts = {}) {
 // src/repos-check.ts
 import { spawnSync as spawnSync9 } from "child_process";
 import { readFileSync as readFileSync32 } from "fs";
-import { basename as basename9 } from "path";
+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 = basename9(spec.bin).replace(/\.exe$/i, "").toLowerCase();
+  const name = basename10(spec.bin).replace(/\.exe$/i, "").toLowerCase();
   let run2;
   if (POSIX_SHELL.test(name)) {
     run2 = spawnSync9(spec.bin, ["-n"], { input: script, encoding: "utf8" });
@@ -18032,7 +18265,7 @@ function checkHookSyntax(script, shell) {
   return { status: "error", message };
 }
 function renderSamples(cfg, dir) {
-  const checkout = basename9(dir.replace(/[/\\]+$/, ""));
+  const checkout = basename10(dir.replace(/[/\\]+$/, ""));
   const tagged = { key: "ISSUE-123", title: "Fix the widget", role: "dev", tag: "TABL-123", prefix: "tabl", lowercase: cfg.branch.lowercase };
   const untagged = { key: "ISSUE-123", title: "Fix the widget", role: "dev", lowercase: cfg.branch.lowercase };
   return [["with a project tag", tagged], ["without a project tag", untagged]].map(([label, ctx]) => {
@@ -18324,7 +18557,7 @@ function existingRepoConfig(f) {
 }
 
 // src/repos-hooks-agent.ts
-import { spawn as spawn5, execFileSync as execFileSync7 } from "child_process";
+import { spawn as spawn6, execFileSync as execFileSync8 } from "child_process";
 import { realpathSync as realpathSync2 } from "fs";
 import { isAbsolute as isAbsolute2, relative } from "path";
 var AgentSuggestError = class extends Error {
@@ -18427,7 +18660,7 @@ function classifyFailure(o) {
 }
 function porcelain(dir) {
   try {
-    return execFileSync7("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: dir, encoding: "utf8" });
+    return execFileSync8("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: dir, encoding: "utf8" });
   } catch {
     return void 0;
   }
@@ -18445,7 +18678,7 @@ async function runAgentSuggest(o) {
   const run2 = await new Promise((resolve7) => {
     let out = "";
     let err3 = "";
-    const child = spawn5(bin, args, { cwd: o.dir, env, detached: true, stdio: ["pipe", "pipe", "pipe"] });
+    const child = spawn6(bin, args, { cwd: o.dir, env, detached: true, stdio: ["pipe", "pipe", "pipe"] });
     let settled = false;
     const settle = (r) => {
       if (settled) return;
@@ -18496,7 +18729,7 @@ ${run2.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename10, dirname as dirname20, join as join36 } from "path";
+import { basename as basename11, dirname as dirname20, join as join37 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -18519,8 +18752,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 join36(dirname20(existing[0]), SAMPLE_REPO);
-  return join36(reposBase, workspace, SAMPLE_REPO);
+  if (existing.length > 0) return join37(dirname20(existing[0]), SAMPLE_REPO);
+  return join37(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
 function sampleDescription() {
@@ -18565,7 +18798,7 @@ function planSampleTicket(i) {
 
 // src/worktree-sweep.ts
 import { existsSync as existsSync37, readFileSync as readFileSync33, readdirSync as readdirSync14 } from "fs";
-import { basename as basename11, dirname as dirname21, join as join37, resolve as resolve4 } from "path";
+import { basename as basename12, dirname as dirname21, join as join38, 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;
@@ -18606,7 +18839,7 @@ function ticketForWorktree(w, byNumber, contract) {
     const t = num ? byNumber.get(num) : void 0;
     if (t && ticketStems(t).has(stem)) return t;
   }
-  const dir = basename11(w.path);
+  const dir = basename12(w.path);
   const m = DIR_NUMBER.exec(dir);
   if (m && byNumber.has(m[1])) return byNumber.get(m[1]);
   if (!w.branch) {
@@ -18622,7 +18855,7 @@ function worktreeTicketNumbers(target) {
       const n = /-(\d+)$/.exec(BRANCH_STEM.exec(w.branch)?.[1] ?? "")?.[1];
       if (n) nums.add(n);
     }
-    const m = DIR_NUMBER_SUFFIXED.exec(basename11(w.path));
+    const m = DIR_NUMBER_SUFFIXED.exec(basename12(w.path));
     if (m) nums.add(m[1]);
   }
   for (const d of siblingWorktreeDirs(target)) nums.add(d.number);
@@ -18630,7 +18863,7 @@ function worktreeTicketNumbers(target) {
 }
 function siblingWorktreeDirs(target) {
   const parent = dirname21(target.dir.replace(/[/\\]+$/, ""));
-  const stem = `${basename11(target.dir.replace(/[/\\]+$/, ""))}-`;
+  const stem = `${basename12(target.dir.replace(/[/\\]+$/, ""))}-`;
   const registered = new Set(worktrees(target.dir).map((w) => resolve4(w.path)));
   let names;
   try {
@@ -18642,7 +18875,7 @@ function siblingWorktreeDirs(target) {
   for (const name of names) {
     if (!name.startsWith(stem)) continue;
     const m = DIR_NUMBER_SUFFIXED.exec(name);
-    const path = join37(parent, name);
+    const path = join38(parent, name);
     if (m && !registered.has(resolve4(path))) out.push({ path, number: m[1] });
   }
   return out;
@@ -18655,7 +18888,7 @@ function orphanedWorktreeDirs(target, tickets, contract) {
 }
 function warnOrphanedWorktreeDirs(paths, log, held) {
   for (const p of paths) {
-    const number = DIR_NUMBER_SUFFIXED.exec(basename11(p))?.[1];
+    const number = DIR_NUMBER_SUFFIXED.exec(basename12(p))?.[1];
     const when = held && number ? noteHeldWorktree(held.state, { repo: held.repo, path: p, ticket: number, status: "deployed", reason: "orphaned directory" }) : "first";
     if (when) {
       log.warn(`orphaned directory ${p}: its ticket is deployed but it is not a registered worktree; the sweep will not delete it \u2014 remove it by hand`, { step: "worktree" });
@@ -18799,7 +19032,7 @@ function isTicketBranch(name, base, stems) {
 }
 function sweepCandidatesExist(cwd, base) {
   const linked = worktrees(cwd).slice(1);
-  if (linked.some((w) => DIR_NUMBER_SUFFIXED.test(basename11(w.path)) || w.branch && BRANCH_STEM.test(w.branch))) return true;
+  if (linked.some((w) => DIR_NUMBER_SUFFIXED.test(basename12(w.path)) || w.branch && BRANCH_STEM.test(w.branch))) return true;
   if (siblingWorktreeDirs({ name: "", dir: cwd }).length) return true;
   return localBranches(cwd).some((b) => b !== base && /-\d+(?:-.*)?$/.test(b));
 }
@@ -18850,14 +19083,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync38, readdirSync as readdirSync15, rmSync as rmSync16, statSync as statSync10 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync38, readdirSync as readdirSync15, rmSync as rmSync17, statSync as statSync10 } from "fs";
+import { join as join39 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join38(stateDir, "streams");
+  const dir = join39(stateDir, "streams");
   if (!existsSync38(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync15(dir).map((name) => join38(dir, name)).filter((path) => {
+  return readdirSync15(dir).map((name) => join39(dir, name)).filter((path) => {
     try {
       return statSync10(path).mtimeMs < cutoff;
     } catch {
@@ -18873,7 +19106,7 @@ function applyStreamSweep(paths, dryRun, log) {
       continue;
     }
     try {
-      rmSync16(path, { force: true });
+      rmSync17(path, { force: true });
       removed++;
       log.emit(`removed stream artifact ${path}`, { step: "worktree" });
     } catch (e) {
@@ -18885,7 +19118,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) => join38(stateDir, name)).filter((path) => {
+  return readdirSync15(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join39(stateDir, name)).filter((path) => {
     try {
       return statSync10(path).mtimeMs < cutoff;
     } catch {
@@ -18895,12 +19128,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 writeFileSync31, rmSync as rmSync21, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync5, statSync as statSync14, readdirSync as readdirSync20 } from "fs";
+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 { createInterface } from "readline/promises";
 
 // src/periscope-cmd.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync24, readFileSync as readFileSync34, rmSync as rmSync17, writeFileSync as writeFileSync27 } from "fs";
-import { join as join39 } from "path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync24, readFileSync as readFileSync34, rmSync as rmSync18, writeFileSync as writeFileSync28 } from "fs";
+import { join as join40 } from "path";
 var PeriscopeError = class extends Error {
 };
 var LivePeriscopeError = class extends PeriscopeError {
@@ -18910,15 +19143,15 @@ var LivePeriscopeError = class extends PeriscopeError {
     this.data = { refused: "live_periscope_exists", ...live };
   }
 };
-var priorDir = (stateDir) => join39(stateDir, "periscope-priors");
-var priorPath = (stateDir, ticketRecordId) => join39(priorDir(stateDir), `${ticketRecordId}.json`);
+var priorDir = (stateDir) => join40(stateDir, "periscope-priors");
+var priorPath = (stateDir, ticketRecordId) => join40(priorDir(stateDir), `${ticketRecordId}.json`);
 function removePeriscopePrior(stateDir, ticketRecordId) {
-  rmSync17(priorPath(stateDir, ticketRecordId), { force: true });
+  rmSync18(priorPath(stateDir, ticketRecordId), { force: true });
 }
 function writePeriscopePrior(stateDir, ticketRecordId, prior) {
   try {
     mkdirSync24(priorDir(stateDir), { recursive: true });
-    writeFileSync27(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
+    writeFileSync28(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
   } catch {
   }
 }
@@ -19322,14 +19555,14 @@ ${tail2(preview.output)}`);
 }
 
 // src/periscope-idle.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 import { statSync as statSync11 } from "fs";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 var MAX_SCANNED_FILES = 2e4;
 function newestWorktreeMtime(root) {
   let listing;
   try {
-    listing = execFileSync8("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+    listing = execFileSync9("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
       cwd: root,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -19344,7 +19577,7 @@ function newestWorktreeMtime(root) {
     if (!rel) continue;
     if (++scanned > MAX_SCANNED_FILES) break;
     try {
-      const m = statSync11(join40(root, rel)).mtimeMs;
+      const m = statSync11(join41(root, rel)).mtimeMs;
       if (newest === null || m > newest) newest = m;
     } catch {
     }
@@ -19419,13 +19652,13 @@ async function runPeriscopeIdlePass(d) {
 import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
-import { execFileSync as execFileSync9 } from "child_process";
+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 join41 } from "path";
+import { dirname as dirname22, join as join42 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join41(stateDir, "ssh", "id_ed25519");
+  return join42(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
@@ -19433,7 +19666,7 @@ function ensureShipSshKeypair(stateDir) {
   if (!existsSync40(privateKeyPath)) {
     mkdirSync25(dirname22(privateKeyPath), { recursive: true });
     try {
-      execFileSync9("ssh-keygen", [
+      execFileSync10("ssh-keygen", [
         "-t",
         "ed25519",
         "-N",
@@ -19459,7 +19692,7 @@ function ensureShipSshKeypair(stateDir) {
 }
 function sshKeygenAvailable() {
   try {
-    execFileSync9("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
+    execFileSync10("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
     return true;
   } catch (e) {
     return e.code !== "ENOENT";
@@ -19616,10 +19849,10 @@ async function unregisterEndpoint(workspaceId, info, d) {
 
 // src/passenger-sync-daemon.ts
 import { createServer as createHttpServer } from "http";
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync41, mkdirSync as mkdirSync26, readFileSync as readFileSync36, writeFileSync as writeFileSync28, unlinkSync as unlinkSync4, readdirSync as readdirSync16 } from "fs";
-import { join as join42 } from "path";
+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";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -19703,12 +19936,12 @@ function runSyncDaemonFromEnv(env = process.env) {
   return server;
 }
 var defaultSpawn2 = (cmd, args, env) => {
-  const child = spawn6(cmd, args, { detached: true, stdio: "ignore", env });
+  const child = spawn7(cmd, args, { detached: true, stdio: "ignore", env });
   child.unref();
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join42(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join43(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
@@ -19721,8 +19954,8 @@ function readPersistedSyncDaemon(stateDir, workspaceId) {
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync26(join42(stateDir, "passengers"), { recursive: true });
-  writeFileSync28(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync26(join43(stateDir, "passengers"), { recursive: true });
+  writeFileSync29(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function removePersistedSyncDaemon(stateDir, workspaceId) {
@@ -19742,7 +19975,7 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join42(stateDir, "passengers");
+  const dir = join43(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));
@@ -19831,8 +20064,8 @@ function describeCause(err3) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync42, mkdirSync as mkdirSync27, readFileSync as readFileSync37, readdirSync as readdirSync17, rmSync as rmSync18, statSync as statSync12, writeFileSync as writeFileSync29 } from "fs";
-import { join as join43 } from "path";
+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 { randomBytes as randomBytes2 } from "crypto";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
@@ -19920,7 +20153,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(join43(path, entry.name)));
+    latest = Math.max(latest, latestMtime(join44(path, entry.name)));
   }
   return latest;
 }
@@ -19932,7 +20165,7 @@ function makeStaleChecker(paths, opts = {}) {
   return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync42(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join43(stateDir, "reload-requested");
+  return join44(stateDir, "reload-requested");
 }
 function readReloadRequestedAt(stateDir) {
   try {
@@ -19942,12 +20175,12 @@ function readReloadRequestedAt(stateDir) {
   }
 }
 function daemonStampFor(stateDir) {
-  return join43(stateDir, "daemon.started");
+  return join44(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
   mkdirSync27(stateDir, { recursive: true });
-  rmSync18(reloadSentinelFor(stateDir), { force: true });
-  writeFileSync29(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
+  rmSync19(reloadSentinelFor(stateDir), { force: true });
+  writeFileSync30(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
 `);
 }
 function readDaemonStarted(stateDir) {
@@ -20017,7 +20250,7 @@ async function runOnePassUnguarded(o) {
   await hydrateApiKeys([o.route], o.getSessionStore);
   const emit = o.newEmitter();
   const decide = o.decide ?? decideCycle;
-  const spawn9 = o.spawnRoleAgent ?? runRoleAgent;
+  const spawn10 = 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 });
@@ -20121,7 +20354,7 @@ async function runOnePassUnguarded(o) {
         settle = resolve7;
       });
       const ready = (tookTicket2) => settle(tookTicket2);
-      const run2 = spawn9(role, decision, ctx, { ready }).then(() => {
+      const run2 = spawn10(role, decision, ctx, { ready }).then(() => {
         breaker.recordSuccess(role);
         clearShipAttention(o.state, `role_parked:${role}`);
         clearShipAttention(o.state, workspaceAuthKey(role));
@@ -20516,17 +20749,17 @@ import {
   openSync as openSync5,
   readSync as readSync3,
   readdirSync as readdirSync18,
-  rmSync as rmSync19,
+  rmSync as rmSync20,
   statSync as statSync13,
   watch
 } from "fs";
 import { createConnection } from "net";
 import { createServer } from "http";
-import { basename as basename12, dirname as dirname23, join as join44 } from "path";
-import { execFile, spawn as spawn8 } from "child_process";
+import { basename as basename13, dirname as dirname23, join as join45 } from "path";
+import { execFile as execFile2, spawn as spawn9 } from "child_process";
 
 // src/periscope-control.ts
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } 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+$/;
@@ -20717,7 +20950,7 @@ async function handlePeriscopes(h, q) {
 }
 function runCrew(args, onLine, timeoutMs = 20 * 6e4) {
   return new Promise((resolve7) => {
-    const child = spawn7(process.execPath, [process.argv[1] ?? "", ...args], { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn8(process.execPath, [process.argv[1] ?? "", ...args], { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     let pending = "";
@@ -20751,7 +20984,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) => join44(stateDir, CONTROL_SOCKET_NAME);
+var controlSocketFor = (stateDir) => join45(stateDir, CONTROL_SOCKET_NAME);
 var MAX_SOCKET_PATH = 100;
 var MAX_TAIL_BYTES = 1024 * 1024;
 var MAX_WAIT_SECONDS = 30;
@@ -20838,7 +21071,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(join44(dirname23(live), n));
+    for (const n of readdirSync18(dirname23(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join45(dirname23(live), n));
   } catch {
   }
   return out;
@@ -20961,7 +21194,7 @@ function pauseDoc(state) {
 }
 function describeStream(r) {
   return {
-    run: basename12(r.streamPath).replace(/\.jsonl$/, ""),
+    run: basename13(r.streamPath).replace(/\.jsonl$/, ""),
     pid: r.pid,
     ticket: r.ticket,
     role: r.role,
@@ -21038,7 +21271,7 @@ async function route(deps, method, url, req, abort) {
   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 = join44(deps.stateDir, "streams", run2.endsWith(".jsonl") ? run2 : `${run2}.jsonl`);
+    const file = join45(deps.stateDir, "streams", run2.endsWith(".jsonl") ? run2 : `${run2}.jsonl`);
     if (!existsSync43(file)) return err2(404, "no such run");
     return tailReply(file, url.searchParams, false, abort);
   }
@@ -21101,7 +21334,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)) rmSync19(path, { force: true });
+  if (await socketIsStale(path)) rmSync20(path, { force: true });
   else if (existsSync43(path)) {
     log(`control API not started: ${path} is in use by another process`);
     return null;
@@ -21148,7 +21381,7 @@ async function startControlServer(deps) {
         path,
         close: () => new Promise((done) => {
           server.close(() => {
-            rmSync19(path, { force: true });
+            rmSync20(path, { force: true });
             done();
           });
         })
@@ -21157,7 +21390,7 @@ async function startControlServer(deps) {
   });
 }
 var shq2 = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
-function runDetached(commands, spawnFn = spawn8) {
+function runDetached(commands, spawnFn = spawn9) {
   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", () => {
@@ -21175,7 +21408,7 @@ function schedulerHandler(control, run2 = runDetached) {
 }
 function crewJson(args, timeoutMs = 6e4) {
   return new Promise((resolve7) => {
-    execFile(process.execPath, [process.argv[1] ?? "", ...args], { timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 }, (_e, stdout) => {
+    execFile2(process.execPath, [process.argv[1] ?? "", ...args], { timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 }, (_e, stdout) => {
       try {
         const v = JSON.parse(String(stdout));
         resolve7(v && typeof v === "object" && !Array.isArray(v) ? v : null);
@@ -21188,24 +21421,24 @@ 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 basename13, dirname as dirname24, isAbsolute as isAbsolute3, join as join46, relative as relative2, resolve as resolve5, sep } from "path";
+import { basename as basename14, dirname as dirname24, isAbsolute as isAbsolute3, join as join47, 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 rmSync20, writeFileSync as writeFileSync30 } from "fs";
-import { join as join45 } from "path";
-var secretDir = (stateDir) => join45(stateDir, "periscope-mcp");
-var secretFile = (stateDir, id) => join45(secretDir(stateDir), `${id}.json`);
-var endpointDir = (stateDir) => join45(stateDir, "periscope-endpoints");
-var endpointFile = (stateDir, id) => join45(endpointDir(stateDir), `${id}.json`);
+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`);
 function mintPeriscopeSecret(stateDir, ticketRecordId) {
   mkdirSync28(secretDir(stateDir), { recursive: true, mode: 448 });
   const secret = randomBytes3(32).toString("base64url");
   const file = secretFile(stateDir, ticketRecordId);
-  writeFileSync30(file, `${JSON.stringify({ secret })}
+  writeFileSync31(file, `${JSON.stringify({ secret })}
 `, { mode: 384 });
   chmodSync5(file, 384);
   return secret;
@@ -21219,7 +21452,7 @@ function readPeriscopeSecret(stateDir, ticketRecordId) {
   }
 }
 function removePeriscopeSecret(stateDir, ticketRecordId) {
-  rmSync20(secretFile(stateDir, ticketRecordId), { force: true });
+  rmSync21(secretFile(stateDir, ticketRecordId), { force: true });
 }
 function readPeriscopeEndpoint(stateDir, ticketRecordId) {
   try {
@@ -21230,11 +21463,11 @@ function readPeriscopeEndpoint(stateDir, ticketRecordId) {
 }
 function writePeriscopeEndpoint(stateDir, rec) {
   mkdirSync28(endpointDir(stateDir), { recursive: true });
-  writeFileSync30(endpointFile(stateDir, rec.ticketRecordId), `${JSON.stringify(rec, null, 2)}
+  writeFileSync31(endpointFile(stateDir, rec.ticketRecordId), `${JSON.stringify(rec, null, 2)}
 `);
 }
 function removePeriscopeEndpointRecord(stateDir, ticketRecordId) {
-  rmSync20(endpointFile(stateDir, ticketRecordId), { force: true });
+  rmSync21(endpointFile(stateDir, ticketRecordId), { force: true });
 }
 function listPeriscopeEndpoints(stateDir) {
   const dir = endpointDir(stateDir);
@@ -21331,7 +21564,7 @@ async function realAncestor(p) {
     }
     const parent = dirname24(cur);
     if (parent === cur) throw new PathRefusal(`cannot resolve ${p}`);
-    tail3.push(basename13(cur));
+    tail3.push(basename14(cur));
     cur = parent;
   }
 }
@@ -21341,13 +21574,13 @@ async function resolveInWorktree(root, requested) {
   let abs;
   if (isAbsolute3(requested)) {
     abs = resolve5(requested);
-    if (isInside(root, abs)) abs = join46(realRoot, relative2(root, abs));
+    if (isInside(root, abs)) abs = join47(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 ? join46(real, rest) : real;
+  const final = rest ? join47(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;
@@ -21415,7 +21648,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(join46(abs, e.name))).size;
+      const size = (await lstat(join47(abs, e.name))).size;
       return `[FILE] ${e.name} (${size} bytes)`;
     }));
     return text(lines2.join("\n") || "(empty)");
@@ -21481,8 +21714,8 @@ function createPeriscopeMcpServer(d, sc) {
     annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
   }, async ({ path }) => {
     const parent = await inTree(dirname24(path) === "" ? "." : dirname24(path));
-    const abs = join46(parent, basename13(path));
-    if (basename13(path) === ".git" || abs === parent) return text("path must name a file", true);
+    const abs = join47(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);
     if (st.isDirectory()) return text(`${path} is a directory; only files are deleted`, true);
@@ -22181,7 +22414,7 @@ if (command === "passenger-sync-daemon") {
         stateDir: cfg.ship.stateDir,
         configFile: cfg.configFile,
         readFile: (p) => readFileSync39(p, "utf8"),
-        writeFile: (p, t) => writeFileSync31(p, t),
+        writeFile: (p, t) => writeFileSync32(p, t),
         stdin: () => readFileSync39(0, "utf8"),
         env: process.env
       }
@@ -22465,7 +22698,7 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join47(homedir11(), ".config", "systemd", "user", `${label}.timer`);
+      const staleTimer = join48(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)" : ""}
@@ -22528,7 +22761,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;
-          writeFileSync31(cfg.configFile, planEnable(readFileSync39(cfg.configFile, "utf8"), a.route));
+          writeFileSync32(cfg.configFile, planEnable(readFileSync39(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -23651,7 +23884,7 @@ ${cu.tail.trimEnd()}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join47(CREW_HOME, "src"), join47(CREW_HOME, "dist"), join47(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join48(CREW_HOME, "src"), join48(CREW_HOME, "dist"), join48(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -23950,7 +24183,7 @@ ${cu.tail.trimEnd()}
         const raw = existsSync45(resolvedPath) ? JSON.parse(readFileSync39(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
         mkdirSync29(dirOf2(resolvedPath), { recursive: true });
-        writeFileSync31(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        writeFileSync32(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (result.outcomes.some((o) => o.action === "diverged")) process.exitCode = 1;
@@ -23973,7 +24206,7 @@ ${cu.tail.trimEnd()}
         throw e;
       }
       const oldName = cfg.ship.name;
-      writeFileSync31(cfg.configFile, setShipNameInYaml(readFileSync39(cfg.configFile, "utf8"), newName));
+      writeFileSync32(cfg.configFile, setShipNameInYaml(readFileSync39(cfg.configFile, "utf8"), newName));
       cfg.ship.name = newName;
       let renameMachineId;
       try {
@@ -24102,19 +24335,19 @@ ${cu.tail.trimEnd()}
           let cleared;
           if (clear2) {
             const plan = clearRouteHooks(configText, a.route, a.name);
-            if (plan.removed.length > 0) writeFileSync31(cfg.configFile, plan.text);
+            if (plan.removed.length > 0) writeFileSync32(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") });
-            writeFileSync31(cfg.configFile, plan.text);
+            writeFileSync32(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");
-            writeFileSync31(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
+            writeFileSync32(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
             written = { target: "repo", file, hooks: Object.keys(picked.hooks), kept: [], replaced: [] };
           }
           if (flag("json")) {
@@ -24281,7 +24514,7 @@ ${cu.tail.trimEnd()}
             throw new ReposError(`${e.message}${authHint}
   crew.yaml was not changed`);
           }
-          writeFileSync31(cfg.configFile, plan2.text);
+          writeFileSync32(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}`);
@@ -24344,11 +24577,11 @@ ${cu.tail.trimEnd()}
             const raw = JSON.parse(readFileSync39(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
-            writeFileSync31(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync32(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        writeFileSync31(cfg.configFile, plan.text);
+        writeFileSync32(cfg.configFile, plan.text);
         process.stdout.write(`added ${top} to ${routeName} as ${plan.mode === "dir" ? "dir" : `repos.${plan.name}`} in ${cfg.configFile}
 `);
       } catch (e) {
@@ -24717,7 +24950,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.exit(2);
         }
         if (found.shipNameAdopted && !dryRun) {
-          writeFileSync31(cfg.configFile, setShipNameInYaml(readFileSync39(cfg.configFile, "utf8"), found.shipNameAdopted));
+          writeFileSync32(cfg.configFile, setShipNameInYaml(readFileSync39(cfg.configFile, "utf8"), found.shipNameAdopted));
           cfg.ship.name = found.shipNameAdopted;
         }
         if (found.shipRow) {
@@ -24896,7 +25129,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           mkdirSync29(dirname25(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
-          writeFileSync31(tmpPath, `${JSON.stringify(resolved, null, 2)}
+          writeFileSync32(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
           renameSync5(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
@@ -24943,7 +25176,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
 `);
           } else {
             mkdirSync29(dirname25(apiKeyFile), { recursive: true });
-            writeFileSync31(apiKeyFile, `${apiKeyVar}=${apiKey}
+            writeFileSync32(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
 `);
@@ -25773,10 +26006,10 @@ ${where.join("\n")}`);
           },
           prepare: async (path) => {
             for (const f of repoP.config.worktrees.copy) {
-              const src = join47(repoP.dir, f);
+              const src = join48(repoP.dir, f);
               if (!existsSync45(src)) continue;
-              mkdirSync29(dirOf2(join47(path, f)), { recursive: true });
-              copyFileSync2(src, join47(path, f));
+              mkdirSync29(dirOf2(join48(path, f)), { recursive: true });
+              copyFileSync2(src, join48(path, f));
             }
             const setup = repoP.config.hooks.setup;
             return setup ? runScript(setup, { cwd: path, shell: shellP, onLine: (l) => {
@@ -26125,7 +26358,7 @@ ${where.join("\n")}`);
         break;
       }
       mkdirSync29(cfg.ship.stateDir, { recursive: true });
-      writeFileSync31(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
+      writeFileSync32(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"
@@ -26230,7 +26463,7 @@ ${where.join("\n")}`);
         }
         if (configured2.some((r) => r.dir === dir)) {
           try {
-            writeFileSync31(cfg.configFile, planRepoRemove(configText, cfgBase, route2.route, dir).text);
+            writeFileSync32(cfg.configFile, planRepoRemove(configText, cfgBase, route2.route, dir).text);
           } catch (e) {
             if (e instanceof ReposError) fail(e.message);
             throw e;
@@ -26242,16 +26475,16 @@ ${where.join("\n")}`);
             const raw = JSON.parse(readFileSync39(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
-            writeFileSync31(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync32(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        if (existsSync45(join47(dir, ".git")) && basename14(dir) === SAMPLE_REPO) rmSync21(dir, { recursive: true, force: true });
+        if (existsSync45(join48(dir, ".git")) && basename15(dir) === SAMPLE_REPO) rmSync22(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(join47(dir, ".git"));
+      const fresh = !existsSync45(join48(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`);
@@ -26259,8 +26492,8 @@ ${where.join("\n")}`);
       }
       if (fresh) {
         mkdirSync29(dir, { recursive: true });
-        writeFileSync31(join47(dir, "README.md"), SAMPLE_README);
-        writeFileSync31(join47(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        writeFileSync32(join48(dir, "README.md"), SAMPLE_README);
+        writeFileSync32(join48(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()}`);
@@ -26282,13 +26515,13 @@ ${where.join("\n")}`);
           const raw = JSON.parse(readFileSync39(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
-          writeFileSync31(resolvedFile, `${JSON.stringify(raw, null, 2)}
+          writeFileSync32(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
         }
       }
       if (!configured2.some((r) => r.dir === dir)) {
         try {
-          writeFileSync31(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route2.route, path: dir, name: SAMPLE_REPO }).text);
+          writeFileSync32(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;
@@ -26523,7 +26756,7 @@ ${where.join("\n")}`);
               // `synthesis-tabl-123`. `worktreePrefix` above is kept for
               // config-provenance display; this is the field that actually
               // describes where a worktree lands by default.
-              worktreeDirPattern: r.config.worktrees.name ?? (r.config.provenance["worktrees.prefix"] !== "default" ? `${r.config.worktrees.prefix}<number>` : `${basename14(r.dir.replace(/[/\\]+$/, ""))}-<branch>`),
+              worktreeDirPattern: r.config.worktrees.name ?? (r.config.provenance["worktrees.prefix"] !== "default" ? `${r.config.worktrees.prefix}<number>` : `${basename15(r.dir.replace(/[/\\]+$/, ""))}-<branch>`),
               worktreeParent: resolvePath(r.dir, "..")
             })),
             waiting: waiting ? { ticket: waiting.ticket, since: waiting.since, streak: fairness.streak() } : null
@@ -26781,7 +27014,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       );
       for (const r of await resolvedRepos(route2)) {
         const { config } = r;
-        const worktreePattern = config.worktrees.name ?? (config.provenance["worktrees.prefix"] !== "default" ? `${config.worktrees.prefix}<number>` : `${basename14(r.dir.replace(/[/\\]+$/, ""))}-${effectiveBranchTemplate(config, void 0)}`);
+        const worktreePattern = config.worktrees.name ?? (config.provenance["worktrees.prefix"] !== "default" ? `${config.worktrees.prefix}<number>` : `${basename15(r.dir.replace(/[/\\]+$/, ""))}-${effectiveBranchTemplate(config, void 0)}`);
         process.stdout.write(
           `${`repo ${r.name}:`.padEnd(19)}${r.dir}
                    worktrees at ../${worktreePattern} (${config.provenance["worktrees.name"] ?? config.provenance["worktrees.prefix"] ?? "default"}), branch ${config.branch.name}
@@ -27103,6 +27336,13 @@ ${foreign.join("\n")}
 `);
         }
       }
+      if (cfg.ship.runner === "sandbox") {
+        const sb = checkSandboxRunner(cfg.ship.sandbox);
+        process.stdout.write(`sandbox runner:    ${sb.ok ? `OK (${sb.detail})` : `NOT READY \u2014 ${sb.detail}`}
+`);
+      } else {
+        process.stdout.write("sandbox runner:    off (ship.runner is host)\n");
+      }
       const passengerRoutes = cfg.routes.filter((r) => r.enabled && r.hostPassengers);
       if (passengerRoutes.length === 0) {
         process.stdout.write("host passengers:   off (no enabled route sets hostPassengers: true)\n");