@tablation/crew 0.105.0 → 0.107.0

package/dist/cli.js

@@ -1698,9 +1698,9 @@ var keychainSource = {
   write(s, token, c) {
     try {
       if (process.platform === "darwin") {
-        const q = (v) => `"${v.replace(/(["\\])/g, "\\$1")}"`;
+        const q2 = (v) => `"${v.replace(/(["\\])/g, "\\$1")}"`;
         execFileSync("security", ["-i"], {
-          input: `add-generic-password -U -s ${q(keychainService(s))} -a ${q(c.host)} -w ${q(token)}
+          input: `add-generic-password -U -s ${q2(keychainService(s))} -a ${q2(c.host)} -w ${q2(token)}
 `,
           stdio: ["pipe", "ignore", "pipe"]
         });
@@ -2185,6 +2185,12 @@ function parseSandbox(raw, file) {
   const r = raw;
   const packages = stringList(r.packages, "sandbox.packages", file);
   const setup = stringList(r.setup, "sandbox.setup", file);
+  const warm = stringList(r.warm, "sandbox.warm", file);
+  for (const w of warm) {
+    if (w.startsWith("/") || w.split("/").some((seg) => seg === ".." || seg === "" || seg === ".") || /[\\\s]/.test(w)) {
+      throw new RepoConfigError(`${file}: sandbox.warm entry "${w}" must be a repo-relative path or glob with no "..", empty segments, backslashes or whitespace`);
+    }
+  }
   for (const p of packages) {
     if (!PACKAGE_NAME.test(p)) throw new RepoConfigError(`${file}: sandbox.packages entry "${p}" is not a package name (lowercase letters, digits, + . - and an optional =version)`);
   }
@@ -2198,7 +2204,7 @@ function parseSandbox(raw, file) {
       throw new RepoConfigError(`${file}: sandbox.image and sandbox.packages are alternatives \u2014 a published image already carries its packages; put the rest in sandbox.setup`);
     }
   }
-  return { ...image ? { image } : {}, packages, setup };
+  return { ...image ? { image } : {}, packages, setup, warm };
 }
 function parseRepoConfig(text2, file) {
   let raw;
@@ -2218,7 +2224,7 @@ function parseRepoConfig(text2, file) {
   rejectUnknown(raw.branch, BRANCH_KEYS, "branch", file);
   rejectUnknown(raw.worktrees, /* @__PURE__ */ new Set(["copy", "prefix", "name"]), "worktrees", file);
   rejectUnknown(raw.docs, /* @__PURE__ */ new Set(["triagePolicy", "designGuide"]), "docs", file);
-  rejectUnknown(raw.sandbox, /* @__PURE__ */ new Set(["image", "packages", "setup"]), "sandbox", file);
+  rejectUnknown(raw.sandbox, /* @__PURE__ */ new Set(["image", "packages", "setup", "warm"]), "sandbox", file);
   if (raw.version === void 0) throw new RepoConfigError(`${file}: version is required`);
   if (raw.version !== SPEC_VERSION) {
     throw new RepoConfigError(
@@ -2719,7 +2725,22 @@ function parseShipRunner(v) {
   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"];
+var SANDBOX_KEYS = [
+  "bin",
+  "image",
+  "policy",
+  "cacheVolume",
+  "mirrorDir",
+  "workDir",
+  "agentBin",
+  "forgeTokenVar",
+  "engine",
+  "cacheWorkspace",
+  "cacheImage",
+  "depsImage",
+  "depsCommand",
+  "depsLockfile"
+];
 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");
@@ -5352,8 +5373,9 @@ function attentionProblems(items, already) {
 // src/sandbox-image.ts
 import { createHash as createHash5 } from "crypto";
 import { spawn as spawn2 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync3, writeFileSync as writeFileSync10, rmSync as rmSync9 } from "fs";
-import { join as join15 } from "path";
+import { dirname as dirname7, join as join15 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 
 // src/passenger-containers.ts
@@ -5613,7 +5635,25 @@ function crewLayer(base) {
   ].join("\n");
   return { name: "crew", tag: `crew-sandbox-crew:${hash({ base: base.tag, dockerfile, files })}`, dockerfile, files };
 }
-function repoLayer(repo, decl, crew) {
+var WARM_DIR = "/tmp/crew-warm";
+var WARM_MAX_BYTES = 64 * 1024 * 1024;
+var globToRegExp = (glob) => new RegExp(`^${glob.split("*").map((p) => p.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*")}$`);
+function readWarmFiles(dir, ref, patterns) {
+  if (patterns.length === 0) return {};
+  const git2 = (args) => execFileSync4("git", ["-C", dir, ...args], { encoding: "utf8", maxBuffer: WARM_MAX_BYTES, stdio: ["ignore", "pipe", "pipe"] });
+  const all = git2(["ls-tree", "-r", "--name-only", ref]).split("\n").filter(Boolean);
+  const res = patterns.map(globToRegExp);
+  const out = {};
+  let total = 0;
+  for (const path of all.filter((f) => res.some((re) => re.test(f))).sort()) {
+    const content = git2(["show", `${ref}:${path}`]);
+    total += content.length;
+    if (total > WARM_MAX_BYTES) throw new Error(`sandbox.warm files exceed ${WARM_MAX_BYTES} bytes`);
+    out[path] = content;
+  }
+  return out;
+}
+function repoLayer(repo, decl, crew, warm) {
   const env = Object.entries(CREW_ENV).map(([k, v]) => `${k}=${v}`).join(" ");
   const lines2 = [];
   if (decl.image) {
@@ -5635,15 +5675,22 @@ function repoLayer(repo, decl, crew) {
     `USER ${SANDBOX_UID}`,
     "WORKDIR /sandbox"
   );
+  const files = {};
+  const warming = Object.keys(warm).length > 0;
+  if (warming) {
+    for (const [path, content] of Object.entries(warm)) files[`warm/${path}`] = content;
+    lines2.push(`COPY --chown=${SANDBOX_UID}:${SANDBOX_UID} warm/ ${WARM_DIR}/`, `WORKDIR ${WARM_DIR}`);
+  }
   for (const step of decl.setup) lines2.push(run(step));
+  if (warming) lines2.push("WORKDIR /sandbox", run(`rm -rf ${WARM_DIR}`));
   lines2.push(`LABEL io.crew.sandbox.layer="repo" io.crew.sandbox.repo=${JSON.stringify(repo)}`, "");
   const dockerfile = lines2.join("\n");
-  return { name: "repo", tag: `crew-sandbox/${slug(repo)}:${hash({ crew: crew.tag, dockerfile })}`, dockerfile, files: {} };
+  return { name: "repo", tag: `crew-sandbox/${slug(repo)}:${hash({ crew: crew.tag, dockerfile, files })}`, dockerfile, files };
 }
-function planSandbox(repo, decl) {
+function planSandbox(repo, decl, warm = {}) {
   const base = baseLayer();
   const crew = crewLayer(base);
-  const layer = repoLayer(repo, decl, crew);
+  const layer = repoLayer(repo, decl, crew, warm);
   return { repo, tag: layer.tag, layers: [base, crew, layer] };
 }
 var sandboxStatePath = (stateDir) => join15(stateDir, "sandbox-images.json");
@@ -5718,7 +5765,10 @@ async function buildSandboxImage(plan, deps) {
     mkdirSync9(ctx, { recursive: true });
     try {
       writeFileSync10(join15(ctx, "Dockerfile"), layer.dockerfile);
-      for (const [name, content] of Object.entries(layer.files)) writeFileSync10(join15(ctx, name), content);
+      for (const [name, content] of Object.entries(layer.files)) {
+        mkdirSync9(dirname7(join15(ctx, name)), { recursive: true });
+        writeFileSync10(join15(ctx, name), content);
+      }
       const code = await deps.run(["build", "--tag", layer.tag, "--file", join15(ctx, "Dockerfile"), ctx], logPath);
       if (code !== 0) {
         state[plan.repo] = { ...entry, failure: { tag: plan.tag, at: now().toISOString(), logPath } };
@@ -5749,7 +5799,7 @@ function sandboxFailedItem(repo, tag, layer, logPath, nowIso = (/* @__PURE__ */
 async function sandboxBuildTick(repos, deps, force = false) {
   const nowMs = (deps.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
   for (const r of repos) {
-    const plan = planSandbox(r.name, r.decl);
+    const plan = planSandbox(r.name, r.decl, r.warm);
     const state = readSandboxState(deps.stateDir)[r.name];
     const upToDate = state?.tags[0]?.tag === plan.tag && deps.hasImage(plan.tag);
     if (upToDate) {
@@ -5772,10 +5822,10 @@ async function sandboxBuildTick(repos, deps, force = false) {
 }
 
 // src/doctor-checks.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 var PROBE_BRANCH = "crew-probe-branch";
 var realGit = (cwd, args, env) => {
-  execFileSync4("git", args, { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+  execFileSync5("git", args, { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
 };
 function isSshRemote(url) {
   return /^ssh:\/\//.test(url) || /^[\w.-]+@[\w.-]+:/.test(url);
@@ -5897,16 +5947,16 @@ function roleCapWarnings(ship) {
 
 // src/selftest.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync2, readFileSync as readFileSync21, rmSync as rmSync14, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync2, readFileSync as readFileSync22, rmSync as rmSync14, writeFileSync as writeFileSync16 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join25 } from "path";
+import { join as join27 } from "path";
 
 // src/agent.ts
-import { spawnSync as spawnSync5 } from "child_process";
-import { readFileSync as readFileSync20, existsSync as existsSync21, statSync as statSync7, mkdirSync as mkdirSync13, writeFileSync as writeFileSync15, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
+import { spawnSync as spawnSync6 } from "child_process";
+import { readFileSync as readFileSync21, existsSync as existsSync24, statSync as statSync7, mkdirSync as mkdirSync13, writeFileSync as writeFileSync15, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
 import { StringDecoder } from "string_decoder";
 import { finished } from "stream/promises";
-import { join as join24, dirname as dirname8, basename as basename8 } from "path";
+import { join as join26, dirname as dirname9, basename as basename8 } from "path";
 import { createHash as createHash6 } from "crypto";
 
 // src/state.ts
@@ -7061,9 +7111,9 @@ async function addRunToTicket(target, t, recordId, run3) {
   }
 }
 var queueDir = (stateDir) => join17(stateDir, "pending-agent-logs");
-function queueAgentRun(stateDir, name, q) {
+function queueAgentRun(stateDir, name, q2) {
   mkdirSync11(queueDir(stateDir), { recursive: true });
-  writeFileSync12(join17(queueDir(stateDir), `${name}.json`), JSON.stringify(q));
+  writeFileSync12(join17(queueDir(stateDir), `${name}.json`), JSON.stringify(q2));
 }
 async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = queueDir(stateDir);
@@ -7071,23 +7121,23 @@ async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__
   let sent = 0;
   for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
     const path = join17(dir, f);
-    let q;
+    let q2;
     try {
-      q = JSON.parse(readFileSync16(path, "utf8"));
+      q2 = JSON.parse(readFileSync16(path, "utf8"));
     } catch {
       continue;
     }
-    if (q.version !== 1 || q.route !== route2 || now.toISOString() < q.nextAttemptAt) continue;
+    if (q2.version !== 1 || q2.route !== route2 || now.toISOString() < q2.nextAttemptAt) continue;
     try {
-      const apiKey = await keyFor(q.role);
+      const apiKey = await keyFor(q2.role);
       if (!apiKey) continue;
-      const sentRun = await reportAgentRun({ ...q.target, apiKey }, q.report);
+      const sentRun = await reportAgentRun({ ...q2.target, apiKey }, q2.report);
       if (sentRun.counterWarning) log.warn(sentRun.counterWarning);
       if (sentRun.counterRetry) queueTicketCounters(stateDir, f.replace(/\.json$/, ""), {
         version: 1,
-        route: q.route,
-        role: q.role,
-        target: q.target,
+        route: q2.route,
+        role: q2.role,
+        target: q2.target,
         write: sentRun.counterRetry,
         attempts: 0,
         nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -7101,22 +7151,22 @@ async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__
         log.warn(`dropped a queued Agent Log report (${f}): ${e.message}`);
         continue;
       }
-      const attempts = q.attempts + 1;
+      const attempts = q2.attempts + 1;
       writeFileSync12(path, JSON.stringify({
-        ...q,
+        ...q2,
         attempts,
         warned: true,
         nextAttemptAt: new Date(now.getTime() + sleepBackoff(attempts)).toISOString()
       }));
-      if (!q.warned) log.warn(`a queued Agent Log report could not be sent yet (${e.message}); will retry`);
+      if (!q2.warned) log.warn(`a queued Agent Log report could not be sent yet (${e.message}); will retry`);
     }
   }
   return sent;
 }
 var countersDir = (stateDir) => join17(stateDir, "pending-ticket-counters");
-function queueTicketCounters(stateDir, name, q) {
+function queueTicketCounters(stateDir, name, q2) {
   mkdirSync11(countersDir(stateDir), { recursive: true });
-  writeFileSync12(join17(countersDir(stateDir), `${name}.json`), JSON.stringify(q));
+  writeFileSync12(join17(countersDir(stateDir), `${name}.json`), JSON.stringify(q2));
 }
 async function replayQueuedTicketCounters(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = countersDir(stateDir);
@@ -7124,34 +7174,34 @@ async function replayQueuedTicketCounters(stateDir, route2, keyFor, log, now = /
   let sent = 0;
   for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
     const path = join17(dir, f);
-    let q;
+    let q2;
     try {
-      q = JSON.parse(readFileSync16(path, "utf8"));
+      q2 = JSON.parse(readFileSync16(path, "utf8"));
     } catch {
       continue;
     }
-    if (q.version !== 1 || q.route !== route2 || now.toISOString() < q.nextAttemptAt) continue;
+    if (q2.version !== 1 || q2.route !== route2 || now.toISOString() < q2.nextAttemptAt) continue;
     try {
-      const apiKey = await keyFor(q.role);
+      const apiKey = await keyFor(q2.role);
       if (!apiKey) continue;
-      await writeCounters({ ...q.target, apiKey }, q.write);
+      await writeCounters({ ...q2.target, apiKey }, q2.write);
       rmSync11(path, { force: true });
       sent += 1;
-      log.emit(`added a queued run's spend to ${q.write.ticketReference ?? q.write.recordId} (${f})`);
+      log.emit(`added a queued run's spend to ${q2.write.ticketReference ?? q2.write.recordId} (${f})`);
     } catch (e) {
       if (!isRetryable(e)) {
         rmSync11(path, { force: true });
         log.warn(`dropped a queued ticket counter update (${f}): ${e.message}`);
         continue;
       }
-      const attempts = q.attempts + 1;
+      const attempts = q2.attempts + 1;
       writeFileSync12(path, JSON.stringify({
-        ...q,
+        ...q2,
         attempts,
         warned: true,
         nextAttemptAt: new Date(now.getTime() + sleepBackoff(attempts)).toISOString()
       }));
-      if (!q.warned) log.warn(`a queued ticket counter update could not be sent yet (${e.message}); will retry`);
+      if (!q2.warned) log.warn(`a queued ticket counter update could not be sent yet (${e.message}); will retry`);
     }
   }
   return sent;
@@ -8516,15 +8566,15 @@ function holdWarnings(tickets, ships, contract, humanHolds, now = Date.now()) {
 
 // src/run-worktree.ts
 import { existsSync as existsSync17 } from "fs";
-import { dirname as dirname7, join as join19 } from "path";
+import { dirname as dirname8, join as join19 } from "path";
 
 // src/ports.ts
-import { execFileSync as execFileSync5 } from "child_process";
+import { execFileSync as execFileSync6 } from "child_process";
 import { existsSync as existsSync16 } from "fs";
 import { join as join18 } from "path";
 var run2 = (cmd, args) => {
   try {
-    return execFileSync5(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return execFileSync6(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
   } catch {
     return "";
   }
@@ -8665,7 +8715,7 @@ function planRunWorktree(dir, cfg, t, role, opts = {}) {
     if (countCommits(existing.path, `${baseRef}..HEAD`) > 0) return { action: "leave-unpushed", path: existing.path, branch };
     return { action: "recut", path: existing.path, branch, base: baseRef };
   }
-  const path = join19(dirname7(dir), worktreeForTicket(dir, cfg, t, role));
+  const path = join19(dirname8(dir), worktreeForTicket(dir, cfg, t, role));
   if (located?.where === "remote" || located && hasRemote && remoteBranchExists(dir, remote, located.branch)) {
     return { action: "cut-remote", path, branch: located.branch };
   }
@@ -9936,11 +9986,11 @@ function skillMarkerWarnings(promptsDir, personaPrompts) {
 }
 
 // src/runner.ts
-import { spawn as spawn3, execFile, execFileSync as execFileSync6 } from "child_process";
+import { spawn as spawn3, execFile as execFile2, execFileSync as execFileSync7 } from "child_process";
 import { mkdtempSync, writeFileSync as writeFileSync14, rmSync as rmSync13 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { basename as basename7, join as join23 } from "path";
-import { promisify } from "util";
+import { basename as basename7, join as join25 } from "path";
+import { promisify as promisify2 } from "util";
 
 // src/run-limit.ts
 var DEFAULT_MAX_RUN_MINUTES = 240;
@@ -9991,1216 +10041,1712 @@ 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"
+// src/sandbox-cache.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/deprovision-host.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import { existsSync as existsSync23, readdirSync as readdirSync11 } from "fs";
+
+// src/interrupted.ts
+import { existsSync as existsSync21, readdirSync as readdirSync9, readFileSync as readFileSync20 } from "fs";
+import { join as join23 } 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.";
+  return `${INTERRUPTED_MARKER}
+
+The agent run on this ticket was cut short (${b.reason}) before it handed on${b.branch ? `; its branch is \`${b.branch}\`` : ""}. ${tree} The next run on this seat resumes from the worktree rather than starting over.`;
+}
+var handled = /* @__PURE__ */ new Set();
+var pidAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
 };
-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 = spawn3(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 } };
+function runFinished(streamPath) {
+  const path = `${streamPath}.meta.json`;
+  if (!existsSync21(path)) return false;
+  try {
+    return JSON.parse(readFileSync20(path, "utf8")).running !== true;
+  } catch {
+    return true;
   }
-  async kill(handle) {
-    if (handle.pid !== void 0) await killRunGroup(handle.pid);
+}
+function orphanedStreams(o) {
+  const dir = join23(o.stateDir, "streams");
+  if (!existsSync21(dir)) return [];
+  const ownerAlive = o.isOwnerAlive ?? pidAlive;
+  const out = [];
+  for (const name of readdirSync9(dir)) {
+    if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
+    const streamPath = join23(dir, name);
+    if (runFinished(streamPath)) continue;
+    const sidecar = readRunSidecar(streamPath);
+    if (!sidecar || sidecar.route !== o.routeLabel) continue;
+    if (ownerAlive(sidecar.ownerPid)) continue;
+    out.push({ streamPath, sidecar });
   }
-  isAlive(handle) {
-    if (handle.pid === void 0) return false;
-    try {
-      process.kill(handle.pid, 0);
-      return true;
-    } catch (e) {
-      return e.code === "EPERM";
+  return out;
+}
+async function reconcileRuns(o) {
+  let adopted = 0;
+  let interrupted = 0;
+  for (const { streamPath, sidecar } of orphanedStreams(o)) {
+    if (handled.has(streamPath)) continue;
+    handled.add(streamPath);
+    const isAlive = o.isAlive ?? runIsAlive;
+    const lock = isAlive(sidecar) ? o.state.acquireRun(sidecar.role, o.maxConcurrentAgents, o.roleConcurrency?.[sidecar.role] ?? 1) : null;
+    const ticketLock = isAlive(sidecar) && sidecar.ticketRecordId ? o.state.acquireTicket(sidecar.ticketRecordId) : null;
+    const work = (async () => {
+      try {
+        const result = await reattachRun(streamPath, sidecar, o.emit, {
+          agentLogKey: await o.agentLogKey?.(sidecar.role).catch(() => void 0),
+          isAlive: o.isAlive,
+          pollMs: o.pollMs,
+          onAdopted: () => o.emit.emit(`adopted ${sidecar.role} run (pid ${sidecar.pid}) left by a previous crew process`, { step: "agent", role: sidecar.role })
+        });
+        if (result.adopted) adopted++;
+        else interrupted++;
+        try {
+          await o.afterRun?.(sidecar, result);
+        } catch (e) {
+          o.emit.warn(`could not follow up on ${sidecar.role} run ${streamPath}: ${e.message}`, { step: "agent" });
+        }
+      } catch (e) {
+        o.emit.warn(`could not reattach ${sidecar.role} run ${streamPath}: ${e.message}`, { step: "agent" });
+      } finally {
+        if (lock?.ok) lock.release();
+        if (ticketLock?.ok) ticketLock.release();
+      }
+    })();
+    if (isAlive(sidecar)) {
+      if (o.inFlight) {
+        o.inFlight.add(work);
+        void work.finally(() => o.inFlight.delete(work));
+      }
+    } else {
+      await work;
     }
   }
-  reattach(meta) {
-    return { runner: "host", pid: meta.pid };
-  }
-  async release() {
+  return { adopted, interrupted };
+}
+
+// src/live-runs.ts
+import { existsSync as existsSync22, readdirSync as readdirSync10 } from "fs";
+import { join as join24 } from "path";
+function liveRuns(stateDir, isAlive = runIsAlive) {
+  const dir = join24(stateDir, "streams");
+  if (!existsSync22(dir)) return [];
+  const out = [];
+  for (const name of readdirSync10(dir)) {
+    if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
+    const streamPath = join24(dir, name);
+    if (runFinished(streamPath)) continue;
+    const sidecar = readRunSidecar(streamPath);
+    if (!sidecar || !isAlive(sidecar)) continue;
+    out.push({ ...sidecar, streamPath });
   }
-};
-function shQuote2(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
+  return out.sort((a, b) => a.spawnedAt.localeCompare(b.spawnedAt));
 }
-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, "-");
+function siblingRuns(runs, ownTicketRecordId) {
+  return runs.filter((r) => !ownTicketRecordId || r.ticketRecordId !== ownTicketRecordId);
 }
-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 };
+async function settleRunEnd(o) {
+  const { tracker, emit } = o;
+  const all = o.runs ?? liveRuns(o.stateDir);
+  const slug2 = routeSlug(o.route.route);
+  const seatSiblings = siblingRuns(all.filter((r) => r.role === o.role && r.route === slug2), o.ownTicketRecordId);
+  const shipSiblings = siblingRuns(all, o.ownTicketRecordId);
+  const newest = (rs) => rs[rs.length - 1];
+  if (o.memberId) {
     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(join23(tmpdir3(), "crew-prompt-"));
-        try {
-          const file = join23(tmp, "prompt.txt");
-          writeFileSync14(file, plan.prompt, { mode: 384 });
-          await this.os(["sandbox", "upload", name, file, SANDBOX_PROMPT_PATH]);
-        } finally {
-          rmSync13(tmp, { recursive: true, force: true });
-        }
-      }
-      const command2 = viaUpload ? ["sh", "-c", `exec ${[harness, ...plan.args].map(shQuote2).join(" ")} < ${SANDBOX_PROMPT_PATH}`] : [harness, ...plan.args];
-      const child = spawn3(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 } : {} };
+      if (seatSiblings.length) await tracker.setCrewStatus(o.memberId, "working", newest(seatSiblings).ticketRecordId);
+      else await tracker.setCrewStatus(o.memberId, "idle");
     } catch (e) {
-      await this.release(handle, o.emit);
-      throw new Error(`could not prepare the sandbox ${name}: ${describeExecError(e)}`);
+      emit.warn(`could not clear crew status: ${e.message}`, { step: "agent" });
     }
   }
-  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 {
+  try {
+    if (shipSiblings.length) {
+      const n = newest(shipSiblings);
+      await tracker.beatEngaged(o.shipName, n.routeName ?? n.route, n.ticketRecordId, n.spawnedAt);
+    } else {
+      await tracker.beatIdle(o.shipName);
     }
+  } catch (e) {
+    emit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
   }
-};
-function describeExecError(e) {
-  const err3 = e;
-  return (err3.stderr?.trim() || err3.message || String(e)).split("\n").slice(-3).join(" / ");
 }
-function gitOrigin(cwd) {
+function describeRun(run3, route2, seatIds, worktreeOf = (d, n) => {
   try {
-    return execFileSync6("git", ["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    return worktreeForNumber(d, n)?.path ?? null;
   } catch {
     return null;
   }
+}) {
+  const ownRoute = run3.route === routeSlug(route2.route);
+  const repoDir = run3.repo ? reposOf(route2).find((t) => t.name === run3.repo)?.dir : void 0;
+  const num = run3.ticket?.replace(/^\D+/, "") ?? "";
+  return {
+    role: run3.role,
+    seat: ownRoute ? seatIds[run3.role] ?? null : null,
+    ticket: run3.ticket,
+    ticketRecordId: run3.ticketRecordId,
+    repo: run3.repo ?? null,
+    worktree: repoDir && num ? worktreeOf(repoDir, num) : null,
+    stream: run3.streamPath,
+    pid: run3.pid,
+    startedAt: run3.spawnedAt,
+    deadline: run3.deadline ?? 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 = {}, run3 = (b, a) => execFileSync6(b, a, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 15e3 })) {
-  const bin = cfg.bin ?? DEFAULT_SANDBOX_CONFIG.bin;
-  let version;
+
+// src/seat-keys.ts
+import { hostFromUrl as hostFromUrl2 } from "@tablation/client";
+var SEAT_KEY_ROLES = ROLE_NAMES.filter((r) => r !== "pair");
+function keyIsAdmin(route2) {
+  const role = route2.resolved?.role;
+  return role === void 0 || role === "WORKSPACE_ADMIN" || role === "PLATFORM_ADMIN";
+}
+var MEMBER_NO_ROW = "has no linked Agents row \u2014 a workspace admin's `crew agents sync` creates the persona rows; run it here afterwards to link this ship's seats";
+var MEMBER_NO_KEY = 'no agent key for this seat \u2014 run `crew agents sync` (needs the "Mint agent keys" capability on your role)';
+var FORBIDDEN_LINE = 'seat keys: not minted \u2014 your role does not grant "Mint agent keys"; ask a workspace admin to add it to your project role (or run sync with an admin key)';
+function seatKeySlug(workspaceSlug, agentId) {
+  return `${workspaceSlug}#agent:${agentId}`;
+}
+function slugFor(route2, agentId) {
+  const [workspaceSlug] = splitRoute(route2.route);
+  return seatKeySlug(workspaceSlug, agentId);
+}
+function seatAgentId(route2, role) {
+  return route2.resolved?.agentPersonas?.[role]?.agentId;
+}
+async function resolveReleaseKey(route2, getStore = getSessionStore) {
+  const ship = (reason) => ({ kind: "ship", apiKey: resolveApiKey(route2), reason });
+  const agentId = route2.resolved?.releaseAgentId;
+  if (!agentId) return ship(keyIsAdmin(route2) ? "release seat has no linked Agents row (run `crew agents sync`)" : `release seat ${MEMBER_NO_ROW}`);
   try {
-    version = run3(bin, ["--version"]).trim();
+    const session = await getStore().get(hostFromUrl2(route2.baseUrl), slugFor(route2, agentId));
+    if (session?.apiKey) return { kind: "agent", apiKey: session.apiKey, agentId };
+    return ship(keyIsAdmin(route2) ? "no agent key stored for the release seat (run `crew agents sync`)" : MEMBER_NO_KEY);
   } catch (e) {
-    return { ok: false, detail: `${bin} is not installed or not on the scheduler PATH (${e.message.split("\n")[0]})` };
+    const reason = describeReadError(e);
+    return { kind: "ship", apiKey: resolveApiKey(route2), reason, storeError: reason };
   }
+}
+async function resolveSeatKey(route2, role, getStore = getSessionStore) {
+  const ship = (reason) => ({ kind: "ship", apiKey: resolveApiKey(route2), reason });
+  if (!SEAT_KEY_ROLES.includes(role)) return ship(`${role} always writes as the ship`);
+  const agentId = seatAgentId(route2, role);
+  if (!agentId) return ship(keyIsAdmin(route2) ? "seat has no linked Agents row (run `crew agents sync`)" : `seat ${MEMBER_NO_ROW}`);
   try {
-    run3(bin, ["status"]);
+    const session = await getStore().get(hostFromUrl2(route2.baseUrl), slugFor(route2, agentId));
+    if (session?.apiKey) return { kind: "agent", apiKey: session.apiKey, agentId };
+    return ship(keyIsAdmin(route2) ? "no agent key stored for this seat (run `crew agents sync`)" : MEMBER_NO_KEY);
   } 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.`
-    };
+    const reason = describeReadError(e);
+    return { kind: "ship", apiKey: resolveApiKey(route2), reason, storeError: reason };
   }
-  return { ok: true, detail: version };
 }
-
-// src/agent.ts
-var DIGEST_MAX_AGE_SECONDS = 600;
-var LEGACY_TOOLCHAIN_HARNESS = "claude";
-var LEGACY_TOOLCHAIN_PROVIDER = "anthropic";
-function scrubbedEnv(env = process.env, harness = LEGACY_TOOLCHAIN_HARNESS) {
-  const out = { ...env };
-  for (const v of adapterFor(harness).unsetEnv) delete out[v];
-  return out;
+function safeStderrLine(e) {
+  const err3 = e;
+  const raw = typeof err3?.stderr === "string" && err3.stderr.trim() ? err3.stderr : typeof err3?.message === "string" ? err3.message : "";
+  for (const line of raw.split("\n")) {
+    const t = line.trim();
+    if (!t || /^Command failed:/i.test(t) || /(^|\s)-w(\s|$)/.test(t)) continue;
+    return t.slice(0, 120);
+  }
+  return void 0;
 }
-var CREW_LANE_ROLE_VAR = "CREW_LANE_ROLE";
-function assemblePrompt(p) {
-  const sections = [p.roster, p.environment, `${p.common}${p.brief}`];
-  if (p.digest) sections.push(p.digest);
-  return sections.join("\n\n");
+function describeReadError(e) {
+  const fsErr = e;
+  if (typeof fsErr?.path === "string" && typeof fsErr.code === "string") return `key file store unreadable (${fsErr.code})`;
+  const code = e?.code;
+  const line = safeStderrLine(e);
+  const what = typeof code === "number" ? `security exited ${code}` : typeof code === "string" ? `security failed: ${code}` : void 0;
+  const detail = [what, line].filter(Boolean).join(what && line ? ": " : "");
+  return detail ? `OS keychain unavailable (${detail})` : "OS keychain unavailable";
 }
-var AgentError = class extends Error {
-};
-var AgentSpawnError = class extends AgentError {
-};
-var WorkspaceAuthRefused = class extends AgentSpawnError {
-};
-var WorkspaceAllowanceExhausted = class extends AgentError {
-};
-var ALLOWANCE_REFUSAL_MARKER = "AI_ALLOWANCE_EXCEEDED";
-function streamShowsAllowanceRefusal(streamPath) {
-  let raw;
+function keychainExitCode(reason) {
+  const m = /security exited (\d+)/.exec(reason);
+  return m ? Number(m[1]) : void 0;
+}
+function describeStoreError(e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  if (/User interaction is not allowed/i.test(msg)) {
+    return "keychain unavailable (User interaction is not allowed \u2014 run from a logged-in session, or `security unlock-keychain` first)";
+  }
+  return "keychain unavailable (could not write to the OS keychain)";
+}
+async function mintMissingSeatKeys(route2, o) {
+  const out = [];
+  if (!route2.resolved) return out;
+  const resolved = route2.resolved;
+  const doFetch = o.fetchImpl ?? fetch;
+  const targets = [
+    ...SEAT_KEY_ROLES.filter((r) => resolved.seats[r]).map((role) => ({ role, agentId: seatAgentId(route2, role) })),
+    ...resolved.releaseSeat ? [{ role: "release", agentId: resolved.releaseAgentId }] : []
+  ];
+  let store;
   try {
-    raw = readFileSync20(streamPath, "utf8");
-  } catch {
-    return false;
+    store = (o.getStore ?? getSessionStore)();
+  } catch (e) {
+    return targets.map(({ role }) => ({
+      role,
+      action: "failed",
+      detail: describeStoreError(e)
+    }));
   }
-  if (!raw.includes(ALLOWANCE_REFUSAL_MARKER)) return false;
-  for (const line of raw.split("\n")) {
-    if (!line.includes(ALLOWANCE_REFUSAL_MARKER)) continue;
-    let ev;
+  const host = hostFromUrl2(route2.baseUrl);
+  const base = route2.baseUrl.replace(/\/+$/, "");
+  if (!o.dryRun) {
+    const probeSlug = seatKeySlug(splitRoute(route2.route)[0], "_probe");
     try {
-      ev = JSON.parse(line);
-    } catch {
+      await store.set(host, probeSlug, {
+        apiKey: "probe",
+        workspaceId: resolved.workspaceId,
+        identityId: "_probe",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await store.clear(host, probeSlug);
+    } catch (e) {
+      const detail = `${describeStoreError(e)}; no keys minted`;
+      return targets.map(({ role, agentId }) => agentId ? { role, action: "failed", detail } : { role, action: "no_agent" });
+    }
+  }
+  for (const { role, agentId } of targets) {
+    if (!agentId) {
+      out.push({ role, action: "no_agent" });
       continue;
     }
-    if (typeof ev !== "object" || ev === null) continue;
-    const e = ev;
-    if (e.type === "result" && e.is_error === true) {
-      if (typeof e.result === "string" && e.result.includes(ALLOWANCE_REFUSAL_MARKER)) return true;
-    } else if (e.type === "assistant" && (e.isApiErrorMessage === true || e.error !== void 0)) {
-      if (JSON.stringify(e.message ?? "").includes(ALLOWANCE_REFUSAL_MARKER)) return true;
+    const slug2 = slugFor(route2, agentId);
+    try {
+      if ((await store.get(host, slug2))?.apiKey) {
+        out.push({ role, action: "already_stored" });
+        continue;
+      }
+      if (o.dryRun) {
+        out.push({ role, action: "minted", detail: "dry run" });
+        continue;
+      }
+      const res = await doFetch(`${base}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${resolveApiKey(route2)}`,
+          "Content-Type": "application/json",
+          "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0"
+        },
+        body: JSON.stringify({ name: `crew ${o.shipName ?? "ship"} ${role}` })
+      });
+      if (res.status === 403) {
+        out.push({ role, action: "forbidden" });
+        break;
+      }
+      if (!res.ok) {
+        out.push({ role, action: "failed", detail: `${res.status} ${res.statusText}` });
+        continue;
+      }
+      const body = await res.json();
+      if (!body.key) {
+        out.push({ role, action: "failed", detail: "response carried no key" });
+        continue;
+      }
+      try {
+        const session = {
+          apiKey: body.key,
+          workspaceId: resolved.workspaceId,
+          identityId: agentId,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ...body.id ? { keyId: body.id } : {}
+        };
+        await store.set(host, slug2, session);
+      } catch (e) {
+        let revoked = false;
+        if (body.id) {
+          try {
+            const del2 = await doFetch(`${base}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys/${body.id}`, {
+              method: "DELETE",
+              headers: { Authorization: `Bearer ${resolveApiKey(route2)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
+            });
+            revoked = del2.ok;
+          } catch {
+            revoked = false;
+          }
+        }
+        out.push({
+          role,
+          action: "failed",
+          detail: revoked ? `minted but could not be stored (${describeStoreError(e)}); revoked` : `a key for ${role} is live on the server and not stored (${describeStoreError(e)}) \u2014 revoke it from that seat's Agents row`
+        });
+        continue;
+      }
+      out.push({ role, action: "minted" });
+    } catch (e) {
+      out.push({ role, action: "failed", detail: /Command failed|security|sk_|-w /i.test(e.message) ? describeStoreError(e) : e.message });
     }
   }
-  return false;
+  return out;
 }
-var digestPathFor = (stateDir, routeLabel, role, runId) => join24(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
-function planAgentRun(o) {
-  const briefPath = join24(o.route.promptsDir, "personas", `lane-${o.role}.md`);
-  if (!existsSync21(briefPath)) {
-    throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
+function describeMintOutcome(o) {
+  switch (o.action) {
+    case "minted":
+      return `${o.role}: agent key minted${o.detail ? ` (${o.detail})` : ""}`;
+    case "already_stored":
+      return `${o.role}: agent key already stored`;
+    case "no_agent":
+      return `${o.role}: no linked Agents row \u2014 writes as the ship until \`crew agents sync\` links one`;
+    case "forbidden":
+      return FORBIDDEN_LINE;
+    case "failed":
+      return `${o.role}: could not mint an agent key (${o.detail ?? "unknown"}) \u2014 writes as the ship`;
   }
-  const commonPath = join24(o.route.promptsDir, "personas", "common.md");
-  const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync21(commonPath);
-  const now = o.now ?? (() => Date.now());
-  const routeLabel = routeSlug(o.route.route);
-  const ownDigest = o.runId ? digestPathFor(o.stateDir, routeLabel, o.role, o.runId) : void 0;
-  const digestPath2 = ownDigest && existsSync21(ownDigest) ? ownDigest : digestPathFor(o.stateDir, routeLabel, o.role);
-  let digest;
-  let ageSeconds;
-  if (existsSync21(digestPath2)) {
-    ageSeconds = Math.floor((now() - statSync7(digestPath2).mtimeMs) / 1e3);
-    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync20(digestPath2, "utf8");
-  }
-  const common = usesCommon ? readFileSync20(commonPath, "utf8") : "";
-  const brief = readFileSync20(briefPath, "utf8");
-  const effectiveCommon = o.divergedPrompt ? "" : common;
-  const effectiveBrief = appendAdditions(o.divergedPrompt ?? brief, o.personaAdditions);
-  const localSkills = new Map(listLocalSkills(o.route.promptsDir).map((s) => [s.name, s.prompt]));
-  let expanded;
+}
+async function revokeSeatKeys(route2, o) {
+  const out = [];
+  if (!route2.resolved) return out;
+  const resolved = route2.resolved;
+  const doFetch = o.fetchImpl ?? fetch;
+  const targets = [
+    ...SEAT_KEY_ROLES.filter((r) => resolved.seats[r]).map((role) => ({ role, agentId: seatAgentId(route2, role) })),
+    ...resolved.releaseSeat ? [{ role: "release", agentId: resolved.releaseAgentId }] : []
+  ];
+  let store;
   try {
-    expanded = expandSkillMarkers(
-      `${effectiveCommon}${effectiveBrief}`,
-      (name) => o.skillOverrides?.[name] ?? localSkills.get(name)
-    );
+    store = (o.getStore ?? getSessionStore)();
   } catch (e) {
-    if (e instanceof SkillIncludeError) throw new AgentError(`${e.message} \u2014 refusing to run an unscoped session`);
-    throw e;
+    return targets.map(({ role }) => ({ role, action: "failed", detail: describeStoreError(e) }));
   }
-  const prompt = assemblePrompt({
-    roster: o.roster,
-    environment: o.environment,
-    common: "",
-    brief: expanded.text,
-    digest
-  });
-  const promptSha = createHash6("sha256").update(expanded.text).digest("hex");
-  const streamsDir = join24(o.stateDir, "streams");
-  const base = `${routeLabel}-${o.role}-${o.cycle}${o.runId ? `-${o.runId}` : ""}`;
-  const seat = resolveSeat(o.ship, o.route, o.role, o.agentPersona ?? (o.agentModel ? { model: o.agentModel } : {}), o.repo);
-  const { model } = seat;
-  let toolchain = seat.toolchain;
-  if (toolchain.auth === "workspace") {
-    if (!o.apiKey || o.seatKind === "ship") {
-      throw new WorkspaceAuthRefused(`${o.role}: toolchain ${toolchain.name} has auth: workspace, which needs the seat's own agent key \u2014 this seat would fall back to the ship key (run \`crew agents sync\`)`);
+  const host = hostFromUrl2(route2.baseUrl);
+  const base = route2.baseUrl.replace(/\/+$/, "");
+  for (const { role, agentId } of targets) {
+    if (!agentId) {
+      out.push({ role, action: "no_agent" });
+      continue;
     }
-    if (!o.route.resolved) {
-      throw new WorkspaceAuthRefused(`${o.role}: toolchain ${toolchain.name} has auth: workspace, but route ${o.route.route} is not connected (run \`crew connect\`)`);
+    const slug2 = slugFor(route2, agentId);
+    try {
+      const session = await store.get(host, slug2);
+      if (!session?.apiKey) {
+        out.push({ role, action: "not_stored" });
+        continue;
+      }
+      if (!session.keyId) {
+        out.push({ role, action: "failed", detail: "no key id was recorded when this key was minted \u2014 revoke it from the seat's Agents row" });
+        continue;
+      }
+      if (o.dryRun) {
+        out.push({ role, action: "revoked", detail: "dry run" });
+        continue;
+      }
+      const del2 = await doFetch(`${base}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys/${session.keyId}`, {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${resolveApiKey(route2)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
+      });
+      if (!del2.ok && del2.status !== 404) {
+        out.push({ role, action: "failed", detail: `${del2.status} ${del2.statusText}` });
+        continue;
+      }
+      await store.clear(host, slug2);
+      out.push({ role, action: "revoked", detail: del2.ok ? void 0 : "server already had no such key" });
+    } catch (e) {
+      out.push({ role, action: "failed", detail: /Command failed|security|sk_|-w /i.test(e.message) ? describeStoreError(e) : e.message });
     }
-    toolchain = { ...toolchain, inference: { baseUrl: inferenceBaseUrl(o.route.baseUrl, o.route.resolved.workspaceId), token: o.apiKey } };
   }
-  const adapter = adapterFor(toolchain.harness);
-  const invocation = adapter.invocation(toolchain, {
-    role: o.role,
-    model,
-    // Skipped when there's no key to send: a route `crew connect` hasn't
-    // resolved yet has nothing to authenticate the MCP connection with either.
-    mcp: o.apiKey ? { url: `${o.route.baseUrl}/api/mcp`, keyVar: API_KEY_VAR } : void 0
-  });
-  const columns = resolveContract(o.route.contract).columns;
-  const agentLog = o.route.resolved && o.apiKey ? {
-    baseUrl: o.route.baseUrl,
-    workspaceId: o.route.resolved.workspaceId,
-    apiKey: o.apiKey,
-    userAgent: o.ship.userAgent,
-    agentId: o.resolvedAgentId,
-    ...o.route.resolved.models?.issues ? { tickets: {
-      issuesModelId: o.route.resolved.models.issues,
-      keyColumn: columns.key,
-      tagColumn: columns.tag,
-      counters: {
-        agentRuns: columns.agentRuns,
-        tokensIn: columns.tokensIn,
-        tokensOut: columns.tokensOut,
-        cacheReadTokens: columns.cacheReadTokens,
-        cacheWriteTokens: columns.cacheWriteTokens,
-        costUsd: columns.costUsd
-      }
-    } } : {}
-  } : void 0;
-  return {
-    role: o.role,
-    route: routeLabel,
-    // The route's directory, which is a STARTING POINT and not the
-    // ticket's repo: the session picks its own working directory even when
-    // the runner already selected a ticket (`o.repo` is known then, and
-    // only feeds the per-repo toolchain choice). Where an area spans
-    // several repos this is whichever one `repos` happened to list first
-    // (config.ts), and the digest's `repo` column is what actually places
-    // the work. Kept deliberately rather than guessed at (ISSUE-349).
-    cwd: o.route.dir,
-    bin: invocation.bin,
-    args: invocation.args,
-    toolchain: toolchain.name,
-    harness: toolchain.harness,
-    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,
-    promptBytes: Buffer.byteLength(prompt, "utf8"),
-    unsetEnv: adapter.unsetEnv,
-    setEnv: {
-      ...o.apiKey ? { [API_KEY_VAR]: o.apiKey } : {},
-      ...adapter.runEnv(toolchain),
-      // The operator's global SessionStart hook (pair-context-hook.sh) injects
-      // the interactive Pair persona's prompt for any session it can't tell
-      // apart from a person's own terminal. Every headless lane run this
-      // planner produces carries a real ticket brief already (`prompt`
-      // above) — it must never be replaced by the Pair persona with no
-      // ticket attached, which silently no-ops and strands the ticket
-      // in_progress (ISSUE-490, ISSUE-591). Setting this is what lets that
-      // hook tell the two apart; it has nothing to do with the run itself.
-      [CREW_LANE_ROLE_VAR]: o.role,
-      // CREW-2783: the ship's forge credential — git helper config plus the
-      // token as an env var for `gh` and friends. Empty without `forges:`.
-      ...forgeRunEnv(o.ship.forges, { crewCommand: crewCommandLine(), configFile: process.env.CREW_CONFIG, stateDir: o.stateDir })
-    },
-    digestAttached: digest !== void 0,
-    digestAgeSeconds: ageSeconds,
-    model,
-    streamPath: join24(streamsDir, `${base}.jsonl`),
-    eventsPath: join24(streamsDir, `${base}.events.jsonl`),
-    ticket: o.ticket,
-    ticketRecordId: o.ticketRecordId ?? null,
-    repo: o.repo ?? null,
-    routeName: o.route.route,
-    agentLog,
-    promptVersion: o.route.resolved?.agentPersonas?.[o.role]?.historyId,
-    promptSha
-  };
+  return out;
 }
-function describePlan(p) {
-  return [
-    `role:    ${p.role}`,
-    ...p.resolution ? [`resolved: toolchain ${p.toolchain} \u2190 ${p.resolution.toolchain}; model ${p.model} \u2190 ${p.resolution.model}${p.provider ? `; provider ${p.provider}` : ""}`] : [],
-    ...(p.warnings ?? []).map((w) => `warning: ${w}`),
-    // Only for a non-default toolchain, so a plain Claude run's output is unchanged.
-    ...p.toolchain && p.toolchain !== "claude" ? [`toolchain: ${p.toolchain} (${p.harness ?? "claude"})`] : [],
-    `cwd:     ${p.cwd}`,
-    `command: ${p.bin} ${p.args.join(" ")}`,
-    `prompt:  ${p.promptBytes} bytes on stdin (never argv)`,
-    `digest:  ${p.digestAttached ? `attached, ${p.digestAgeSeconds}s old` : "absent \u2014 the agent will fetch the tracker itself"}`,
-    `unset:   ${p.unsetEnv.join(" ")}`,
-    // The VALUE is deliberately absent: --dry-run output is pasted into
-    // tickets and chat.
-    `set:     ${Object.keys(p.setEnv).join(" ") || "(nothing)"}`,
-    `stream:  ${p.streamPath}`
-  ].join("\n");
+function describeRevokeOutcome(o) {
+  switch (o.action) {
+    case "revoked":
+      return `${o.role}: agent key revoked and cleared from the keychain${o.detail ? ` (${o.detail})` : ""}`;
+    case "not_stored":
+      return `${o.role}: no agent key stored on this ship`;
+    case "no_agent":
+      return `${o.role}: no linked Agents row`;
+    case "failed":
+      return `${o.role}: could not revoke the agent key (${o.detail ?? "unknown"}) \u2014 left in the keychain`;
+  }
 }
-var pidPathFor = (streamPath) => `${streamPath}.pid`;
-function readRunSidecar(streamPath) {
+async function canMintAgentKeys(route2, o = {}) {
+  const resolved = route2.resolved;
+  if (!resolved) return void 0;
+  const agentId = seatAgentId(route2, "dev") ?? SEAT_KEY_ROLES.map((r) => seatAgentId(route2, r)).find(Boolean);
+  if (!agentId) return void 0;
   try {
-    const sc = JSON.parse(readFileSync20(pidPathFor(streamPath), "utf8"));
-    return typeof sc.pid === "number" && typeof sc.spawnedAt === "string" && typeof sc.role === "string" ? sc : null;
+    const res = await (o.fetchImpl ?? fetch)(`${route2.baseUrl.replace(/\/+$/, "")}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys`, {
+      headers: { Authorization: `Bearer ${resolveApiKey(route2)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
+    });
+    if (res.ok) return true;
+    return res.status === 403 ? false : void 0;
   } catch {
-    return null;
+    return void 0;
   }
 }
-function runIsAlive(sc) {
-  try {
-    process.kill(sc.pid, 0);
-  } catch (e) {
-    if (e.code !== "EPERM") return false;
-  }
-  const ps = spawnSync5("ps", ["-o", "lstart=", "-p", String(sc.pid)], { encoding: "utf8" });
-  const started = Date.parse(ps.stdout.trim());
-  if (ps.status !== 0 || Number.isNaN(started)) return ps.status === 0;
-  return Math.abs(started - Date.parse(sc.spawnedAt)) < 15e3;
+
+// src/deprovision-host.ts
+var DOCKER_LABEL_OWNER = "crew.owner=crew";
+var DOCKER_LABEL_CACHE = "crew.kind=cache";
+var DOCKER_LABEL_REPO_LAYER = "crew.layer=repo";
+function docker(args) {
+  const res = spawnSync5("docker", args, { encoding: "utf8" });
+  if (res.error || res.status !== 0) throw new Error(`docker ${args[0]} ${args[1] ?? ""} failed: ${(res.stderr || String(res.error ?? "")).trim().split("\n").pop()}`);
+  return res.stdout;
 }
-function identityOf(plan, adapterHarness) {
+var lines = (s) => s.split("\n").map((l) => l.trim()).filter(Boolean);
+function labeledDocker() {
+  if (!dockerAvailable()) return { volumes: [], images: [] };
   return {
-    role: plan.role,
-    route: plan.route,
-    ticket: plan.ticket ?? null,
-    model: plan.model,
-    toolchain: plan.toolchain ?? LEGACY_TOOLCHAIN_HARNESS,
-    harness: adapterHarness,
-    provider: plan.provider ?? LEGACY_TOOLCHAIN_PROVIDER,
-    eventsPath: plan.eventsPath,
-    streamPath: plan.streamPath,
-    agentLog: plan.agentLog ? withoutKey(plan.agentLog) : void 0,
-    promptVersion: plan.promptVersion,
-    promptSha: plan.promptSha
+    volumes: lines(docker(["volume", "ls", "-q", "--filter", `label=${DOCKER_LABEL_OWNER}`, "--filter", `label=${DOCKER_LABEL_CACHE}`])),
+    images: lines(docker(["image", "ls", "-q", "--filter", `label=${DOCKER_LABEL_OWNER}`, "--filter", `label=${DOCKER_LABEL_REPO_LAYER}`]))
   };
 }
-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)`, {
-    role,
-    ...ticket ? { ticket } : {},
-    data: { event: "run_killed", reason: WALL_CLOCK_REASON, limitMinutes: limit, elapsedMs, pid }
-  });
-  await kill();
-  return { limitMinutes: limit, elapsedMs };
-}
-var withoutKey = ({ apiKey: _apiKey, ...rest }) => rest;
-function openSink(path) {
-  try {
-    mkdirSync13(dirname8(path), { recursive: true });
-    return createWriteStream(path, { flags: "a" });
-  } catch {
-    return void 0;
-  }
-}
-function endSink(sink) {
-  if (!sink) return Promise.resolve();
-  sink.end();
-  return finished(sink).catch(() => void 0);
+function realDeprovisionDeps(cfg, emit, crewHome, getStore) {
+  const stateDir = cfg.ship.stateDir;
+  const forgeHosts = () => Object.keys(cfg.ship.forges ?? {});
+  const routeFor = (label) => cfg.routes.find((r) => routeSlug(r.route) === label);
+  const sandboxes = () => dockerAvailable() ? listPassengerContainers().map((c) => c.name) : [];
+  const unitPaths = () => {
+    const host = hostPlatform();
+    if (host === "windows") return [];
+    const ctx = installContext();
+    const systemd = detectSystemd();
+    return ["run", "release", "passengers"].flatMap((job) => planInstall(cfg.ship, crewHome, host, systemd, job, ctx).unitPaths).filter((p) => existsSync23(p));
+  };
+  return {
+    liveRuns: () => liveRuns(stateDir).map((r) => ({ role: r.role, route: r.route, pid: r.pid, ticketRecordId: r.ticketRecordId ?? void 0, streamPath: r.streamPath })),
+    killRun: (run3) => killRunGroup(run3.pid),
+    recordKill(run3) {
+      emit.emit(`run_killed: ${run3.role} run on ${run3.route} stopped by crew deprovision`, {
+        step: "agent",
+        role: run3.role,
+        data: { event: "run_killed", reason: "deprovision", pid: run3.pid }
+      });
+    },
+    async handBack(run3) {
+      const route2 = routeFor(run3.route);
+      if (!run3.ticketRecordId || !route2) return;
+      const memberId = route2.resolved?.seats[run3.role];
+      if (!memberId) return;
+      const identity = await resolveSeatKey(route2, run3.role, getStore);
+      const tracker = new Tracker(route2, cfg.ship, { apiKey: identity.apiKey });
+      const t = await tracker.ticket(run3.ticketRecordId);
+      const target = repoTargetFor(route2, t.repo_id);
+      const num = String(t[tracker.contract.columns.key] ?? "").replace(/^\D+/, "");
+      const wt = target && num ? worktreeForNumber(target.dir, num) : null;
+      let dirty = null;
+      try {
+        if (wt) dirty = status(wt.path).length > 0;
+      } catch {
+      }
+      await tracker.postEvent(run3.ticketRecordId, interruptedComment({
+        branch: wt?.branch ?? null,
+        dirty,
+        reason: "the host was released and wiped"
+      }), memberId, "interrupted");
+    },
+    sandboxes,
+    removeSandbox: (name) => {
+      stopContainer(name);
+    },
+    async clearShipRows() {
+      const out = [];
+      for (const r of cfg.routes.filter((x) => x.resolved?.shipsModelId)) {
+        try {
+          const found = await new Tracker(r, cfg.ship).clearForRelease(cfg.ship.name);
+          out.push({ route: r.route, ok: true, detail: found ? "cleared engaged, tunnel_status, relay_url" : "no Ships row for this ship" });
+        } catch (e) {
+          out.push({ route: r.route, ok: false, detail: e.message });
+        }
+      }
+      return out;
+    },
+    forgeHosts,
+    eraseForgeToken: (host) => eraseForgeToken(cfg.ship.forges, host, stateDir),
+    labeled: labeledDocker,
+    removeVolume: (name) => {
+      docker(["volume", "rm", "-f", name]);
+    },
+    removeImage: (name) => {
+      docker(["image", "rm", "-f", name]);
+    },
+    remaining() {
+      const left = [];
+      if (existsSync23(cfg.configFile)) left.push(`config ${cfg.configFile}`);
+      for (const h of forgeHosts()) if (hasForgeToken(cfg.ship.forges, h, stateDir)) left.push(`forge token for ${h}`);
+      try {
+        for (const k of readdirSync11(keysDir(stateDir))) left.push(`seat key ${k}`);
+      } catch {
+      }
+      for (const s of sandboxes()) left.push(`sandbox ${s}`);
+      try {
+        const { volumes, images } = labeledDocker();
+        for (const v of volumes) left.push(`volume ${v}`);
+        for (const i of images) left.push(`image ${i}`);
+      } catch (e) {
+        left.push(`docker could not be checked (${e.message})`);
+      }
+      for (const u of unitPaths()) left.push(`unit ${u}`);
+      if (loadedCrewLabels().length) left.push(`loaded units ${loadedCrewLabels().join(", ")}`);
+      return left;
+    }
+  };
 }
-var FileTail = class {
-  offset = 0;
-  decoder = new StringDecoder("utf8");
-  path;
-  constructor(path) {
-    this.path = path;
-  }
-  poll() {
-    let fd;
+
+// src/sandbox-cache.ts
+var execFileP = promisify(execFile);
+var realExec2 = (bin, args, o) => execFileP(bin, args, { env: o?.env ?? process.env, maxBuffer: 16 * 1024 * 1024 });
+var OPENSHELL_ATTACHABLE_LABEL = "openshell.ai/sandbox-attachable=true";
+var OPENSHELL_WORKSPACE_LABEL = "openshell.ai/sandbox-attachable-workspace";
+var VOLUME_ROOT = "/cache";
+var DEFAULT_CACHE_SETTINGS = {
+  engine: "docker",
+  workspace: "crew",
+  helperImage: "alpine/git:latest",
+  depsLockfile: "pnpm-lock.yaml"
+};
+function parseRemote(url) {
+  const u = url.trim();
+  const m = /^[a-z+]+:\/\/(?:[^@/]*@)?([^/:]+)(?::\d+)?\/(.+?)(?:\.git)?\/?$/i.exec(u) ?? /^(?:[\w.-]+@)?([\w.-]+):(?!\/\/)(.+?)(?:\.git)?\/?$/.exec(u);
+  if (!m) return null;
+  return { host: normalizeForgeHost(m[1]) || DEFAULT_FORGE_HOST, path: m[2].replace(/^\/+/, "") };
+}
+function mirrorRelPath(r) {
+  return `mirrors/${r.host}/${r.path}.git`;
+}
+function depsRelDir(r) {
+  return `cache/deps/${r.host}/${r.path}`;
+}
+var q = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+function cloneScript(o) {
+  const mirror = `${o.mirrorDir}/${mirrorRelPath(o.repo)}`;
+  const depsRoot = `${o.mirrorDir}/${depsRelDir(o.repo)}`;
+  return [
+    `git clone --quiet --shared ${q(mirror)} ${q(o.workDir)}`,
+    `cd ${q(o.workDir)}`,
+    `git remote set-url origin ${q(o.origin)}`,
+    `git checkout --quiet -b ${q(o.branch)}`,
+    // A missing lockfile or tree is not an error: the run installs as it would without a cache.
+    `{ if [ -f ${q(o.lockfile)} ]; then h=$(sha256sum ${q(o.lockfile)} | cut -c1-16); d=${q(depsRoot)}/$h; [ -d "$d" ] && cp -R -P "$d"/. . ; fi; true; }`
+  ].join(" && ");
+}
+var REFRESH_SCRIPT = `
+set -e
+m=${VOLUME_ROOT}/"$1"; url="$2"
+export GIT_TERMINAL_PROMPT=0
+git config --global --add safe.directory '*'
+if [ -n "$CREW_FORGE_TOKEN" ]; then
+  H="Authorization: Basic $(printf '%s:%s' "$CREW_FORGE_USER" "$CREW_FORGE_TOKEN" | base64 | tr -d '\\n')"
+  git() { command git -c "http.extraHeader=$H" "$@"; }
+fi
+if [ -d "$m" ]; then
+  git -C "$m" fetch --prune --atomic --quiet origin
+else
+  mkdir -p "$(dirname "$m")"; rm -rf "$m.tmp"
+  git clone --mirror --quiet "$url" "$m.tmp"
+  git -C "$m.tmp" config gc.auto 0
+  mv "$m.tmp" "$m"
+fi
+date -u +%Y-%m-%dT%H:%M:%SZ > "$m/crew-last-refresh"
+`;
+var DEPS_SCRIPT = `
+set -e
+m=${VOLUME_ROOT}/"$1"; droot=${VOLUME_ROOT}/"$2"; lock="$3"
+export GIT_TERMINAL_PROMPT=0
+git config --global --add safe.directory '*'
+git -C "$m" cat-file -e HEAD:"$lock" 2>/dev/null || exit 0
+h=$(git -C "$m" show HEAD:"$lock" | sha256sum | cut -c1-16)
+[ -d "$droot/$h" ] && exit 0
+w=$(mktemp -d); trap 'rm -rf "$w"' EXIT
+git clone --quiet --shared "$m" "$w/src"
+cd "$w/src"
+sh -c "$CREW_DEPS_COMMAND"
+mkdir -p "$droot/$h.tmp"
+find . -name node_modules -type d -prune | while read -r p; do
+  mkdir -p "$droot/$h.tmp/$(dirname "$p")"; cp -R -P "$p" "$droot/$h.tmp/$p"
+done
+rm -rf "$droot/$h"; mv "$droot/$h.tmp" "$droot/$h"
+`;
+var SandboxCache = class {
+  s;
+  exec;
+  constructor(s, exec = realExec2) {
+    this.s = s;
+    this.exec = exec;
+  }
+  engine(args, env) {
+    return this.exec(this.s.engine, args, { env });
+  }
+  /** Creates the volume with the labels OpenShell and `crew deprovision` look for, if it is not there. */
+  async ensureVolume() {
     try {
-      fd = openSync3(this.path, "r");
+      await this.engine(["volume", "inspect", this.s.volume]);
+      return false;
     } catch {
-      return "";
-    }
-    try {
-      let text2 = "";
-      const chunk = Buffer.alloc(64 * 1024);
-      for (; ; ) {
-        const n = readSync(fd, chunk, 0, chunk.length, this.offset);
-        if (n <= 0) break;
-        this.offset += n;
-        text2 += this.decoder.write(chunk.subarray(0, n));
-      }
-      return text2;
-    } finally {
-      closeSync3(fd);
     }
+    await this.engine([
+      "volume",
+      "create",
+      "--label",
+      OPENSHELL_ATTACHABLE_LABEL,
+      "--label",
+      `${OPENSHELL_WORKSPACE_LABEL}=${this.s.workspace}`,
+      "--label",
+      DOCKER_LABEL_OWNER,
+      "--label",
+      DOCKER_LABEL_CACHE,
+      this.s.volume
+    ]);
+    return true;
+  }
+  helper(image, script, args, env = {}) {
+    const flags = Object.keys(env).flatMap((k) => ["-e", k]);
+    return this.engine(["run", "--rm", "--label", DOCKER_LABEL_OWNER, "-v", `${this.s.volume}:${VOLUME_ROOT}`, ...flags, "--entrypoint", "sh", image, "-c", script, "sh", ...args], { ...process.env, ...env });
   }
-};
-var TAIL_POLL_MS = 200;
-var RunObserver = class {
-  cycles = [];
-  attribution = new TicketAttributionTracker();
-  /** Hand-off writes and their outcomes, to tell a run whose hand-off never landed (CREW-2363). */
-  handoff = new HandoffTranscriptTracker();
-  result;
-  /** Prefix tokens of the first assistant call that carried usage; kept once. */
-  prefixTokens;
-  /** Set once the stream carries the harness's final result (turn count or cost). */
-  sawResult = false;
-  muted = false;
   /**
-   * The label stamped on events. Starts as the poll hint and switches to the
-   * ticket the run actually claims (CREW-1776); `id.ticket` stays the hint.
+   * Refreshes every mirror (and, where configured, its dependency tree). One
+   * repository failing does not stop the others; the caller raises attention
+   * for the failures and the runs keep using the previous mirror state.
    */
-  liveTicket;
-  /** Called after `liveTicket` changes, so the sidecar can be rewritten. */
-  onClaim;
-  buf = "";
-  mapper;
-  id;
-  adapter;
-  eventsSink;
-  emitCycle;
-  constructor(id, adapter, eventsSink, emitCycle) {
-    this.id = id;
-    this.adapter = adapter;
-    this.eventsSink = eventsSink;
-    this.emitCycle = emitCycle;
-    this.liveTicket = id.ticket ?? void 0;
-    this.mapper = adapter.createStreamMapper?.() ?? { map: (p) => adapter.mapStreamLine(p), flush: () => [] };
-  }
-  feed(text2) {
-    this.buf += text2;
-    const lines2 = this.buf.split("\n");
-    this.buf = lines2.pop() ?? "";
-    for (const line of lines2) this.handleLine(line);
+  async refresh(repos) {
+    await this.ensureVolume();
+    const out = [];
+    for (const r of repos) {
+      const env = r.token ? { CREW_FORGE_TOKEN: r.token, CREW_FORGE_USER: r.username ?? DEFAULT_FORGE_USERNAME } : {};
+      try {
+        await this.helper(this.s.helperImage, REFRESH_SCRIPT, [mirrorRelPath(r), forgeDescriptorFor(r.host).httpsUrl(r.host, r.path)], env);
+      } catch (e) {
+        out.push({ repo: r, ok: false, detail: describe(e) });
+        continue;
+      }
+      if (this.s.depsCommand && this.s.depsImage) {
+        try {
+          await this.helper(this.s.depsImage, DEPS_SCRIPT, [mirrorRelPath(r), depsRelDir(r), this.s.depsLockfile], { CREW_DEPS_COMMAND: this.s.depsCommand });
+        } catch (e) {
+          out.push({ repo: r, ok: false, detail: `dependency tree: ${describe(e)}` });
+          continue;
+        }
+      }
+      out.push({ repo: r, ok: true });
+    }
+    return out;
   }
-  end() {
-    if (this.buf) this.handleLine(this.buf);
-    this.buf = "";
+  /** Mirrors in the volume with their last refresh; empty when the volume does not exist. */
+  async list() {
     try {
-      this.consume(void 0, this.mapper.flush());
+      await this.engine(["volume", "inspect", this.s.volume]);
     } catch {
+      return [];
+    }
+    const script = `cd ${VOLUME_ROOT}/mirrors 2>/dev/null || exit 0; find . -name '*.git' -type d -prune | while read -r d; do printf '%s\\t%s\\n' "\${d#./}" "$(cat "$d/crew-last-refresh" 2>/dev/null)"; done`;
+    const { stdout } = await this.helper(this.s.helperImage, script, []);
+    const rows = [];
+    for (const line of stdout.split("\n").filter(Boolean)) {
+      const [rel, when] = line.split("	");
+      const m = /^([^/]+)\/(.+)\.git$/.exec(rel ?? "");
+      if (m) rows.push({ repo: { host: m[1], path: m[2] }, lastRefresh: when?.trim() || null });
     }
+    return rows;
   }
-  handleLine(line) {
-    if (!line) return;
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      return;
+  /** Drops mirrors (and their dependency trees) for repositories not in `keep`. Returns what was dropped. */
+  async prune(keep) {
+    const have = new Set(keep.map((r) => `${r.host}/${r.path}`));
+    const drop = (await this.list()).map((m) => m.repo).filter((r) => !have.has(`${r.host}/${r.path}`));
+    for (const r of drop) {
+      await this.helper(this.s.helperImage, `rm -rf ${VOLUME_ROOT}/${q(mirrorRelPath(r))} ${VOLUME_ROOT}/${q(depsRelDir(r))}`, []);
     }
+    return drop;
+  }
+  /** Recreates the volume empty; the next pass refreshes every mirror. */
+  async reset() {
     try {
-      const got = this.adapter.extractResult(parsed);
-      if (got) {
-        this.result = { ...this.result, ...Object.fromEntries(Object.entries(got).filter(([, v]) => v !== void 0)) };
-        if (got.numTurns !== void 0 || got.costUsd !== void 0) this.sawResult = true;
-      }
-      this.handoff.feed(parsed);
-      this.consume(parsed, this.mapper.map(parsed));
-    } catch {
+      await this.engine(["volume", "rm", "--force", this.s.volume]);
+    } catch (e) {
+      throw new Error(`could not remove volume ${this.s.volume}: ${describe(e)}`);
     }
+    await this.ensureVolume();
   }
-  // Turns mapped events (and, when there is a source line, its token usage)
-  // into sink writes and buffered cycles. `parsed` is undefined for events
-  // the mapper flushes at end of stream, which have no line of their own.
-  consume(parsed, events) {
-    const plan = this.id;
-    let turnText = "";
-    for (const ev of events) if ((ev.kind === "thought" || ev.kind === "text") && ev.text) this.attribution.note(ev.text);
-    for (const ev of events) {
-      if (ev.kind === "tool") this.attribution.noteWrite(ev.tool, ev.input);
-      if (ev.kind === "tool" && isClaimWrite(ev.tool, ev.input)) {
-        const claimed = this.attribution.current;
-        if (claimed && claimed !== this.liveTicket) {
-          if (!this.muted) {
-            this.eventsSink?.write(`${JSON.stringify({
-              at: (/* @__PURE__ */ new Date()).toISOString(),
-              cycle: this.emitCycle,
-              route: plan.route,
-              step: "agent",
-              level: "info",
-              message: `ticket: ${this.liveTicket ?? "none"} \u2192 ${claimed}`,
-              role: plan.role,
-              ticket: claimed,
-              data: { kind: "ticket", from: this.liveTicket ?? null, to: claimed }
-            })}
-`);
-          }
-          this.liveTicket = claimed;
-          if (!this.muted) this.onClaim?.();
-        }
-      }
-      const e = {
-        at: (/* @__PURE__ */ new Date()).toISOString(),
-        cycle: this.emitCycle,
-        route: plan.route,
-        step: "agent",
-        level: "info",
-        message: ev.kind === "tool" ? `${ev.tool ?? "tool"}${ev.target ? ` ${ev.target}` : ""}` : ev.kind,
-        role: plan.role,
-        ...this.liveTicket ? { ticket: this.liveTicket } : {},
-        data: { kind: ev.kind, ...ev.text ? { text: ev.text } : {}, ...ev.tool ? { tool: ev.tool } : {}, ...ev.target ? { target: ev.target } : {} }
-      };
-      if (!this.muted) this.eventsSink?.write(`${JSON.stringify(e)}
-`);
-      if ((ev.kind === "thought" || ev.kind === "text") && ev.text) {
-        turnText += `${ev.text}
-`;
-        const cycleIndex = this.cycles.length;
-        this.cycles.push({
-          cycleIndex,
-          occurredAt: e.at,
-          thinking: ev.text,
-          // A conversational `text` turn is tagged 'assistant' so it's
-          // distinguishable from a thinking block once both share this
-          // buffer (ISSUE-594) — matching the precedent
-          // `agent-chat.service.ts`'s logChatRun (ISSUE-504) already set
-          // for the same column. A `thought` cycle stays untagged, same
-          // as before this change.
-          ...ev.kind === "text" ? { role: "assistant" } : {}
-        });
-        if (!this.muted) {
-          this.eventsSink?.write(`${JSON.stringify({
-            ...e,
-            message: "cycle",
-            data: { kind: "cycle", cycleIndex, text: ev.text }
-          })}
-`);
-        }
+};
+function describe(e) {
+  const err3 = e;
+  return (err3.stderr?.trim() || err3.message || String(e)).split("\n").slice(-3).join(" / ");
+}
+function cacheSettingsOf(cfg) {
+  if (!cfg?.cacheVolume) return null;
+  return {
+    engine: cfg.engine ?? DEFAULT_CACHE_SETTINGS.engine,
+    volume: cfg.cacheVolume,
+    workspace: cfg.cacheWorkspace ?? DEFAULT_CACHE_SETTINGS.workspace,
+    helperImage: cfg.cacheImage ?? DEFAULT_CACHE_SETTINGS.helperImage,
+    depsImage: cfg.depsImage ?? cfg.image,
+    depsCommand: cfg.depsCommand,
+    depsLockfile: cfg.depsLockfile ?? DEFAULT_CACHE_SETTINGS.depsLockfile
+  };
+}
+var sandboxCacheKey = (volume, r) => `sandbox_cache:${volume}:${r.host}/${r.path}`;
+var CACHE_REFRESH_INTERVAL_MS = 6e4;
+function makeCachePass(o) {
+  const now = o.now ?? Date.now;
+  let last = -Infinity;
+  return async () => {
+    if (now() - last < CACHE_REFRESH_INTERVAL_MS) return [];
+    last = now();
+    const all = [];
+    for (const r of o.repos()) {
+      let release;
+      try {
+        release = o.lock(r.dir);
+        all.push(...await o.cache.refresh([r]));
+      } catch (e) {
+        all.push({ repo: r, ok: false, detail: describe(e) });
+      } finally {
+        release?.();
       }
     }
-    if (this.prefixTokens === void 0 && parsed !== void 0) this.prefixTokens = this.adapter.extractPrefixTokens?.(parsed);
-    const turnTokens = parsed === void 0 ? void 0 : this.adapter.extractTurnTokens(parsed);
-    if (turnTokens !== void 0) this.attribution.add(turnText, turnTokens);
-  }
+    for (const out of all) {
+      const key = sandboxCacheKey(o.volume, out.repo);
+      if (out.ok) o.ok(key);
+      else await o.fail(key, `sandbox cache: ${out.repo.host}/${out.repo.path} did not refresh (${out.detail}); runs use the previous mirror. Resumes automatically when a later pass refreshes it`);
+    }
+    return all;
+  };
+}
+
+// src/runner.ts
+var execFileP2 = promisify2(execFile2);
+var DEFAULT_SANDBOX_CONFIG = {
+  bin: "openshell",
+  mirrorDir: "/cache",
+  workDir: "/sandbox/work"
 };
-function writeRunMeta(id, startedAt, liveTicket, extra) {
-  try {
-    writeFileSync15(`${id.streamPath}.meta.json`, JSON.stringify({
-      route: id.route,
-      role: id.role,
-      hint: id.ticket,
-      ticket: liveTicket ?? id.ticket,
-      startedAt,
-      model: id.model,
-      toolchain: id.toolchain,
-      harness: id.harness,
-      provider: id.provider,
-      exitCode: null,
-      running: true,
-      ...extra
-    }));
-  } catch {
+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 = spawn3(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 function finishRun(id, obs, emit, startedAt, end, agentLogKey, hintMoved) {
-  let moved = false;
-  if (hintMoved) {
-    try {
-      moved = await hintMoved();
-    } catch {
-    }
+  async kill(handle) {
+    if (handle.pid !== void 0) await killRunGroup(handle.pid);
   }
-  const { ticket: attributedTicket, by: attributedBy } = obs.attribution.decide(obs.liveTicket, { hintMoved: moved });
-  const identity = { toolchain: id.toolchain, harness: id.harness, provider: id.provider };
-  const { result } = obs;
-  const pending = end.interrupted ? null : obs.handoff.pending();
-  if (pending) {
+  isAlive(handle) {
+    if (handle.pid === void 0) return false;
     try {
-      const now = /* @__PURE__ */ new Date();
-      writePendingHandoff(stateDirOfStream(id.streamPath), {
-        ...pending,
-        version: 1,
-        route: id.route,
-        role: id.role,
-        ...attributedTicket ? { ticket: attributedTicket } : {},
-        streamPath: id.streamPath,
-        createdAt: now.toISOString(),
-        attempts: 0,
-        nextAttemptAt: now.toISOString()
-      });
+      process.kill(handle.pid, 0);
+      return true;
     } catch (e) {
-      emit.warn(`could not save the pending hand-off: ${e.message}`, { step: "agent" });
+      return e.code === "EPERM";
     }
   }
-  try {
-    writeRunMeta(id, startedAt, obs.liveTicket, {
-      attributedTicket: attributedTicket ?? null,
-      attributedBy,
-      running: void 0,
-      exitCode: end.code,
-      ...end.interrupted ? { interrupted: end.interrupted } : {},
-      ...pending ? { handoff: "pending" } : {},
-      sessionId: result?.sessionId ?? null,
-      numTurns: result?.numTurns ?? null,
-      prefixTokens: obs.prefixTokens ?? null,
-      totalCostUsd: result?.costUsd ?? null
-    });
-  } catch {
+  reattach(meta) {
+    return { runner: "host", pid: meta.pid };
   }
-  const ms3 = Date.now() - Date.parse(startedAt);
-  emit.emit(end.interrupted ? "agent run interrupted" : `agent run finished (${pending ? "hand-off pending" : `exit ${end.code ?? "unknown"}`})`, {
-    data: {
-      ms: ms3,
-      code: end.code,
-      ...pending ? { handoff: "pending" } : {},
-      ...end.interrupted ? { interrupted: end.interrupted } : {},
-      ...identity,
-      attributedTicket: attributedTicket ?? null,
-      attributedBy,
-      ...result?.sessionId ? { sessionId: result.sessionId } : {},
-      ...result?.numTurns !== void 0 ? { numTurns: result.numTurns } : {},
-      ...result?.costUsd !== void 0 ? { totalCostUsd: result.costUsd } : {}
+  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 execFileP2(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 repo = parseRemote(origin);
+    if (!repo) throw new Error(`cannot read a forge host and path from the origin remote ${origin}`);
+    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 }] }
+      }));
     }
-  });
-  if (id.agentLog && agentLogKey) {
-    const report = {
-      ticketReference: attributedTicket,
-      outcome: end.interrupted ? "interrupted" : end.code === 0 || end.code === null && obs.sawResult ? "success" : "error",
-      startedAt,
-      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      cycles: obs.cycles,
-      model: id.model,
-      tokensIn: result?.inputTokens,
-      tokensOut: result?.outputTokens,
-      cacheReadTokens: result?.cacheReadTokens,
-      cacheWriteTokens: result?.cacheWriteTokens,
-      costUsd: result?.costUsd,
-      // Both come from a finished run: without the result line (interrupted) neither is trustworthy.
-      ...result?.numTurns !== void 0 ? { numTurns: result.numTurns } : {},
-      ...result?.numTurns !== void 0 && obs.prefixTokens !== void 0 ? { prefixTokens: obs.prefixTokens } : {},
-      harness: identity.harness,
-      provider: identity.provider,
-      promptVersion: id.promptVersion,
-      promptSha: id.promptSha
-    };
+    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 {
-      const sent = await reportAgentRun({ ...id.agentLog, apiKey: agentLogKey }, report);
-      try {
-        clearShipAttention(new State(stateDirOfStream(id.streamPath)), agentLogRefusedKey(id.route));
-      } catch {
-      }
-      if (sent.counterWarning) emit.warn(sent.counterWarning, { step: "agent" });
-      if (sent.counterRetry) {
-        try {
-          queueTicketCounters(stateDirOfStream(id.streamPath), basename8(id.streamPath, ".jsonl"), {
-            version: 1,
-            route: id.route,
-            role: id.role,
-            target: id.agentLog,
-            write: sent.counterRetry,
-            attempts: 0,
-            nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        } catch {
-        }
-      }
+      await this.os(create2, { env: createEnv });
     } catch (e) {
-      if (e instanceof AgentLogUnreachableError) {
-        try {
-          queueAgentRun(stateDirOfStream(id.streamPath), basename8(id.streamPath, ".jsonl"), {
-            version: 1,
-            route: id.route,
-            role: id.role,
-            target: id.agentLog,
-            report,
-            attempts: 0,
-            nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          emit.warn(`could not report agent log (${e.message}); queued to retry`, { step: "agent" });
-          return { ms: ms3, ticket: attributedTicket, handoffPending: !!pending };
-        } catch {
-        }
-      }
-      if (e instanceof AgentLogHttpError && e.row && e.status >= 400 && e.status < 500) {
+      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 = cloneScript({
+        mirrorDir: cfg.mirrorDir,
+        repo,
+        workDir: cfg.workDir,
+        origin,
+        branch,
+        lockfile: cfg.depsLockfile ?? DEFAULT_CACHE_SETTINGS.depsLockfile
+      });
+      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(join25(tmpdir3(), "crew-prompt-"));
         try {
-          await raiseShipAttention(
-            { state: new State(stateDirOfStream(id.streamPath)), emit },
-            agentLogRefusedItem(id.route, id.role, e.status)
-          );
-        } catch {
+          const file = join25(tmp, "prompt.txt");
+          writeFileSync14(file, plan.prompt, { mode: 384 });
+          await this.os(["sandbox", "upload", name, file, SANDBOX_PROMPT_PATH]);
+        } finally {
+          rmSync13(tmp, { recursive: true, force: true });
         }
       }
-      emit.warn(`could not report agent log: ${e.message}`, { step: "agent" });
-    }
-  }
-  return { ms: ms3, ticket: attributedTicket, handoffPending: !!pending };
-}
-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);
-  let streamFd;
-  try {
-    mkdirSync13(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 command2 = viaUpload ? ["sh", "-c", `exec ${[harness, ...plan.args].map(shQuote2).join(" ")} < ${SANDBOX_PROMPT_PATH}`] : [harness, ...plan.args];
+      const child = spawn3(cfg.bin, ["sandbox", "exec", "-n", name, "--no-login-shell", "--workdir", cfg.workDir, "--", ...command2], {
+        env: process.env,
+        stdio: ["pipe", o.streamFd, "inherit"],
+        detached: true
+      });
+      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)}`);
+    }
   }
-  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);
-    return failed(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 });
   }
-  if (begun instanceof Promise) {
-    return begun.then(
-      (run3) => {
-        closeSync3(streamFd);
-        return supervise(run3);
-      },
-      (e) => {
-        closeSync3(streamFd);
-        return failed(e);
-      }
-    );
+  isAlive(handle) {
+    return new HostRunner().isAlive(handle);
   }
-  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 {
-          writeFileSync15(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
-        } catch {
-        }
-      }
-      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);
-    });
+  reattach(meta) {
+    return { runner: "sandbox", pid: meta.pid, sandbox: meta.sandbox, sandboxBin: meta.sandboxBin };
   }
-}
-async function reattachRun(streamPath, sc, emit, o = {}) {
-  const adapter = adapterFor(sc.harness);
-  const isAlive = o.isAlive ?? runIsAlive;
-  const id = { ...sc, streamPath };
-  const eventsSink = openSink(sc.eventsPath);
-  const obs = new RunObserver(id, adapter, eventsSink, emit.cycle);
-  const tail3 = new FileTail(streamPath);
-  obs.muted = true;
-  obs.feed(tail3.poll());
-  obs.muted = false;
-  const runner = runnerOfSidecar(sc);
-  const adopted = isAlive(sc);
-  let killed;
-  if (adopted) {
-    o.onAdopted?.();
-    const pollMs = o.pollMs ?? TAIL_POLL_MS;
-    while (isAlive(sc)) {
-      obs.feed(tail3.poll());
-      if (!killed && (msUntilDeadline(sc.deadline) ?? 1) <= 0) {
-        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));
+  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 execFileP2(bin, ["sandbox", "delete", name], { timeout: 6e4 });
+    } catch {
     }
   }
-  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,
-    obs,
-    emit,
-    sc.spawnedAt,
-    { code: null, ...interrupted ? { interrupted } : {} },
-    o.agentLogKey
-  );
-  return { adopted, ...interrupted ? { interrupted } : {}, ...killed ? { killed } : {}, ms: ms3, ticket };
-}
-
-// src/seat-keys.ts
-import { hostFromUrl as hostFromUrl2 } from "@tablation/client";
-var SEAT_KEY_ROLES = ROLE_NAMES.filter((r) => r !== "pair");
-function keyIsAdmin(route2) {
-  const role = route2.resolved?.role;
-  return role === void 0 || role === "WORKSPACE_ADMIN" || role === "PLATFORM_ADMIN";
+};
+function describeExecError(e) {
+  const err3 = e;
+  return (err3.stderr?.trim() || err3.message || String(e)).split("\n").slice(-3).join(" / ");
 }
-var MEMBER_NO_ROW = "has no linked Agents row \u2014 a workspace admin's `crew agents sync` creates the persona rows; run it here afterwards to link this ship's seats";
-var MEMBER_NO_KEY = 'no agent key for this seat \u2014 run `crew agents sync` (needs the "Mint agent keys" capability on your role)';
-var FORBIDDEN_LINE = 'seat keys: not minted \u2014 your role does not grant "Mint agent keys"; ask a workspace admin to add it to your project role (or run sync with an admin key)';
-function seatKeySlug(workspaceSlug, agentId) {
-  return `${workspaceSlug}#agent:${agentId}`;
+function gitOrigin(cwd) {
+  try {
+    return execFileSync7("git", ["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
 }
-function slugFor(route2, agentId) {
-  const [workspaceSlug] = splitRoute(route2.route);
-  return seatKeySlug(workspaceSlug, agentId);
+function runnerFor(kind, sandbox) {
+  return kind === "sandbox" ? new SandboxRunner(sandbox) : new HostRunner();
 }
-function seatAgentId(route2, role) {
-  return route2.resolved?.agentPersonas?.[role]?.agentId;
+function runnerOfSidecar(sc) {
+  return sc.runner === "sandbox" ? new SandboxRunner(sc.sandboxBin ? { bin: sc.sandboxBin } : {}) : new HostRunner();
 }
-async function resolveReleaseKey(route2, getStore = getSessionStore) {
-  const ship = (reason) => ({ kind: "ship", apiKey: resolveApiKey(route2), reason });
-  const agentId = route2.resolved?.releaseAgentId;
-  if (!agentId) return ship(keyIsAdmin(route2) ? "release seat has no linked Agents row (run `crew agents sync`)" : `release seat ${MEMBER_NO_ROW}`);
+function checkSandboxRunner(cfg = {}, run3 = (b, a) => execFileSync7(b, a, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 15e3 })) {
+  const bin = cfg.bin ?? DEFAULT_SANDBOX_CONFIG.bin;
+  let version;
   try {
-    const session = await getStore().get(hostFromUrl2(route2.baseUrl), slugFor(route2, agentId));
-    if (session?.apiKey) return { kind: "agent", apiKey: session.apiKey, agentId };
-    return ship(keyIsAdmin(route2) ? "no agent key stored for the release seat (run `crew agents sync`)" : MEMBER_NO_KEY);
+    version = run3(bin, ["--version"]).trim();
   } catch (e) {
-    const reason = describeReadError(e);
-    return { kind: "ship", apiKey: resolveApiKey(route2), reason, storeError: reason };
+    return { ok: false, detail: `${bin} is not installed or not on the scheduler PATH (${e.message.split("\n")[0]})` };
   }
-}
-async function resolveSeatKey(route2, role, getStore = getSessionStore) {
-  const ship = (reason) => ({ kind: "ship", apiKey: resolveApiKey(route2), reason });
-  if (!SEAT_KEY_ROLES.includes(role)) return ship(`${role} always writes as the ship`);
-  const agentId = seatAgentId(route2, role);
-  if (!agentId) return ship(keyIsAdmin(route2) ? "seat has no linked Agents row (run `crew agents sync`)" : `seat ${MEMBER_NO_ROW}`);
   try {
-    const session = await getStore().get(hostFromUrl2(route2.baseUrl), slugFor(route2, agentId));
-    if (session?.apiKey) return { kind: "agent", apiKey: session.apiKey, agentId };
-    return ship(keyIsAdmin(route2) ? "no agent key stored for this seat (run `crew agents sync`)" : MEMBER_NO_KEY);
+    run3(bin, ["status"]);
   } catch (e) {
-    const reason = describeReadError(e);
-    return { kind: "ship", apiKey: resolveApiKey(route2), reason, storeError: reason };
-  }
-}
-function safeStderrLine(e) {
-  const err3 = e;
-  const raw = typeof err3?.stderr === "string" && err3.stderr.trim() ? err3.stderr : typeof err3?.message === "string" ? err3.message : "";
-  for (const line of raw.split("\n")) {
-    const t = line.trim();
-    if (!t || /^Command failed:/i.test(t) || /(^|\s)-w(\s|$)/.test(t)) continue;
-    return t.slice(0, 120);
+    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 void 0;
+  return { ok: true, detail: version };
 }
-function describeReadError(e) {
-  const fsErr = e;
-  if (typeof fsErr?.path === "string" && typeof fsErr.code === "string") return `key file store unreadable (${fsErr.code})`;
-  const code = e?.code;
-  const line = safeStderrLine(e);
-  const what = typeof code === "number" ? `security exited ${code}` : typeof code === "string" ? `security failed: ${code}` : void 0;
-  const detail = [what, line].filter(Boolean).join(what && line ? ": " : "");
-  return detail ? `OS keychain unavailable (${detail})` : "OS keychain unavailable";
+
+// src/agent.ts
+var DIGEST_MAX_AGE_SECONDS = 600;
+var LEGACY_TOOLCHAIN_HARNESS = "claude";
+var LEGACY_TOOLCHAIN_PROVIDER = "anthropic";
+function scrubbedEnv(env = process.env, harness = LEGACY_TOOLCHAIN_HARNESS) {
+  const out = { ...env };
+  for (const v of adapterFor(harness).unsetEnv) delete out[v];
+  return out;
 }
-function keychainExitCode(reason) {
-  const m = /security exited (\d+)/.exec(reason);
-  return m ? Number(m[1]) : void 0;
+var CREW_LANE_ROLE_VAR = "CREW_LANE_ROLE";
+function assemblePrompt(p) {
+  const sections = [p.roster, p.environment, `${p.common}${p.brief}`];
+  if (p.digest) sections.push(p.digest);
+  return sections.join("\n\n");
 }
-function describeStoreError(e) {
-  const msg = e instanceof Error ? e.message : String(e);
-  if (/User interaction is not allowed/i.test(msg)) {
-    return "keychain unavailable (User interaction is not allowed \u2014 run from a logged-in session, or `security unlock-keychain` first)";
+var AgentError = class extends Error {
+};
+var AgentSpawnError = class extends AgentError {
+};
+var WorkspaceAuthRefused = class extends AgentSpawnError {
+};
+var WorkspaceAllowanceExhausted = class extends AgentError {
+};
+var ALLOWANCE_REFUSAL_MARKER = "AI_ALLOWANCE_EXCEEDED";
+function streamShowsAllowanceRefusal(streamPath) {
+  let raw;
+  try {
+    raw = readFileSync21(streamPath, "utf8");
+  } catch {
+    return false;
+  }
+  if (!raw.includes(ALLOWANCE_REFUSAL_MARKER)) return false;
+  for (const line of raw.split("\n")) {
+    if (!line.includes(ALLOWANCE_REFUSAL_MARKER)) continue;
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof ev !== "object" || ev === null) continue;
+    const e = ev;
+    if (e.type === "result" && e.is_error === true) {
+      if (typeof e.result === "string" && e.result.includes(ALLOWANCE_REFUSAL_MARKER)) return true;
+    } else if (e.type === "assistant" && (e.isApiErrorMessage === true || e.error !== void 0)) {
+      if (JSON.stringify(e.message ?? "").includes(ALLOWANCE_REFUSAL_MARKER)) return true;
+    }
+  }
+  return false;
+}
+var digestPathFor = (stateDir, routeLabel, role, runId) => join26(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
+function planAgentRun(o) {
+  const briefPath = join26(o.route.promptsDir, "personas", `lane-${o.role}.md`);
+  if (!existsSync24(briefPath)) {
+    throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
+  }
+  const commonPath = join26(o.route.promptsDir, "personas", "common.md");
+  const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync24(commonPath);
+  const now = o.now ?? (() => Date.now());
+  const routeLabel = routeSlug(o.route.route);
+  const ownDigest = o.runId ? digestPathFor(o.stateDir, routeLabel, o.role, o.runId) : void 0;
+  const digestPath2 = ownDigest && existsSync24(ownDigest) ? ownDigest : digestPathFor(o.stateDir, routeLabel, o.role);
+  let digest;
+  let ageSeconds;
+  if (existsSync24(digestPath2)) {
+    ageSeconds = Math.floor((now() - statSync7(digestPath2).mtimeMs) / 1e3);
+    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync21(digestPath2, "utf8");
+  }
+  const common = usesCommon ? readFileSync21(commonPath, "utf8") : "";
+  const brief = readFileSync21(briefPath, "utf8");
+  const effectiveCommon = o.divergedPrompt ? "" : common;
+  const effectiveBrief = appendAdditions(o.divergedPrompt ?? brief, o.personaAdditions);
+  const localSkills = new Map(listLocalSkills(o.route.promptsDir).map((s) => [s.name, s.prompt]));
+  let expanded;
+  try {
+    expanded = expandSkillMarkers(
+      `${effectiveCommon}${effectiveBrief}`,
+      (name) => o.skillOverrides?.[name] ?? localSkills.get(name)
+    );
+  } catch (e) {
+    if (e instanceof SkillIncludeError) throw new AgentError(`${e.message} \u2014 refusing to run an unscoped session`);
+    throw e;
+  }
+  const prompt = assemblePrompt({
+    roster: o.roster,
+    environment: o.environment,
+    common: "",
+    brief: expanded.text,
+    digest
+  });
+  const promptSha = createHash6("sha256").update(expanded.text).digest("hex");
+  const streamsDir = join26(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;
+  let toolchain = seat.toolchain;
+  if (toolchain.auth === "workspace") {
+    if (!o.apiKey || o.seatKind === "ship") {
+      throw new WorkspaceAuthRefused(`${o.role}: toolchain ${toolchain.name} has auth: workspace, which needs the seat's own agent key \u2014 this seat would fall back to the ship key (run \`crew agents sync\`)`);
+    }
+    if (!o.route.resolved) {
+      throw new WorkspaceAuthRefused(`${o.role}: toolchain ${toolchain.name} has auth: workspace, but route ${o.route.route} is not connected (run \`crew connect\`)`);
+    }
+    toolchain = { ...toolchain, inference: { baseUrl: inferenceBaseUrl(o.route.baseUrl, o.route.resolved.workspaceId), token: o.apiKey } };
+  }
+  const adapter = adapterFor(toolchain.harness);
+  const invocation = adapter.invocation(toolchain, {
+    role: o.role,
+    model,
+    // Skipped when there's no key to send: a route `crew connect` hasn't
+    // resolved yet has nothing to authenticate the MCP connection with either.
+    mcp: o.apiKey ? { url: `${o.route.baseUrl}/api/mcp`, keyVar: API_KEY_VAR } : void 0
+  });
+  const columns = resolveContract(o.route.contract).columns;
+  const agentLog = o.route.resolved && o.apiKey ? {
+    baseUrl: o.route.baseUrl,
+    workspaceId: o.route.resolved.workspaceId,
+    apiKey: o.apiKey,
+    userAgent: o.ship.userAgent,
+    agentId: o.resolvedAgentId,
+    ...o.route.resolved.models?.issues ? { tickets: {
+      issuesModelId: o.route.resolved.models.issues,
+      keyColumn: columns.key,
+      tagColumn: columns.tag,
+      counters: {
+        agentRuns: columns.agentRuns,
+        tokensIn: columns.tokensIn,
+        tokensOut: columns.tokensOut,
+        cacheReadTokens: columns.cacheReadTokens,
+        cacheWriteTokens: columns.cacheWriteTokens,
+        costUsd: columns.costUsd
+      }
+    } } : {}
+  } : void 0;
+  return {
+    role: o.role,
+    route: routeLabel,
+    // The route's directory, which is a STARTING POINT and not the
+    // ticket's repo: the session picks its own working directory even when
+    // the runner already selected a ticket (`o.repo` is known then, and
+    // only feeds the per-repo toolchain choice). Where an area spans
+    // several repos this is whichever one `repos` happened to list first
+    // (config.ts), and the digest's `repo` column is what actually places
+    // the work. Kept deliberately rather than guessed at (ISSUE-349).
+    cwd: o.route.dir,
+    bin: invocation.bin,
+    args: invocation.args,
+    toolchain: toolchain.name,
+    harness: toolchain.harness,
+    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,
+    promptBytes: Buffer.byteLength(prompt, "utf8"),
+    unsetEnv: adapter.unsetEnv,
+    setEnv: {
+      ...o.apiKey ? { [API_KEY_VAR]: o.apiKey } : {},
+      ...adapter.runEnv(toolchain),
+      // The operator's global SessionStart hook (pair-context-hook.sh) injects
+      // the interactive Pair persona's prompt for any session it can't tell
+      // apart from a person's own terminal. Every headless lane run this
+      // planner produces carries a real ticket brief already (`prompt`
+      // above) — it must never be replaced by the Pair persona with no
+      // ticket attached, which silently no-ops and strands the ticket
+      // in_progress (ISSUE-490, ISSUE-591). Setting this is what lets that
+      // hook tell the two apart; it has nothing to do with the run itself.
+      [CREW_LANE_ROLE_VAR]: o.role,
+      // CREW-2783: the ship's forge credential — git helper config plus the
+      // token as an env var for `gh` and friends. Empty without `forges:`.
+      ...forgeRunEnv(o.ship.forges, { crewCommand: crewCommandLine(), configFile: process.env.CREW_CONFIG, stateDir: o.stateDir })
+    },
+    digestAttached: digest !== void 0,
+    digestAgeSeconds: ageSeconds,
+    model,
+    streamPath: join26(streamsDir, `${base}.jsonl`),
+    eventsPath: join26(streamsDir, `${base}.events.jsonl`),
+    ticket: o.ticket,
+    ticketRecordId: o.ticketRecordId ?? null,
+    repo: o.repo ?? null,
+    routeName: o.route.route,
+    agentLog,
+    promptVersion: o.route.resolved?.agentPersonas?.[o.role]?.historyId,
+    promptSha
+  };
+}
+function describePlan(p) {
+  return [
+    `role:    ${p.role}`,
+    ...p.resolution ? [`resolved: toolchain ${p.toolchain} \u2190 ${p.resolution.toolchain}; model ${p.model} \u2190 ${p.resolution.model}${p.provider ? `; provider ${p.provider}` : ""}`] : [],
+    ...(p.warnings ?? []).map((w) => `warning: ${w}`),
+    // Only for a non-default toolchain, so a plain Claude run's output is unchanged.
+    ...p.toolchain && p.toolchain !== "claude" ? [`toolchain: ${p.toolchain} (${p.harness ?? "claude"})`] : [],
+    `cwd:     ${p.cwd}`,
+    `command: ${p.bin} ${p.args.join(" ")}`,
+    `prompt:  ${p.promptBytes} bytes on stdin (never argv)`,
+    `digest:  ${p.digestAttached ? `attached, ${p.digestAgeSeconds}s old` : "absent \u2014 the agent will fetch the tracker itself"}`,
+    `unset:   ${p.unsetEnv.join(" ")}`,
+    // The VALUE is deliberately absent: --dry-run output is pasted into
+    // tickets and chat.
+    `set:     ${Object.keys(p.setEnv).join(" ") || "(nothing)"}`,
+    `stream:  ${p.streamPath}`
+  ].join("\n");
+}
+var pidPathFor = (streamPath) => `${streamPath}.pid`;
+function readRunSidecar(streamPath) {
+  try {
+    const sc = JSON.parse(readFileSync21(pidPathFor(streamPath), "utf8"));
+    return typeof sc.pid === "number" && typeof sc.spawnedAt === "string" && typeof sc.role === "string" ? sc : null;
+  } catch {
+    return null;
+  }
+}
+function runIsAlive(sc) {
+  try {
+    process.kill(sc.pid, 0);
+  } catch (e) {
+    if (e.code !== "EPERM") return false;
+  }
+  const ps = spawnSync6("ps", ["-o", "lstart=", "-p", String(sc.pid)], { encoding: "utf8" });
+  const started = Date.parse(ps.stdout.trim());
+  if (ps.status !== 0 || Number.isNaN(started)) return ps.status === 0;
+  return Math.abs(started - Date.parse(sc.spawnedAt)) < 15e3;
+}
+function identityOf(plan, adapterHarness) {
+  return {
+    role: plan.role,
+    route: plan.route,
+    ticket: plan.ticket ?? null,
+    model: plan.model,
+    toolchain: plan.toolchain ?? LEGACY_TOOLCHAIN_HARNESS,
+    harness: adapterHarness,
+    provider: plan.provider ?? LEGACY_TOOLCHAIN_PROVIDER,
+    eventsPath: plan.eventsPath,
+    streamPath: plan.streamPath,
+    agentLog: plan.agentLog ? withoutKey(plan.agentLog) : void 0,
+    promptVersion: plan.promptVersion,
+    promptSha: plan.promptSha
+  };
+}
+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)`, {
+    role,
+    ...ticket ? { ticket } : {},
+    data: { event: "run_killed", reason: WALL_CLOCK_REASON, limitMinutes: limit, elapsedMs, pid }
+  });
+  await kill();
+  return { limitMinutes: limit, elapsedMs };
+}
+var withoutKey = ({ apiKey: _apiKey, ...rest }) => rest;
+function openSink(path) {
+  try {
+    mkdirSync13(dirname9(path), { recursive: true });
+    return createWriteStream(path, { flags: "a" });
+  } catch {
+    return void 0;
+  }
+}
+function endSink(sink) {
+  if (!sink) return Promise.resolve();
+  sink.end();
+  return finished(sink).catch(() => void 0);
+}
+var FileTail = class {
+  offset = 0;
+  decoder = new StringDecoder("utf8");
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  poll() {
+    let fd;
+    try {
+      fd = openSync3(this.path, "r");
+    } catch {
+      return "";
+    }
+    try {
+      let text2 = "";
+      const chunk = Buffer.alloc(64 * 1024);
+      for (; ; ) {
+        const n = readSync(fd, chunk, 0, chunk.length, this.offset);
+        if (n <= 0) break;
+        this.offset += n;
+        text2 += this.decoder.write(chunk.subarray(0, n));
+      }
+      return text2;
+    } finally {
+      closeSync3(fd);
+    }
+  }
+};
+var TAIL_POLL_MS = 200;
+var RunObserver = class {
+  cycles = [];
+  attribution = new TicketAttributionTracker();
+  /** Hand-off writes and their outcomes, to tell a run whose hand-off never landed (CREW-2363). */
+  handoff = new HandoffTranscriptTracker();
+  result;
+  /** Prefix tokens of the first assistant call that carried usage; kept once. */
+  prefixTokens;
+  /** Set once the stream carries the harness's final result (turn count or cost). */
+  sawResult = false;
+  muted = false;
+  /**
+   * The label stamped on events. Starts as the poll hint and switches to the
+   * ticket the run actually claims (CREW-1776); `id.ticket` stays the hint.
+   */
+  liveTicket;
+  /** Called after `liveTicket` changes, so the sidecar can be rewritten. */
+  onClaim;
+  buf = "";
+  mapper;
+  id;
+  adapter;
+  eventsSink;
+  emitCycle;
+  constructor(id, adapter, eventsSink, emitCycle) {
+    this.id = id;
+    this.adapter = adapter;
+    this.eventsSink = eventsSink;
+    this.emitCycle = emitCycle;
+    this.liveTicket = id.ticket ?? void 0;
+    this.mapper = adapter.createStreamMapper?.() ?? { map: (p) => adapter.mapStreamLine(p), flush: () => [] };
+  }
+  feed(text2) {
+    this.buf += text2;
+    const lines2 = this.buf.split("\n");
+    this.buf = lines2.pop() ?? "";
+    for (const line of lines2) this.handleLine(line);
+  }
+  end() {
+    if (this.buf) this.handleLine(this.buf);
+    this.buf = "";
+    try {
+      this.consume(void 0, this.mapper.flush());
+    } catch {
+    }
+  }
+  handleLine(line) {
+    if (!line) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return;
+    }
+    try {
+      const got = this.adapter.extractResult(parsed);
+      if (got) {
+        this.result = { ...this.result, ...Object.fromEntries(Object.entries(got).filter(([, v]) => v !== void 0)) };
+        if (got.numTurns !== void 0 || got.costUsd !== void 0) this.sawResult = true;
+      }
+      this.handoff.feed(parsed);
+      this.consume(parsed, this.mapper.map(parsed));
+    } catch {
+    }
   }
-  return "keychain unavailable (could not write to the OS keychain)";
-}
-async function mintMissingSeatKeys(route2, o) {
-  const out = [];
-  if (!route2.resolved) return out;
-  const resolved = route2.resolved;
-  const doFetch = o.fetchImpl ?? fetch;
-  const targets = [
-    ...SEAT_KEY_ROLES.filter((r) => resolved.seats[r]).map((role) => ({ role, agentId: seatAgentId(route2, role) })),
-    ...resolved.releaseSeat ? [{ role: "release", agentId: resolved.releaseAgentId }] : []
-  ];
-  let store;
+  // Turns mapped events (and, when there is a source line, its token usage)
+  // into sink writes and buffered cycles. `parsed` is undefined for events
+  // the mapper flushes at end of stream, which have no line of their own.
+  consume(parsed, events) {
+    const plan = this.id;
+    let turnText = "";
+    for (const ev of events) if ((ev.kind === "thought" || ev.kind === "text") && ev.text) this.attribution.note(ev.text);
+    for (const ev of events) {
+      if (ev.kind === "tool") this.attribution.noteWrite(ev.tool, ev.input);
+      if (ev.kind === "tool" && isClaimWrite(ev.tool, ev.input)) {
+        const claimed = this.attribution.current;
+        if (claimed && claimed !== this.liveTicket) {
+          if (!this.muted) {
+            this.eventsSink?.write(`${JSON.stringify({
+              at: (/* @__PURE__ */ new Date()).toISOString(),
+              cycle: this.emitCycle,
+              route: plan.route,
+              step: "agent",
+              level: "info",
+              message: `ticket: ${this.liveTicket ?? "none"} \u2192 ${claimed}`,
+              role: plan.role,
+              ticket: claimed,
+              data: { kind: "ticket", from: this.liveTicket ?? null, to: claimed }
+            })}
+`);
+          }
+          this.liveTicket = claimed;
+          if (!this.muted) this.onClaim?.();
+        }
+      }
+      const e = {
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        cycle: this.emitCycle,
+        route: plan.route,
+        step: "agent",
+        level: "info",
+        message: ev.kind === "tool" ? `${ev.tool ?? "tool"}${ev.target ? ` ${ev.target}` : ""}` : ev.kind,
+        role: plan.role,
+        ...this.liveTicket ? { ticket: this.liveTicket } : {},
+        data: { kind: ev.kind, ...ev.text ? { text: ev.text } : {}, ...ev.tool ? { tool: ev.tool } : {}, ...ev.target ? { target: ev.target } : {} }
+      };
+      if (!this.muted) this.eventsSink?.write(`${JSON.stringify(e)}
+`);
+      if ((ev.kind === "thought" || ev.kind === "text") && ev.text) {
+        turnText += `${ev.text}
+`;
+        const cycleIndex = this.cycles.length;
+        this.cycles.push({
+          cycleIndex,
+          occurredAt: e.at,
+          thinking: ev.text,
+          // A conversational `text` turn is tagged 'assistant' so it's
+          // distinguishable from a thinking block once both share this
+          // buffer (ISSUE-594) — matching the precedent
+          // `agent-chat.service.ts`'s logChatRun (ISSUE-504) already set
+          // for the same column. A `thought` cycle stays untagged, same
+          // as before this change.
+          ...ev.kind === "text" ? { role: "assistant" } : {}
+        });
+        if (!this.muted) {
+          this.eventsSink?.write(`${JSON.stringify({
+            ...e,
+            message: "cycle",
+            data: { kind: "cycle", cycleIndex, text: ev.text }
+          })}
+`);
+        }
+      }
+    }
+    if (this.prefixTokens === void 0 && parsed !== void 0) this.prefixTokens = this.adapter.extractPrefixTokens?.(parsed);
+    const turnTokens = parsed === void 0 ? void 0 : this.adapter.extractTurnTokens(parsed);
+    if (turnTokens !== void 0) this.attribution.add(turnText, turnTokens);
+  }
+};
+function writeRunMeta(id, startedAt, liveTicket, extra) {
   try {
-    store = (o.getStore ?? getSessionStore)();
-  } catch (e) {
-    return targets.map(({ role }) => ({
-      role,
-      action: "failed",
-      detail: describeStoreError(e)
+    writeFileSync15(`${id.streamPath}.meta.json`, JSON.stringify({
+      route: id.route,
+      role: id.role,
+      hint: id.ticket,
+      ticket: liveTicket ?? id.ticket,
+      startedAt,
+      model: id.model,
+      toolchain: id.toolchain,
+      harness: id.harness,
+      provider: id.provider,
+      exitCode: null,
+      running: true,
+      ...extra
     }));
+  } catch {
   }
-  const host = hostFromUrl2(route2.baseUrl);
-  const base = route2.baseUrl.replace(/\/+$/, "");
-  if (!o.dryRun) {
-    const probeSlug = seatKeySlug(splitRoute(route2.route)[0], "_probe");
+}
+async function finishRun(id, obs, emit, startedAt, end, agentLogKey, hintMoved) {
+  let moved = false;
+  if (hintMoved) {
     try {
-      await store.set(host, probeSlug, {
-        apiKey: "probe",
-        workspaceId: resolved.workspaceId,
-        identityId: "_probe",
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      moved = await hintMoved();
+    } catch {
+    }
+  }
+  const { ticket: attributedTicket, by: attributedBy } = obs.attribution.decide(obs.liveTicket, { hintMoved: moved });
+  const identity = { toolchain: id.toolchain, harness: id.harness, provider: id.provider };
+  const { result } = obs;
+  const pending = end.interrupted ? null : obs.handoff.pending();
+  if (pending) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      writePendingHandoff(stateDirOfStream(id.streamPath), {
+        ...pending,
+        version: 1,
+        route: id.route,
+        role: id.role,
+        ...attributedTicket ? { ticket: attributedTicket } : {},
+        streamPath: id.streamPath,
+        createdAt: now.toISOString(),
+        attempts: 0,
+        nextAttemptAt: now.toISOString()
       });
-      await store.clear(host, probeSlug);
     } catch (e) {
-      const detail = `${describeStoreError(e)}; no keys minted`;
-      return targets.map(({ role, agentId }) => agentId ? { role, action: "failed", detail } : { role, action: "no_agent" });
+      emit.warn(`could not save the pending hand-off: ${e.message}`, { step: "agent" });
     }
   }
-  for (const { role, agentId } of targets) {
-    if (!agentId) {
-      out.push({ role, action: "no_agent" });
-      continue;
+  try {
+    writeRunMeta(id, startedAt, obs.liveTicket, {
+      attributedTicket: attributedTicket ?? null,
+      attributedBy,
+      running: void 0,
+      exitCode: end.code,
+      ...end.interrupted ? { interrupted: end.interrupted } : {},
+      ...pending ? { handoff: "pending" } : {},
+      sessionId: result?.sessionId ?? null,
+      numTurns: result?.numTurns ?? null,
+      prefixTokens: obs.prefixTokens ?? null,
+      totalCostUsd: result?.costUsd ?? null
+    });
+  } catch {
+  }
+  const ms3 = Date.now() - Date.parse(startedAt);
+  emit.emit(end.interrupted ? "agent run interrupted" : `agent run finished (${pending ? "hand-off pending" : `exit ${end.code ?? "unknown"}`})`, {
+    data: {
+      ms: ms3,
+      code: end.code,
+      ...pending ? { handoff: "pending" } : {},
+      ...end.interrupted ? { interrupted: end.interrupted } : {},
+      ...identity,
+      attributedTicket: attributedTicket ?? null,
+      attributedBy,
+      ...result?.sessionId ? { sessionId: result.sessionId } : {},
+      ...result?.numTurns !== void 0 ? { numTurns: result.numTurns } : {},
+      ...result?.costUsd !== void 0 ? { totalCostUsd: result.costUsd } : {}
     }
-    const slug2 = slugFor(route2, agentId);
+  });
+  if (id.agentLog && agentLogKey) {
+    const report = {
+      ticketReference: attributedTicket,
+      outcome: end.interrupted ? "interrupted" : end.code === 0 || end.code === null && obs.sawResult ? "success" : "error",
+      startedAt,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      cycles: obs.cycles,
+      model: id.model,
+      tokensIn: result?.inputTokens,
+      tokensOut: result?.outputTokens,
+      cacheReadTokens: result?.cacheReadTokens,
+      cacheWriteTokens: result?.cacheWriteTokens,
+      costUsd: result?.costUsd,
+      // Both come from a finished run: without the result line (interrupted) neither is trustworthy.
+      ...result?.numTurns !== void 0 ? { numTurns: result.numTurns } : {},
+      ...result?.numTurns !== void 0 && obs.prefixTokens !== void 0 ? { prefixTokens: obs.prefixTokens } : {},
+      harness: identity.harness,
+      provider: identity.provider,
+      promptVersion: id.promptVersion,
+      promptSha: id.promptSha
+    };
     try {
-      if ((await store.get(host, slug2))?.apiKey) {
-        out.push({ role, action: "already_stored" });
-        continue;
-      }
-      if (o.dryRun) {
-        out.push({ role, action: "minted", detail: "dry run" });
-        continue;
-      }
-      const res = await doFetch(`${base}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${resolveApiKey(route2)}`,
-          "Content-Type": "application/json",
-          "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0"
-        },
-        body: JSON.stringify({ name: `crew ${o.shipName ?? "ship"} ${role}` })
-      });
-      if (res.status === 403) {
-        out.push({ role, action: "forbidden" });
-        break;
-      }
-      if (!res.ok) {
-        out.push({ role, action: "failed", detail: `${res.status} ${res.statusText}` });
-        continue;
-      }
-      const body = await res.json();
-      if (!body.key) {
-        out.push({ role, action: "failed", detail: "response carried no key" });
-        continue;
-      }
+      const sent = await reportAgentRun({ ...id.agentLog, apiKey: agentLogKey }, report);
       try {
-        const session = {
-          apiKey: body.key,
-          workspaceId: resolved.workspaceId,
-          identityId: agentId,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          ...body.id ? { keyId: body.id } : {}
-        };
-        await store.set(host, slug2, session);
-      } catch (e) {
-        let revoked = false;
-        if (body.id) {
-          try {
-            const del2 = await doFetch(`${base}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys/${body.id}`, {
-              method: "DELETE",
-              headers: { Authorization: `Bearer ${resolveApiKey(route2)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
-            });
-            revoked = del2.ok;
-          } catch {
-            revoked = false;
-          }
+        clearShipAttention(new State(stateDirOfStream(id.streamPath)), agentLogRefusedKey(id.route));
+      } catch {
+      }
+      if (sent.counterWarning) emit.warn(sent.counterWarning, { step: "agent" });
+      if (sent.counterRetry) {
+        try {
+          queueTicketCounters(stateDirOfStream(id.streamPath), basename8(id.streamPath, ".jsonl"), {
+            version: 1,
+            route: id.route,
+            role: id.role,
+            target: id.agentLog,
+            write: sent.counterRetry,
+            attempts: 0,
+            nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } catch {
         }
-        out.push({
-          role,
-          action: "failed",
-          detail: revoked ? `minted but could not be stored (${describeStoreError(e)}); revoked` : `a key for ${role} is live on the server and not stored (${describeStoreError(e)}) \u2014 revoke it from that seat's Agents row`
-        });
-        continue;
       }
-      out.push({ role, action: "minted" });
     } catch (e) {
-      out.push({ role, action: "failed", detail: /Command failed|security|sk_|-w /i.test(e.message) ? describeStoreError(e) : e.message });
+      if (e instanceof AgentLogUnreachableError) {
+        try {
+          queueAgentRun(stateDirOfStream(id.streamPath), basename8(id.streamPath, ".jsonl"), {
+            version: 1,
+            route: id.route,
+            role: id.role,
+            target: id.agentLog,
+            report,
+            attempts: 0,
+            nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          emit.warn(`could not report agent log (${e.message}); queued to retry`, { step: "agent" });
+          return { ms: ms3, ticket: attributedTicket, handoffPending: !!pending };
+        } catch {
+        }
+      }
+      if (e instanceof AgentLogHttpError && e.row && e.status >= 400 && e.status < 500) {
+        try {
+          await raiseShipAttention(
+            { state: new State(stateDirOfStream(id.streamPath)), emit },
+            agentLogRefusedItem(id.route, id.role, e.status)
+          );
+        } catch {
+        }
+      }
+      emit.warn(`could not report agent log: ${e.message}`, { step: "agent" });
     }
   }
-  return out;
+  return { ms: ms3, ticket: attributedTicket, handoffPending: !!pending };
 }
-function describeMintOutcome(o) {
-  switch (o.action) {
-    case "minted":
-      return `${o.role}: agent key minted${o.detail ? ` (${o.detail})` : ""}`;
-    case "already_stored":
-      return `${o.role}: agent key already stored`;
-    case "no_agent":
-      return `${o.role}: no linked Agents row \u2014 writes as the ship until \`crew agents sync\` links one`;
-    case "forbidden":
-      return FORBIDDEN_LINE;
-    case "failed":
-      return `${o.role}: could not mint an agent key (${o.detail ?? "unknown"}) \u2014 writes as the ship`;
+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);
+  let streamFd;
+  try {
+    mkdirSync13(dirname9(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}`));
   }
-}
-async function revokeSeatKeys(route2, o) {
-  const out = [];
-  if (!route2.resolved) return out;
-  const resolved = route2.resolved;
-  const doFetch = o.fetchImpl ?? fetch;
-  const targets = [
-    ...SEAT_KEY_ROLES.filter((r) => resolved.seats[r]).map((role) => ({ role, agentId: seatAgentId(route2, role) })),
-    ...resolved.releaseSeat ? [{ role: "release", agentId: resolved.releaseAgentId }] : []
-  ];
-  let store;
+  const failed = (e) => {
+    void endSink(eventsSink);
+    return Promise.reject(new AgentSpawnError(`cannot run ${plan.bin}: ${e.message}`));
+  };
+  let begun;
   try {
-    store = (o.getStore ?? getSessionStore)();
+    begun = runner.start(plan, { env: { ...scrubbedEnv(process.env, adapter.harness), ...plan.setEnv }, streamFd, emit });
   } catch (e) {
-    return targets.map(({ role }) => ({ role, action: "failed", detail: describeStoreError(e) }));
+    closeSync3(streamFd);
+    return failed(e);
   }
-  const host = hostFromUrl2(route2.baseUrl);
-  const base = route2.baseUrl.replace(/\/+$/, "");
-  for (const { role, agentId } of targets) {
-    if (!agentId) {
-      out.push({ role, action: "no_agent" });
-      continue;
-    }
-    const slug2 = slugFor(route2, agentId);
-    try {
-      const session = await store.get(host, slug2);
-      if (!session?.apiKey) {
-        out.push({ role, action: "not_stored" });
-        continue;
-      }
-      if (!session.keyId) {
-        out.push({ role, action: "failed", detail: "no key id was recorded when this key was minted \u2014 revoke it from the seat's Agents row" });
-        continue;
+  if (begun instanceof Promise) {
+    return begun.then(
+      (run3) => {
+        closeSync3(streamFd);
+        return supervise(run3);
+      },
+      (e) => {
+        closeSync3(streamFd);
+        return failed(e);
       }
-      if (o.dryRun) {
-        out.push({ role, action: "revoked", detail: "dry run" });
-        continue;
+    );
+  }
+  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 {
+          writeFileSync15(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
+        } catch {
+        }
       }
-      const del2 = await doFetch(`${base}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys/${session.keyId}`, {
-        method: "DELETE",
-        headers: { Authorization: `Bearer ${resolveApiKey(route2)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
+      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}`));
       });
-      if (!del2.ok && del2.status !== 404) {
-        out.push({ role, action: "failed", detail: `${del2.status} ${del2.statusText}` });
-        continue;
-      }
-      await store.clear(host, slug2);
-      out.push({ role, action: "revoked", detail: del2.ok ? void 0 : "server already had no such key" });
-    } catch (e) {
-      out.push({ role, action: "failed", detail: /Command failed|security|sk_|-w /i.test(e.message) ? describeStoreError(e) : e.message });
-    }
-  }
-  return out;
-}
-function describeRevokeOutcome(o) {
-  switch (o.action) {
-    case "revoked":
-      return `${o.role}: agent key revoked and cleared from the keychain${o.detail ? ` (${o.detail})` : ""}`;
-    case "not_stored":
-      return `${o.role}: no agent key stored on this ship`;
-    case "no_agent":
-      return `${o.role}: no linked Agents row`;
-    case "failed":
-      return `${o.role}: could not revoke the agent key (${o.detail ?? "unknown"}) \u2014 left in the keychain`;
+      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);
+    });
   }
 }
-async function canMintAgentKeys(route2, o = {}) {
-  const resolved = route2.resolved;
-  if (!resolved) return void 0;
-  const agentId = seatAgentId(route2, "dev") ?? SEAT_KEY_ROLES.map((r) => seatAgentId(route2, r)).find(Boolean);
-  if (!agentId) return void 0;
-  try {
-    const res = await (o.fetchImpl ?? fetch)(`${route2.baseUrl.replace(/\/+$/, "")}/api/workspaces/${resolved.workspaceId}/agents/${agentId}/api-keys`, {
-      headers: { Authorization: `Bearer ${resolveApiKey(route2)}`, "User-Agent": o.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
-    });
-    if (res.ok) return true;
-    return res.status === 403 ? false : void 0;
-  } catch {
-    return void 0;
+async function reattachRun(streamPath, sc, emit, o = {}) {
+  const adapter = adapterFor(sc.harness);
+  const isAlive = o.isAlive ?? runIsAlive;
+  const id = { ...sc, streamPath };
+  const eventsSink = openSink(sc.eventsPath);
+  const obs = new RunObserver(id, adapter, eventsSink, emit.cycle);
+  const tail3 = new FileTail(streamPath);
+  obs.muted = true;
+  obs.feed(tail3.poll());
+  obs.muted = false;
+  const runner = runnerOfSidecar(sc);
+  const adopted = isAlive(sc);
+  let killed;
+  if (adopted) {
+    o.onAdopted?.();
+    const pollMs = o.pollMs ?? TAIL_POLL_MS;
+    while (isAlive(sc)) {
+      obs.feed(tail3.poll());
+      if (!killed && (msUntilDeadline(sc.deadline) ?? 1) <= 0) {
+        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));
+    }
   }
+  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,
+    obs,
+    emit,
+    sc.spawnedAt,
+    { code: null, ...interrupted ? { interrupted } : {} },
+    o.agentLogKey
+  );
+  return { adopted, ...interrupted ? { interrupted } : {}, ...killed ? { killed } : {}, ms: ms3, ticket };
 }
 
 // src/selftest.ts
@@ -11364,7 +11910,7 @@ async function runSelftest(i, deps = realDeps) {
     ...adapter.runEnv(spec),
     [KEY_VAR]: i.apiKey
   };
-  const cwd = mkdtempSync2(join25(tmpdir4(), "crew-selftest-"));
+  const cwd = mkdtempSync2(join27(tmpdir4(), "crew-selftest-"));
   try {
     const run3 = await deps.run({
       bin: invocation.bin,
@@ -11397,11 +11943,11 @@ function formatResult(r) {
   const secs = `${(r.ms / 1e3).toFixed(1)}s`;
   return r.ok ? `${r.toolchain}: PASS ${r.detail} (${secs}${tok})` : `${r.toolchain}: FAIL ${r.failure} \u2014 ${r.detail} (${secs})`;
 }
-var fileFor2 = (stateDir) => join25(stateDir, "selftest.json");
+var fileFor2 = (stateDir) => join27(stateDir, "selftest.json");
 function readSelftest(stateDir) {
   try {
     const p = fileFor2(stateDir);
-    return existsSync22(p) ? JSON.parse(readFileSync21(p, "utf8")) : {};
+    return existsSync25(p) ? JSON.parse(readFileSync22(p, "utf8")) : {};
   } catch {
     return {};
   }
@@ -11422,7 +11968,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve6, dirname as dirname25, join as join49, basename as basename15 } from "path";
+import { resolve as resolve6, dirname as dirname26, join as join49, basename as basename15 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname4, homedir as homedir11 } from "os";
 import { spawnSync as spawnSync10 } from "child_process";
@@ -11619,14 +12165,14 @@ function rosterMarkdown(roster, meId) {
 }
 
 // src/connect-resume.ts
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync22, rmSync as rmSync15, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname9, join as join26 } from "path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync23, rmSync as rmSync15, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname10, join as join28 } from "path";
 function lastSessionFile(stateDir) {
-  return join26(stateDir, "connect-session.json");
+  return join28(stateDir, "connect-session.json");
 }
 function readPointers(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync22(lastSessionFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync23(lastSessionFile(stateDir), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     const out = {};
     for (const [host, v] of Object.entries(parsed)) {
@@ -11640,7 +12186,7 @@ function readPointers(stateDir) {
 }
 function writePointers(stateDir, pointers) {
   const file = lastSessionFile(stateDir);
-  mkdirSync15(dirname9(file), { recursive: true });
+  mkdirSync15(dirname10(file), { recursive: true });
   writeFileSync17(file, `${JSON.stringify(pointers, null, 2)}
 `, { mode: 384 });
 }
@@ -11726,15 +12272,15 @@ async function signOutSessions(o) {
 }
 
 // src/reset.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync16, readFileSync as readFileSync23, readdirSync as readdirSync9, rmSync as rmSync16, statSync as statSync8, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname10, join as join27 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync16, readFileSync as readFileSync24, readdirSync as readdirSync12, rmSync as rmSync16, statSync as statSync8, writeFileSync as writeFileSync18 } from "fs";
+import { dirname as dirname11, join as join29 } from "path";
 import { hostFromUrl as hostFromUrl3 } from "@tablation/client";
 function clonedCheckoutsFile(stateDir) {
-  return join27(stateDir, "cloned-checkouts.json");
+  return join29(stateDir, "cloned-checkouts.json");
 }
 function readClonedCheckouts(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync23(clonedCheckoutsFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync24(clonedCheckoutsFile(stateDir), "utf8"));
     return Array.isArray(parsed) ? parsed.filter((d) => typeof d === "string") : [];
   } catch {
     return [];
@@ -11744,7 +12290,7 @@ function recordClonedCheckout(stateDir, dir) {
   const known = readClonedCheckouts(stateDir);
   if (known.includes(dir)) return;
   const file = clonedCheckoutsFile(stateDir);
-  mkdirSync16(dirname10(file), { recursive: true });
+  mkdirSync16(dirname11(file), { recursive: true });
   writeFileSync18(file, `${JSON.stringify([...known, dir], null, 2)}
 `);
 }
@@ -11797,407 +12343,137 @@ async function runReset(o, fx) {
   if (o.removeCheckouts) {
     for (const dir of readClonedCheckouts(o.stateDir)) steps.push(removeCheckout(dir, o.dryRun, 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) rmSync16(o.configFile, { force: true });
-    steps.push({ step: "config", target: o.configFile, action: mark(o.dryRun) });
-  } else {
-    steps.push({ step: "config", target: o.configFile, action: "absent" });
-  }
-  return steps;
-}
-function removeCheckout(dir, dryRun, fx) {
-  if (!existsSync23(dir)) return { step: "checkout", target: dir, action: "absent", detail: "already gone" };
-  const { dirty, linkedWorktrees } = fx.inspectCheckout(dir);
-  if (dirty.length) {
-    return { step: "checkout", target: dir, action: "kept", detail: `has uncommitted changes (${dirty.length} path${dirty.length === 1 ? "" : "s"}: ${dirty.slice(0, 5).join(", ")}${dirty.length > 5 ? ", \u2026" : ""})` };
-  }
-  if (linkedWorktrees.length) {
-    return { step: "checkout", target: dir, action: "kept", detail: `has linked worktrees (${linkedWorktrees.join(", ")}); remove them first` };
-  }
-  if (!dryRun) rmSync16(dir, { recursive: true, force: true });
-  return { step: "checkout", target: dir, action: mark(dryRun) };
-}
-function removeState(stateDir, dryRun) {
-  const out = [];
-  const targets = [join27(stateDir, "resolved"), join27(stateDir, "keys"), clonedCheckoutsFile(stateDir), join27(stateDir, "connect-session.json"), join27(stateDir, "reload-requested"), join27(stateDir, "daemon.started")];
-  try {
-    for (const name of readdirSync9(stateDir)) {
-      if (name.startsWith(".") && statSync8(join27(stateDir, name)).isFile()) targets.push(join27(stateDir, name));
-    }
-  } catch {
-  }
-  for (const t of targets) {
-    if (!existsSync23(t)) continue;
-    if (!dryRun) rmSync16(t, { recursive: true, force: true });
-    out.push({ step: "state", target: t, action: mark(dryRun) });
-  }
-  if (!out.length) out.push({ step: "state", target: stateDir, action: "absent", detail: "nothing to remove" });
-  return out;
-}
-function wipeStateDir(stateDir, dryRun) {
-  let names;
-  try {
-    names = readdirSync9(stateDir);
-  } catch {
-    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) rmSync16(join27(stateDir, n), { recursive: true, force: true });
-  return [{ step: "state", target: stateDir, action: mark(dryRun), detail: `${names.length} entr${names.length === 1 ? "y" : "ies"}` }];
-}
-function describeResetStep(s) {
-  const verb = { removed: "removed", "would-remove": "would remove", absent: "nothing to remove", kept: "KEPT", failed: "FAILED" }[s.action];
-  return `${s.step}: ${verb}: ${s.target}${s.detail ? ` (${s.detail})` : ""}`;
-}
-function resetIncomplete(steps) {
-  return steps.some((s) => s.action === "failed" || s.action === "kept");
-}
-
-// src/deprovision.ts
-var mark2 = (dryRun) => dryRun ? "would-remove" : "removed";
-async function runDeprovision(o, fx, deps) {
-  const attempt = (step, target, fn, dry) => {
-    try {
-      if (!dry) fn();
-      return { step, target, action: mark2(dry) };
-    } catch (e) {
-      return { step, target, action: "failed", detail: e.message };
-    }
-  };
-  const afterScheduler = async () => {
-    const steps2 = [];
-    for (const run3 of deps.liveRuns()) {
-      const target = `${run3.role} run on ${run3.route} (pid ${run3.pid})`;
-      if (o.dryRun) {
-        steps2.push({ step: "run", target, action: "would-remove" });
-        continue;
-      }
-      try {
-        await deps.killRun(run3);
-        deps.recordKill(run3);
-      } catch (e) {
-        steps2.push({ step: "run", target, action: "failed", detail: e.message });
-        continue;
-      }
-      try {
-        await deps.handBack(run3);
-        steps2.push({ step: "run", target, action: "removed", detail: "killed" });
-      } catch (e) {
-        steps2.push({ step: "run", target, action: "removed", detail: `killed; could not tell its ticket (${e.message})` });
-      }
-    }
-    for (const name of deps.sandboxes()) steps2.push(attempt("sandbox", name, () => {
-      deps.removeSandbox(name);
-    }, o.dryRun));
-    if (!o.dryRun) {
-      for (const r of await deps.clearShipRows()) {
-        steps2.push({ step: "ship-row", target: r.route, action: r.ok ? "removed" : "failed", detail: r.detail });
-      }
-    }
-    return steps2;
-  };
-  const beforeState = async () => {
-    const steps2 = [];
-    for (const host of deps.forgeHosts()) {
-      try {
-        const result = o.dryRun ? "erased" : deps.eraseForgeToken(host);
-        if (result === "env") steps2.push({ step: "forge", target: host, action: "kept", detail: "the token is read from the environment; crew does not own it" });
-        else if (result === "absent") steps2.push({ step: "forge", target: host, action: "absent" });
-        else steps2.push({ step: "forge", target: host, action: mark2(o.dryRun) });
-      } catch (e) {
-        steps2.push({ step: "forge", target: host, action: "failed", detail: e.message });
-      }
-    }
-    const { volumes, images } = deps.labeled();
-    for (const v of volumes) steps2.push(attempt("cache", `volume ${v}`, () => {
-      deps.removeVolume(v);
-    }, o.dryRun));
-    for (const i of images) steps2.push(attempt("cache", `image ${i}`, () => {
-      deps.removeImage(i);
-    }, o.dryRun));
-    return steps2;
-  };
-  const steps = await runReset({ ...o, removeCheckouts: true, wipeState: true, afterScheduler, beforeState }, fx);
-  const remaining = o.dryRun ? [] : deps.remaining();
-  return { steps, remaining, ok: !resetIncomplete(steps) && remaining.length === 0 };
-}
-
-// src/deprovision-host.ts
-import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync26, readdirSync as readdirSync12 } from "fs";
-
-// src/interrupted.ts
-import { existsSync as existsSync24, readdirSync as readdirSync10, readFileSync as readFileSync24 } from "fs";
-import { join as join28 } from "path";
-var INTERRUPTED_MARKER = calloutHeader("NOTE", "Interrupted");
-function interruptedComment(b) {
-  const tree = b.dirty === null ? "The worktree could not be checked." : b.dirty ? "The worktree has uncommitted changes \u2014 they are this seat's own, from that run." : "The worktree is clean.";
-  return `${INTERRUPTED_MARKER}
-
-The agent run on this ticket was cut short (${b.reason}) before it handed on${b.branch ? `; its branch is \`${b.branch}\`` : ""}. ${tree} The next run on this seat resumes from the worktree rather than starting over.`;
-}
-var handled = /* @__PURE__ */ new Set();
-var pidAlive = (pid) => {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (e) {
-    return e.code === "EPERM";
-  }
-};
-function runFinished(streamPath) {
-  const path = `${streamPath}.meta.json`;
-  if (!existsSync24(path)) return false;
-  try {
-    return JSON.parse(readFileSync24(path, "utf8")).running !== true;
-  } catch {
-    return true;
-  }
-}
-function orphanedStreams(o) {
-  const dir = join28(o.stateDir, "streams");
-  if (!existsSync24(dir)) return [];
-  const ownerAlive = o.isOwnerAlive ?? pidAlive;
-  const out = [];
-  for (const name of readdirSync10(dir)) {
-    if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join28(dir, name);
-    if (runFinished(streamPath)) continue;
-    const sidecar = readRunSidecar(streamPath);
-    if (!sidecar || sidecar.route !== o.routeLabel) continue;
-    if (ownerAlive(sidecar.ownerPid)) continue;
-    out.push({ streamPath, sidecar });
-  }
-  return out;
-}
-async function reconcileRuns(o) {
-  let adopted = 0;
-  let interrupted = 0;
-  for (const { streamPath, sidecar } of orphanedStreams(o)) {
-    if (handled.has(streamPath)) continue;
-    handled.add(streamPath);
-    const isAlive = o.isAlive ?? runIsAlive;
-    const lock = isAlive(sidecar) ? o.state.acquireRun(sidecar.role, o.maxConcurrentAgents, o.roleConcurrency?.[sidecar.role] ?? 1) : null;
-    const ticketLock = isAlive(sidecar) && sidecar.ticketRecordId ? o.state.acquireTicket(sidecar.ticketRecordId) : null;
-    const work = (async () => {
-      try {
-        const result = await reattachRun(streamPath, sidecar, o.emit, {
-          agentLogKey: await o.agentLogKey?.(sidecar.role).catch(() => void 0),
-          isAlive: o.isAlive,
-          pollMs: o.pollMs,
-          onAdopted: () => o.emit.emit(`adopted ${sidecar.role} run (pid ${sidecar.pid}) left by a previous crew process`, { step: "agent", role: sidecar.role })
-        });
-        if (result.adopted) adopted++;
-        else interrupted++;
-        try {
-          await o.afterRun?.(sidecar, result);
-        } catch (e) {
-          o.emit.warn(`could not follow up on ${sidecar.role} run ${streamPath}: ${e.message}`, { step: "agent" });
-        }
-      } catch (e) {
-        o.emit.warn(`could not reattach ${sidecar.role} run ${streamPath}: ${e.message}`, { step: "agent" });
-      } finally {
-        if (lock?.ok) lock.release();
-        if (ticketLock?.ok) ticketLock.release();
-      }
-    })();
-    if (isAlive(sidecar)) {
-      if (o.inFlight) {
-        o.inFlight.add(work);
-        void work.finally(() => o.inFlight.delete(work));
-      }
-    } else {
-      await work;
-    }
-  }
-  return { adopted, interrupted };
-}
-
-// src/live-runs.ts
-import { existsSync as existsSync25, readdirSync as readdirSync11 } from "fs";
-import { join as join29 } from "path";
-function liveRuns(stateDir, isAlive = runIsAlive) {
-  const dir = join29(stateDir, "streams");
-  if (!existsSync25(dir)) return [];
-  const out = [];
-  for (const name of readdirSync11(dir)) {
-    if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join29(dir, name);
-    if (runFinished(streamPath)) continue;
-    const sidecar = readRunSidecar(streamPath);
-    if (!sidecar || !isAlive(sidecar)) continue;
-    out.push({ ...sidecar, streamPath });
-  }
-  return out.sort((a, b) => a.spawnedAt.localeCompare(b.spawnedAt));
-}
-function siblingRuns(runs, ownTicketRecordId) {
-  return runs.filter((r) => !ownTicketRecordId || r.ticketRecordId !== ownTicketRecordId);
-}
-async function settleRunEnd(o) {
-  const { tracker, emit } = o;
-  const all = o.runs ?? liveRuns(o.stateDir);
-  const slug2 = routeSlug(o.route.route);
-  const seatSiblings = siblingRuns(all.filter((r) => r.role === o.role && r.route === slug2), o.ownTicketRecordId);
-  const shipSiblings = siblingRuns(all, o.ownTicketRecordId);
-  const newest = (rs) => rs[rs.length - 1];
-  if (o.memberId) {
-    try {
-      if (seatSiblings.length) await tracker.setCrewStatus(o.memberId, "working", newest(seatSiblings).ticketRecordId);
-      else await tracker.setCrewStatus(o.memberId, "idle");
-    } catch (e) {
-      emit.warn(`could not clear crew status: ${e.message}`, { step: "agent" });
-    }
-  }
+  if (o.beforeState) steps.push(...await o.beforeState());
+  steps.push(...o.wipeState ? wipeStateDir(o.stateDir, o.dryRun) : removeState(o.stateDir, o.dryRun));
+  if (existsSync26(o.configFile)) {
+    if (!o.dryRun) rmSync16(o.configFile, { force: true });
+    steps.push({ step: "config", target: o.configFile, action: mark(o.dryRun) });
+  } else {
+    steps.push({ step: "config", target: o.configFile, action: "absent" });
+  }
+  return steps;
+}
+function removeCheckout(dir, dryRun, fx) {
+  if (!existsSync26(dir)) return { step: "checkout", target: dir, action: "absent", detail: "already gone" };
+  const { dirty, linkedWorktrees } = fx.inspectCheckout(dir);
+  if (dirty.length) {
+    return { step: "checkout", target: dir, action: "kept", detail: `has uncommitted changes (${dirty.length} path${dirty.length === 1 ? "" : "s"}: ${dirty.slice(0, 5).join(", ")}${dirty.length > 5 ? ", \u2026" : ""})` };
+  }
+  if (linkedWorktrees.length) {
+    return { step: "checkout", target: dir, action: "kept", detail: `has linked worktrees (${linkedWorktrees.join(", ")}); remove them first` };
+  }
+  if (!dryRun) rmSync16(dir, { recursive: true, force: true });
+  return { step: "checkout", target: dir, action: mark(dryRun) };
+}
+function removeState(stateDir, dryRun) {
+  const out = [];
+  const targets = [join29(stateDir, "resolved"), join29(stateDir, "keys"), clonedCheckoutsFile(stateDir), join29(stateDir, "connect-session.json"), join29(stateDir, "reload-requested"), join29(stateDir, "daemon.started")];
   try {
-    if (shipSiblings.length) {
-      const n = newest(shipSiblings);
-      await tracker.beatEngaged(o.shipName, n.routeName ?? n.route, n.ticketRecordId, n.spawnedAt);
-    } else {
-      await tracker.beatIdle(o.shipName);
+    for (const name of readdirSync12(stateDir)) {
+      if (name.startsWith(".") && statSync8(join29(stateDir, name)).isFile()) targets.push(join29(stateDir, name));
     }
-  } catch (e) {
-    emit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
+  } catch {
+  }
+  for (const t of targets) {
+    if (!existsSync26(t)) continue;
+    if (!dryRun) rmSync16(t, { recursive: true, force: true });
+    out.push({ step: "state", target: t, action: mark(dryRun) });
   }
+  if (!out.length) out.push({ step: "state", target: stateDir, action: "absent", detail: "nothing to remove" });
+  return out;
 }
-function describeRun(run3, route2, seatIds, worktreeOf = (d, n) => {
+function wipeStateDir(stateDir, dryRun) {
+  let names;
   try {
-    return worktreeForNumber(d, n)?.path ?? null;
+    names = readdirSync12(stateDir);
   } catch {
-    return null;
+    return [{ step: "state", target: stateDir, action: "absent", detail: "no state directory" }];
   }
-}) {
-  const ownRoute = run3.route === routeSlug(route2.route);
-  const repoDir = run3.repo ? reposOf(route2).find((t) => t.name === run3.repo)?.dir : void 0;
-  const num = run3.ticket?.replace(/^\D+/, "") ?? "";
-  return {
-    role: run3.role,
-    seat: ownRoute ? seatIds[run3.role] ?? null : null,
-    ticket: run3.ticket,
-    ticketRecordId: run3.ticketRecordId,
-    repo: run3.repo ?? null,
-    worktree: repoDir && num ? worktreeOf(repoDir, num) : null,
-    stream: run3.streamPath,
-    pid: run3.pid,
-    startedAt: run3.spawnedAt,
-    deadline: run3.deadline ?? null
-  };
+  if (!names.length) return [{ step: "state", target: stateDir, action: "absent", detail: "already empty" }];
+  if (!dryRun) for (const n of names) rmSync16(join29(stateDir, n), { recursive: true, force: true });
+  return [{ step: "state", target: stateDir, action: mark(dryRun), detail: `${names.length} entr${names.length === 1 ? "y" : "ies"}` }];
 }
-
-// src/deprovision-host.ts
-var DOCKER_LABEL_OWNER = "crew.owner=crew";
-var DOCKER_LABEL_CACHE = "crew.kind=cache";
-var DOCKER_LABEL_REPO_LAYER = "crew.layer=repo";
-function docker(args) {
-  const res = spawnSync6("docker", args, { encoding: "utf8" });
-  if (res.error || res.status !== 0) throw new Error(`docker ${args[0]} ${args[1] ?? ""} failed: ${(res.stderr || String(res.error ?? "")).trim().split("\n").pop()}`);
-  return res.stdout;
+function describeResetStep(s) {
+  const verb = { removed: "removed", "would-remove": "would remove", absent: "nothing to remove", kept: "KEPT", failed: "FAILED" }[s.action];
+  return `${s.step}: ${verb}: ${s.target}${s.detail ? ` (${s.detail})` : ""}`;
 }
-var lines = (s) => s.split("\n").map((l) => l.trim()).filter(Boolean);
-function labeledDocker() {
-  if (!dockerAvailable()) return { volumes: [], images: [] };
-  return {
-    volumes: lines(docker(["volume", "ls", "-q", "--filter", `label=${DOCKER_LABEL_OWNER}`, "--filter", `label=${DOCKER_LABEL_CACHE}`])),
-    images: lines(docker(["image", "ls", "-q", "--filter", `label=${DOCKER_LABEL_OWNER}`, "--filter", `label=${DOCKER_LABEL_REPO_LAYER}`]))
-  };
+function resetIncomplete(steps) {
+  return steps.some((s) => s.action === "failed" || s.action === "kept");
 }
-function realDeprovisionDeps(cfg, emit, crewHome, getStore) {
-  const stateDir = cfg.ship.stateDir;
-  const forgeHosts = () => Object.keys(cfg.ship.forges ?? {});
-  const routeFor = (label) => cfg.routes.find((r) => routeSlug(r.route) === label);
-  const sandboxes = () => dockerAvailable() ? listPassengerContainers().map((c) => c.name) : [];
-  const unitPaths = () => {
-    const host = hostPlatform();
-    if (host === "windows") return [];
-    const ctx = installContext();
-    const systemd = detectSystemd();
-    return ["run", "release", "passengers"].flatMap((job) => planInstall(cfg.ship, crewHome, host, systemd, job, ctx).unitPaths).filter((p) => existsSync26(p));
+
+// src/deprovision.ts
+var mark2 = (dryRun) => dryRun ? "would-remove" : "removed";
+async function runDeprovision(o, fx, deps) {
+  const attempt = (step, target, fn, dry) => {
+    try {
+      if (!dry) fn();
+      return { step, target, action: mark2(dry) };
+    } catch (e) {
+      return { step, target, action: "failed", detail: e.message };
+    }
   };
-  return {
-    liveRuns: () => liveRuns(stateDir).map((r) => ({ role: r.role, route: r.route, pid: r.pid, ticketRecordId: r.ticketRecordId ?? void 0, streamPath: r.streamPath })),
-    killRun: (run3) => killRunGroup(run3.pid),
-    recordKill(run3) {
-      emit.emit(`run_killed: ${run3.role} run on ${run3.route} stopped by crew deprovision`, {
-        step: "agent",
-        role: run3.role,
-        data: { event: "run_killed", reason: "deprovision", pid: run3.pid }
-      });
-    },
-    async handBack(run3) {
-      const route2 = routeFor(run3.route);
-      if (!run3.ticketRecordId || !route2) return;
-      const memberId = route2.resolved?.seats[run3.role];
-      if (!memberId) return;
-      const identity = await resolveSeatKey(route2, run3.role, getStore);
-      const tracker = new Tracker(route2, cfg.ship, { apiKey: identity.apiKey });
-      const t = await tracker.ticket(run3.ticketRecordId);
-      const target = repoTargetFor(route2, t.repo_id);
-      const num = String(t[tracker.contract.columns.key] ?? "").replace(/^\D+/, "");
-      const wt = target && num ? worktreeForNumber(target.dir, num) : null;
-      let dirty = null;
-      try {
-        if (wt) dirty = status(wt.path).length > 0;
-      } catch {
+  const afterScheduler = async () => {
+    const steps2 = [];
+    for (const run3 of deps.liveRuns()) {
+      const target = `${run3.role} run on ${run3.route} (pid ${run3.pid})`;
+      if (o.dryRun) {
+        steps2.push({ step: "run", target, action: "would-remove" });
+        continue;
       }
-      await tracker.postEvent(run3.ticketRecordId, interruptedComment({
-        branch: wt?.branch ?? null,
-        dirty,
-        reason: "the host was released and wiped"
-      }), memberId, "interrupted");
-    },
-    sandboxes,
-    removeSandbox: (name) => {
-      stopContainer(name);
-    },
-    async clearShipRows() {
-      const out = [];
-      for (const r of cfg.routes.filter((x) => x.resolved?.shipsModelId)) {
-        try {
-          const found = await new Tracker(r, cfg.ship).clearForRelease(cfg.ship.name);
-          out.push({ route: r.route, ok: true, detail: found ? "cleared engaged, tunnel_status, relay_url" : "no Ships row for this ship" });
-        } catch (e) {
-          out.push({ route: r.route, ok: false, detail: e.message });
-        }
+      try {
+        await deps.killRun(run3);
+        deps.recordKill(run3);
+      } catch (e) {
+        steps2.push({ step: "run", target, action: "failed", detail: e.message });
+        continue;
       }
-      return out;
-    },
-    forgeHosts,
-    eraseForgeToken: (host) => eraseForgeToken(cfg.ship.forges, host, stateDir),
-    labeled: labeledDocker,
-    removeVolume: (name) => {
-      docker(["volume", "rm", "-f", name]);
-    },
-    removeImage: (name) => {
-      docker(["image", "rm", "-f", name]);
-    },
-    remaining() {
-      const left = [];
-      if (existsSync26(cfg.configFile)) left.push(`config ${cfg.configFile}`);
-      for (const h of forgeHosts()) if (hasForgeToken(cfg.ship.forges, h, stateDir)) left.push(`forge token for ${h}`);
       try {
-        for (const k of readdirSync12(keysDir(stateDir))) left.push(`seat key ${k}`);
-      } catch {
+        await deps.handBack(run3);
+        steps2.push({ step: "run", target, action: "removed", detail: "killed" });
+      } catch (e) {
+        steps2.push({ step: "run", target, action: "removed", detail: `killed; could not tell its ticket (${e.message})` });
       }
-      for (const s of sandboxes()) left.push(`sandbox ${s}`);
+    }
+    for (const name of deps.sandboxes()) steps2.push(attempt("sandbox", name, () => {
+      deps.removeSandbox(name);
+    }, o.dryRun));
+    if (!o.dryRun) {
+      for (const r of await deps.clearShipRows()) {
+        steps2.push({ step: "ship-row", target: r.route, action: r.ok ? "removed" : "failed", detail: r.detail });
+      }
+    }
+    return steps2;
+  };
+  const beforeState = async () => {
+    const steps2 = [];
+    for (const host of deps.forgeHosts()) {
       try {
-        const { volumes, images } = labeledDocker();
-        for (const v of volumes) left.push(`volume ${v}`);
-        for (const i of images) left.push(`image ${i}`);
+        const result = o.dryRun ? "erased" : deps.eraseForgeToken(host);
+        if (result === "env") steps2.push({ step: "forge", target: host, action: "kept", detail: "the token is read from the environment; crew does not own it" });
+        else if (result === "absent") steps2.push({ step: "forge", target: host, action: "absent" });
+        else steps2.push({ step: "forge", target: host, action: mark2(o.dryRun) });
       } catch (e) {
-        left.push(`docker could not be checked (${e.message})`);
+        steps2.push({ step: "forge", target: host, action: "failed", detail: e.message });
       }
-      for (const u of unitPaths()) left.push(`unit ${u}`);
-      if (loadedCrewLabels().length) left.push(`loaded units ${loadedCrewLabels().join(", ")}`);
-      return left;
     }
+    const { volumes, images } = deps.labeled();
+    for (const v of volumes) steps2.push(attempt("cache", `volume ${v}`, () => {
+      deps.removeVolume(v);
+    }, o.dryRun));
+    for (const i of images) steps2.push(attempt("cache", `image ${i}`, () => {
+      deps.removeImage(i);
+    }, o.dryRun));
+    return steps2;
   };
+  const steps = await runReset({ ...o, removeCheckouts: true, wipeState: true, afterScheduler, beforeState }, fx);
+  const remaining = o.dryRun ? [] : deps.remaining();
+  return { steps, remaining, ok: !resetIncomplete(steps) && remaining.length === 0 };
 }
 
 // src/pool-member.ts
 import { mkdirSync as mkdirSync17, readFileSync as readFileSync25, renameSync as renameSync4, writeFileSync as writeFileSync19 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname11, join as join30 } from "path";
+import { dirname as dirname12, join as join30 } from "path";
 var POOL_EXIT = { ok: 0, failed: 1, credential: 2 };
 function backoffMs(attempt) {
   return Math.min(6e4, 5e3 * 2 ** Math.max(0, attempt));
@@ -12399,7 +12675,7 @@ function fileMemberStore(dir) {
       }
     },
     write(f) {
-      mkdirSync17(dirname11(file), { recursive: true, mode: 448 });
+      mkdirSync17(dirname12(file), { recursive: true, mode: 448 });
       const tmp = `${file}.tmp`;
       writeFileSync19(tmp, `${JSON.stringify(f)}
 `, { mode: 384 });
@@ -12457,10 +12733,10 @@ import { existsSync as existsSync30 } from "fs";
 import { hostname as hostname3 } from "os";
 
 // src/machine-id.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync8 } from "child_process";
 import { createHash as createHash7 } from "crypto";
 import { existsSync as existsSync27, mkdirSync as mkdirSync18, readFileSync as readFileSync26, writeFileSync as writeFileSync20 } from "fs";
-import { dirname as dirname12, join as join31 } from "path";
+import { dirname as dirname13, join as join31 } from "path";
 function machineIdPathFor(stateDir) {
   return join31(stateDir, "machine-id");
 }
@@ -12468,7 +12744,7 @@ var sha256 = (s) => createHash7("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
   try {
     if (platform2 === "darwin") {
-      const out = execFileSync7("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+      const out = execFileSync8("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"]
       });
@@ -12494,7 +12770,7 @@ function ensureMachineId(stateDir, opts = {}) {
   const raw = (opts.read ?? readRawMachineId)();
   if (!raw) return void 0;
   const hashed = sha256(raw);
-  mkdirSync18(dirname12(path), { recursive: true });
+  mkdirSync18(dirname13(path), { recursive: true });
   writeFileSync20(path, `${hashed}
 `, { mode: 384 });
   return hashed;
@@ -14690,7 +14966,7 @@ async function resolveOne(tracker, t, seat, approvedStatus, buildingStatus, affi
 
 // src/repo-refresh.ts
 import { existsSync as existsSync31, mkdirSync as mkdirSync20, readFileSync as readFileSync29, writeFileSync as writeFileSync24 } from "fs";
-import { dirname as dirname14 } from "path";
+import { dirname as dirname15 } from "path";
 var REFRESH_COOLDOWN_MS = 2 * 6e4;
 var UNSERVABLE_PASSES_BEFORE_ATTENTION = 3;
 var lastAsked = /* @__PURE__ */ new Map();
@@ -14722,7 +14998,7 @@ function persistRepoRows(stateDir, routeName, rows) {
   if (!existsSync31(path)) return;
   const raw = JSON.parse(readFileSync29(path, "utf8"));
   applyRepoRows(raw, rows);
-  mkdirSync20(dirname14(path), { recursive: true });
+  mkdirSync20(dirname15(path), { recursive: true });
   writeFileSync24(path, `${JSON.stringify(raw, null, 2)}
 `);
 }
@@ -15173,7 +15449,7 @@ 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 join35 } from "path";
+import { delimiter, dirname as dirname16, join as join35 } from "path";
 import { accessSync as accessSync3, constants as constants3, existsSync as existsSync32, mkdirSync as mkdirSync21, writeFileSync as writeFileSync25 } from "fs";
 import { stringify as stringify2 } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
@@ -15222,9 +15498,9 @@ async function runWizard(p, env) {
     if (entered && isExec(entered)) agentBin = entered;
     else p.say(entered ? `${entered} is not an executable file.` : "A path is required.");
   }
-  const nodeDir = dirname15(env.nodePath);
+  const nodeDir = dirname16(env.nodePath);
   const pnpmPath = findOnPath2("pnpm", env.pathEnv, isExec);
-  const baseDirs = [nodeDir, pnpmPath ? dirname15(pnpmPath) : void 0];
+  const baseDirs = [nodeDir, pnpmPath ? dirname16(pnpmPath) : void 0];
   p.say(
     `
 Host Passengers lets this machine run the agent sessions that other people's
@@ -15235,7 +15511,7 @@ Tablation workspaces ask for, in a container. More: ${HOST_PASSENGERS_DOCS_URL}`
     p.say("Docker is not available here, so nothing will be hosted until it is. Your answer is recorded anyway.");
   }
   const dockerPath = hostPassengers ? findOnPath2("docker", env.pathEnv, isExec) : void 0;
-  const extraPath = deriveExtraPath([...baseDirs, dockerPath ? dirname15(dockerPath) : void 0]);
+  const extraPath = deriveExtraPath([...baseDirs, dockerPath ? dirname16(dockerPath) : void 0]);
   if (extraPath) {
     p.say(`Hooks will get ${extraPath} on their PATH (where node, pnpm${dockerPath ? " and docker" : ""} live).`);
   }
@@ -15257,7 +15533,7 @@ routes:
 ${routeBlock}`;
 }
 function writeNewConfig(path, text2) {
-  mkdirSync21(dirname15(path), { recursive: true });
+  mkdirSync21(dirname16(path), { recursive: true });
   try {
     writeFileSync25(path, text2, { mode: 384, flag: "wx" });
     return true;
@@ -15293,7 +15569,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 join36 } from "path";
+import { dirname as dirname17, join as join36 } from "path";
 import { delimiter as delimiter2 } from "path";
 var CHOICE_EXIT_CODE = 3;
 function createEmitter(json2, write) {
@@ -15359,7 +15635,7 @@ function flagWizardAnswers(f, env) {
   const agentBin = f.agentBin ?? found?.bin;
   const pnpmPath = findOnPath2("pnpm", env.pathEnv, isExec);
   const dockerPath = f.hostPassengers ? findOnPath2("docker", env.pathEnv, isExec) : void 0;
-  const extraPath = f.extraPath ?? deriveExtraPath([dirname16(env.nodePath), pnpmPath ? dirname16(pnpmPath) : void 0, dockerPath ? dirname16(dockerPath) : void 0]);
+  const extraPath = f.extraPath ?? deriveExtraPath([dirname17(env.nodePath), pnpmPath ? dirname17(pnpmPath) : void 0, dockerPath ? dirname17(dockerPath) : void 0]);
   return {
     answers: {
       name: f.shipName?.trim() || env.hostname,
@@ -15374,7 +15650,7 @@ function flagWizardAnswers(f, env) {
 
 // src/release-run.ts
 import { readFileSync as readFileSync30, writeFileSync as writeFileSync26, existsSync as existsSync33, copyFileSync, mkdirSync as mkdirSync22, mkdtempSync as mkdtempSync3, rmSync as rmSync17 } from "fs";
-import { dirname as dirname17, join as join37 } from "path";
+import { dirname as dirname18, join as join37 } from "path";
 import { tmpdir as tmpdir5 } from "os";
 
 // src/release.ts
@@ -15858,11 +16134,11 @@ ${h.prFailure.tail}
       emit.warn(`could not move to ${reviewing}: ${e.message}`, { ticket: t.issue_id });
     }
   }
-  for (const q of outcome.requeues) {
-    const t = q.ticket;
-    const body = `The branch is no longer what was verified: QA verified ${q.verified.slice(0, 8)}, the branch is now at ${q.head.slice(0, 8)}. Returned to ${contract.statuses.handoff} for QA to check what changed.`;
+  for (const q2 of outcome.requeues) {
+    const t = q2.ticket;
+    const body = `The branch is no longer what was verified: QA verified ${q2.verified.slice(0, 8)}, the branch is now at ${q2.head.slice(0, 8)}. Returned to ${contract.statuses.handoff} for QA to check what changed.`;
     if (dryRun) {
-      emit.emit(`would return to ${contract.statuses.handoff} \u2014 branch moved past ${q.verified.slice(0, 8)}`, { ticket: t.issue_id });
+      emit.emit(`would return to ${contract.statuses.handoff} \u2014 branch moved past ${q2.verified.slice(0, 8)}`, { ticket: t.issue_id });
       continue;
     }
     try {
@@ -15870,11 +16146,11 @@ ${h.prFailure.tail}
       await tracker.postEvent(t.id, body, seat, "requeued");
       await tracker.postEvent(
         t.id,
-        pushedEventBody(q.head, remote, q.branch),
+        pushedEventBody(q2.head, remote, q2.branch),
         seat,
         "pushed"
       );
-      emit.emit(`returned to ${contract.statuses.handoff} \u2014 branch moved past ${q.verified.slice(0, 8)}`, { ticket: t.issue_id });
+      emit.emit(`returned to ${contract.statuses.handoff} \u2014 branch moved past ${q2.verified.slice(0, 8)}`, { ticket: t.issue_id });
     } catch (e) {
       emit.warn(`could not return to ${contract.statuses.handoff}: ${e.message}`, { ticket: t.issue_id });
     }
@@ -16260,7 +16536,7 @@ function openReleaseCheckout(o) {
   for (const f of o.repo.worktrees.copy) {
     const src = join37(o.cwd, f);
     if (!existsSync33(src)) continue;
-    mkdirSync22(dirname17(join37(dir, f)), { recursive: true });
+    mkdirSync22(dirname18(join37(dir, f)), { recursive: true });
     copyFileSync(src, join37(dir, f));
   }
   return { dir, branch, close };
@@ -17071,8 +17347,8 @@ async function buildWhoami(routes, deps = {}) {
     const credential = credentialSource(route2);
     try {
       const key = resolveApiKey(route2);
-      const q = route2.resolved ? `?workspaceId=${encodeURIComponent(route2.resolved.workspaceId)}` : "";
-      const res = await doFetch(`${route2.baseUrl.replace(/\/+$/, "")}/api/auth/me${q}`, {
+      const q2 = route2.resolved ? `?workspaceId=${encodeURIComponent(route2.resolved.workspaceId)}` : "";
+      const res = await doFetch(`${route2.baseUrl.replace(/\/+$/, "")}/api/auth/me${q2}`, {
         headers: { Authorization: `Bearer ${key}`, "User-Agent": deps.userAgent ?? "Mozilla/5.0 TablationCrewAgent/1.0" }
       });
       if (res.status === 401 || res.status === 403) {
@@ -17417,9 +17693,9 @@ function startWatch(o) {
 
 // src/inbox.ts
 function matchMembers(rows, query) {
-  const q = query.trim().toLowerCase();
-  const asEmail = q.includes("@");
-  return rows.filter((r) => asEmail ? (r.email ?? "").toLowerCase() === q : (r.name ?? "").toLowerCase().includes(q)).map((r) => ({ id: r.id, name: r.name ?? "", email: r.email ?? "", by: asEmail ? "email" : "name" }));
+  const q2 = query.trim().toLowerCase();
+  const asEmail = q2.includes("@");
+  return rows.filter((r) => asEmail ? (r.email ?? "").toLowerCase() === q2 : (r.name ?? "").toLowerCase().includes(q2)).map((r) => ({ id: r.id, name: r.name ?? "", email: r.email ?? "", by: asEmail ? "email" : "name" }));
 }
 async function gatherInbox(routes, ship, opts = {}) {
   const items = [];
@@ -17580,7 +17856,7 @@ function nextRoles(decision, ran) {
 
 // src/ship-name.ts
 import { existsSync as existsSync35, mkdirSync as mkdirSync23, readFileSync as readFileSync31, renameSync as renameSync5, writeFileSync as writeFileSync27 } from "fs";
-import { dirname as dirname18 } from "path";
+import { dirname as dirname19 } from "path";
 import { parseDocument as parseDocument5 } from "yaml";
 var ShipNameError = class extends Error {
 };
@@ -17659,7 +17935,7 @@ function writeSyncedName(resolvedFile, name) {
   }
   if (raw.shipName === name) return;
   raw.shipName = name;
-  mkdirSync23(dirname18(resolvedFile), { recursive: true });
+  mkdirSync23(dirname19(resolvedFile), { recursive: true });
   const tmp = `${resolvedFile}.tmp${process.pid}`;
   writeFileSync27(tmp, `${JSON.stringify(raw, null, 2)}
 `);
@@ -18353,7 +18629,7 @@ function describeCapability(i) {
 
 // src/agents-sync-run.ts
 import { existsSync as existsSync36, mkdirSync as mkdirSync24, readFileSync as readFileSync32, writeFileSync as writeFileSync28 } from "fs";
-import { dirname as dirname19 } from "path";
+import { dirname as dirname20 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
   const force = o.force ?? false;
@@ -18390,7 +18666,7 @@ async function runAgentsSync(target, o) {
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
-    mkdirSync24(dirname19(resolvedPath), { recursive: true });
+    mkdirSync24(dirname20(resolvedPath), { recursive: true });
     writeFileSync28(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
     if (target.resolved) {
@@ -18811,7 +19087,7 @@ function existingRepoConfig(f) {
 }
 
 // src/repos-hooks-agent.ts
-import { spawn as spawn7, execFileSync as execFileSync8 } from "child_process";
+import { spawn as spawn7, execFileSync as execFileSync9 } from "child_process";
 import { realpathSync as realpathSync2 } from "fs";
 import { isAbsolute as isAbsolute2, relative } from "path";
 var AgentSuggestError = class extends Error {
@@ -18914,7 +19190,7 @@ function classifyFailure(o) {
 }
 function porcelain(dir) {
   try {
-    return execFileSync8("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: dir, encoding: "utf8" });
+    return execFileSync9("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: dir, encoding: "utf8" });
   } catch {
     return void 0;
   }
@@ -18983,7 +19259,7 @@ ${run3.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename11, dirname as dirname20, join as join38 } from "path";
+import { basename as basename11, dirname as dirname21, join as join38 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -19006,7 +19282,7 @@ 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 join38(dirname20(existing[0]), SAMPLE_REPO);
+  if (existing.length > 0) return join38(dirname21(existing[0]), SAMPLE_REPO);
   return join38(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
@@ -19052,7 +19328,7 @@ function planSampleTicket(i) {
 
 // src/worktree-sweep.ts
 import { existsSync as existsSync37, readFileSync as readFileSync34, readdirSync as readdirSync14 } from "fs";
-import { basename as basename12, dirname as dirname21, join as join39, resolve as resolve4 } from "path";
+import { basename as basename12, dirname as dirname22, join as join39, resolve as resolve4 } from "path";
 function planWorktreeSweep(target, tickets, contract) {
   const terminal = new Set(contract.statuses.resolved.filter((s) => s !== contract.statuses.verified));
   const verified = contract.statuses.verified;
@@ -19116,7 +19392,7 @@ function worktreeTicketNumbers(target) {
   return [...nums];
 }
 function siblingWorktreeDirs(target) {
-  const parent = dirname21(target.dir.replace(/[/\\]+$/, ""));
+  const parent = dirname22(target.dir.replace(/[/\\]+$/, ""));
   const stem = `${basename12(target.dir.replace(/[/\\]+$/, ""))}-`;
   const registered = new Set(worktrees(target.dir).map((w) => resolve4(w.path)));
   let names;
@@ -19809,14 +20085,14 @@ ${tail2(preview.output)}`);
 }
 
 // src/periscope-idle.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 import { statSync as statSync11 } from "fs";
 import { join as join42 } from "path";
 var MAX_SCANNED_FILES = 2e4;
 function newestWorktreeMtime(root) {
   let listing;
   try {
-    listing = execFileSync9("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+    listing = execFileSync10("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
       cwd: root,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -19906,9 +20182,9 @@ async function runPeriscopeIdlePass(d) {
 import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 import { existsSync as existsSync40, mkdirSync as mkdirSync26, readFileSync as readFileSync36, chmodSync as chmodSync3 } from "fs";
-import { dirname as dirname22, join as join43 } from "path";
+import { dirname as dirname23, join as join43 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
@@ -19918,9 +20194,9 @@ function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
   if (!existsSync40(privateKeyPath)) {
-    mkdirSync26(dirname22(privateKeyPath), { recursive: true });
+    mkdirSync26(dirname23(privateKeyPath), { recursive: true });
     try {
-      execFileSync10("ssh-keygen", [
+      execFileSync11("ssh-keygen", [
         "-t",
         "ed25519",
         "-N",
@@ -19946,7 +20222,7 @@ function ensureShipSshKeypair(stateDir) {
 }
 function sshKeygenAvailable() {
   try {
-    execFileSync10("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
+    execFileSync11("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
     return true;
   } catch (e) {
     return e.code !== "ENOENT";
@@ -20507,6 +20783,13 @@ async function runOnePassUnguarded(o) {
   const spawn11 = o.spawnRoleAgent ?? runRoleAgent;
   const breaker = o.spawnBreaker ?? new SpawnBreaker();
   const ctx = { route: o.route, ship: o.ship, state: o.state, emit, getSessionStore: o.getSessionStore };
+  if (o.sandboxCache) {
+    try {
+      await o.sandboxCache();
+    } catch (e) {
+      emit.warn(`sandbox cache refresh failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
   if (o.configFile) await reconcileRouteShipName({ route: o.route, ship: o.ship, configFile: o.configFile, emit });
   try {
     await (o.reconcile ?? reconcileForRoute)(ctx, o);
@@ -21009,8 +21292,8 @@ import {
 } from "fs";
 import { createConnection } from "net";
 import { createServer } from "http";
-import { basename as basename13, dirname as dirname23, join as join46 } from "path";
-import { execFile as execFile2, spawn as spawn10 } from "child_process";
+import { basename as basename13, dirname as dirname24, join as join46 } from "path";
+import { execFile as execFile3, spawn as spawn10 } from "child_process";
 
 // src/periscope-control.ts
 import { spawn as spawn9 } from "child_process";
@@ -21097,23 +21380,23 @@ async function execute(h, args, streaming, after) {
   };
 }
 var isPeriscopePath = (p) => p === "/periscopes" || p.startsWith("/periscopes/");
-async function handlePeriscopes(h, q) {
+async function handlePeriscopes(h, q2) {
   if (!h || !h.routes.some((r) => r.hostPeriscopes)) return err(404, "not found");
-  if (!q.token) return err(401, "a bearer token is required");
-  const down = /^\/periscopes\/([^/]+)\/down$/.exec(q.path);
-  const isUp = q.path === "/periscopes" && q.method === "POST";
-  const isList = q.path === "/periscopes" && q.method === "GET";
-  if (q.path === "/periscopes" && !isUp && !isList) return err(405, "method not allowed");
-  if (down && q.method !== "POST") return err(405, "method not allowed");
-  if (q.path !== "/periscopes" && !down) return err(404, "not found");
+  if (!q2.token) return err(401, "a bearer token is required");
+  const down = /^\/periscopes\/([^/]+)\/down$/.exec(q2.path);
+  const isUp = q2.path === "/periscopes" && q2.method === "POST";
+  const isList = q2.path === "/periscopes" && q2.method === "GET";
+  if (q2.path === "/periscopes" && !isUp && !isList) return err(405, "method not allowed");
+  if (down && q2.method !== "POST") return err(405, "method not allowed");
+  if (q2.path !== "/periscopes" && !down) return err(404, "not found");
   const member = async (workspaceId) => {
-    const v = await h.verifyIn(q.token, workspaceId);
+    const v = await h.verifyIn(q2.token, workspaceId);
     if (v === "ok") return void 0;
     if (v === "unavailable") return err(503, "could not verify the key right now");
     return err(403, "this key does not belong to the workspace of this route");
   };
   if (isList) {
-    const named = q.query.get("route") ?? void 0;
+    const named = q2.query.get("route") ?? void 0;
     const candidates2 = named === void 0 ? h.routes.filter((r) => r.hostPeriscopes) : [pickRoute(h, named)];
     const rows = [];
     const hosting = [];
@@ -21145,7 +21428,7 @@ async function handlePeriscopes(h, q) {
     }
     return reply(200, { periscopes: rows, hosting });
   }
-  const b = q.body;
+  const b = q2.body;
   if (!b) return err(400, "body must be a small JSON object");
   const routeName = plainText(b.route, "route", false);
   if (isErr(routeName)) return err(400, routeName.error);
@@ -21166,7 +21449,7 @@ async function handlePeriscopes(h, q) {
       `--${b.outcome}`,
       ...b.allowEmpty === true ? ["--allow-empty"] : [],
       "--json"
-    ], q.wantsStream, h.mcp ? async (done) => {
+    ], q2.wantsStream, h.mcp ? async (done) => {
       await h.mcp.onDown(picked, done);
       return done;
     } : void 0);
@@ -21200,7 +21483,7 @@ async function handlePeriscopes(h, q) {
     ...h.mcp ? ["--serve-mcp"] : [],
     "--no-open",
     "--json"
-  ], q.wantsStream, h.mcp ? async (done) => ({ ...done, ...await h.mcp.onUp(picked, done) }) : void 0);
+  ], q2.wantsStream, h.mcp ? async (done) => ({ ...done, ...await h.mcp.onUp(picked, done) }) : void 0);
 }
 function runCrew(args, onLine, timeoutMs = 20 * 6e4) {
   return new Promise((resolve7) => {
@@ -21325,7 +21608,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(join46(dirname23(live), n));
+    for (const n of readdirSync18(dirname24(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join46(dirname24(live), n));
   } catch {
   }
   return out;
@@ -21475,17 +21758,17 @@ async function readJsonBody(req) {
     return null;
   }
 }
-async function tailReply(path, q, rotated, abort) {
-  const after = q.get("after") ?? void 0;
-  const tail3 = q.has("tail") ? Number(q.get("tail")) : void 0;
+async function tailReply(path, q2, rotated, abort) {
+  const after = q2.get("after") ?? void 0;
+  const tail3 = q2.has("tail") ? Number(q2.get("tail")) : void 0;
   if (tail3 !== void 0 && !(Number.isInteger(tail3) && tail3 >= 0 && tail3 <= 1e3)) return err2(400, "tail must be an integer from 0 to 1000");
-  const wait = q.has("wait") ? Number(q.get("wait")) : 0;
+  const wait = q2.has("wait") ? Number(q2.get("wait")) : 0;
   if (!(Number.isFinite(wait) && wait >= 0)) return err2(400, "wait must be a number of seconds");
   if (after !== void 0 && !decodeCursor(after)) return err2(400, "after is not a cursor this API issued");
   const deadline = Date.now() + Math.min(wait, MAX_WAIT_SECONDS) * 1e3;
   let r = readTail(path, { after, tail: tail3, rotated });
   while (after && !r.lines.length && !r.reset && Date.now() < deadline && !abort.aborted) {
-    await waitForChange(dirname23(path), deadline - Date.now(), abort);
+    await waitForChange(dirname24(path), deadline - Date.now(), abort);
     r = readTail(path, { after: r.cursor, rotated });
   }
   return reply2(200, r);
@@ -21662,7 +21945,7 @@ function schedulerHandler(control, run3 = runDetached) {
 }
 function crewJson(args, timeoutMs = 6e4) {
   return new Promise((resolve7) => {
-    execFile2(process.execPath, [process.argv[1] ?? "", ...args], { timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 }, (_e, stdout) => {
+    execFile3(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);
@@ -21675,7 +21958,7 @@ function crewJson(args, timeoutMs = 6e4) {
 
 // src/periscope-mcp.ts
 import { lstat, mkdir, readdir, readFile, readlink, realpath, rm, stat, writeFile } from "fs/promises";
-import { basename as basename14, dirname as dirname24, isAbsolute as isAbsolute3, join as join48, relative as relative2, resolve as resolve5, sep } from "path";
+import { basename as basename14, dirname as dirname25, isAbsolute as isAbsolute3, join as join48, relative as relative2, resolve as resolve5, sep } from "path";
 import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -21813,10 +22096,10 @@ async function realAncestor(p) {
     }
     if (isLink) {
       if (++hops > 40) throw new PathRefusal(`too many symbolic links resolving ${p}`);
-      cur = resolve5(dirname24(cur), await readlink(cur));
+      cur = resolve5(dirname25(cur), await readlink(cur));
       continue;
     }
-    const parent = dirname24(cur);
+    const parent = dirname25(cur);
     if (parent === cur) throw new PathRefusal(`cannot resolve ${p}`);
     tail3.push(basename14(cur));
     cur = parent;
@@ -21839,7 +22122,7 @@ async function resolveInWorktree(root, requested) {
   if (relative2(realRoot, final).split(sep).includes(".git")) throw new PathRefusal(".git is not reachable from a periscope");
   return final;
 }
-function globToRegExp(glob) {
+function globToRegExp2(glob) {
   let re = "";
   for (let i = 0; i < glob.length; i++) {
     const c = glob[i];
@@ -21913,7 +22196,7 @@ function createPeriscopeMcpServer(d, sc) {
     inputSchema: { pattern: z.string() },
     annotations: { readOnlyHint: true, openWorldHint: false }
   }, async ({ pattern }) => {
-    const re = globToRegExp(pattern);
+    const re = globToRegExp2(pattern);
     const listing = git(root, ["ls-files", "-z", "--cached", "--others", "--exclude-standard"]);
     const hits = listing.split("\0").filter((f) => f && re.test(f)).slice(0, MAX_SEARCH_RESULTS);
     return text(hits.length ? hits.join("\n") : "No matches found");
@@ -21927,7 +22210,7 @@ function createPeriscopeMcpServer(d, sc) {
     if (Buffer.byteLength(content) > MAX_WRITE_BYTES) return text(`content exceeds ${MAX_WRITE_BYTES} bytes`, true);
     const abs = await inTree(path);
     if (abs === await realpath(root)) return text("path must name a file", true);
-    await mkdir(dirname24(abs), { recursive: true });
+    await mkdir(dirname25(abs), { recursive: true });
     await inTree(path);
     await writeFile(abs, content);
     return text(`Wrote ${Buffer.byteLength(content)} bytes to ${await rel(abs)}`);
@@ -21967,7 +22250,7 @@ function createPeriscopeMcpServer(d, sc) {
     inputSchema: { path: z.string() },
     annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
   }, async ({ path }) => {
-    const parent = await inTree(dirname24(path) === "" ? "." : dirname24(path));
+    const parent = await inTree(dirname25(path) === "" ? "." : dirname25(path));
     const abs = join48(parent, basename14(path));
     if (basename14(path) === ".git" || abs === parent) return text("path must name a file", true);
     const st = await lstat(abs).catch(() => void 0);
@@ -22089,7 +22372,7 @@ function findPeriscope(sidecars, segment) {
 }
 
 // src/cli.ts
-var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname25(process.execPath) : resolve6(dirname25(fileURLToPath(import.meta.url)), "..");
+var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname26(process.execPath) : resolve6(dirname26(fileURLToPath(import.meta.url)), "..");
 var RELEASE_LOCK_TTL_MS = 20 * 60 * 1e3;
 var CYCLE_SECONDS2 = 120;
 var STALE_CYCLES = 3;
@@ -22138,12 +22421,12 @@ function terminalPrompter() {
       process.stderr.write(`${line}
 `);
     },
-    ask: async (q, fallback) => {
-      const a = (await rl.question(fallback ? `${q} [${fallback}]: ` : `${q}: `)).trim();
+    ask: async (q2, fallback) => {
+      const a = (await rl.question(fallback ? `${q2} [${fallback}]: ` : `${q2}: `)).trim();
       return a || fallback || "";
     },
-    confirm: async (q, fallback) => {
-      const a = (await rl.question(`${q} [${fallback ? "Y/n" : "y/N"}] `)).trim();
+    confirm: async (q2, fallback) => {
+      const a = (await rl.question(`${q2} [${fallback ? "Y/n" : "y/N"}] `)).trim();
       return a ? /^y/i.test(a) : fallback;
     }
   };
@@ -22268,6 +22551,7 @@ function usage(problem, requested = false) {
   crew shell-init [--shell zsh|bash|fish]   print the periscope shell function (install: eval "$(crew shell-init)")
   crew worktree [route] NNN      cut (or refresh) this run's worktree for a ticket from the remote; prints its path
   crew unassign [route] NNN      hand back a session's ticket \u2014 clears assignee, next cycle picks it up
+  crew sandbox cache [--prune|--reset] [--json]   list the sandbox cache volume's mirrors; --prune drops unserved repositories, --reset recreates the volume
   crew sync [route]              fast-forward the checkout and its worktrees from the remote
   crew pause|resume [route] [R|release]  pause everything, one role, or releases only (merge/deploy/release; passengers keeps running).
                                  resume with no argument clears only the whole-crew pause; a role or release pause needs its own resume
@@ -22584,6 +22868,31 @@ if (command === "passenger-sync-daemon") {
     const out = refreshBaseBranch(r.dir, remote, base, true);
     const unsafe = baseBranchUnsafe(out);
     return { action: out.action, unsafe, detail: unsafe ? describeUnsafeBase(out, remote, base) : out.detail };
+  }, sandboxCacheRepos = function(c, ship) {
+    const out = [];
+    for (const t of reposOf(c)) {
+      const origin = originUrlOf(t.dir, "origin");
+      const repo = origin ? parseRemote(origin) : null;
+      if (!repo) continue;
+      let token = null;
+      try {
+        token = readForgeToken(ship.forges, repo.host, ship.stateDir);
+      } catch {
+      }
+      out.push({ ...repo, dir: t.dir, token, username: forgeFor(ship.forges, repo.host)?.entry.username });
+    }
+    return out;
+  }, buildSandboxCachePass = function(c, ship, state2, emit2) {
+    const settings = cacheSettingsOf(ship.sandbox);
+    if (!settings) return void 0;
+    return makeCachePass({
+      cache: new SandboxCache(settings),
+      volume: settings.volume,
+      repos: () => sandboxCacheRepos(c, ship),
+      lock: (dir) => acquireCheckoutLock(dir),
+      fail: (key, message) => raiseShipAttention({ state: state2, emit: emit2, route: c, ship }, { kind: "sandbox_cache", key, message, since: (/* @__PURE__ */ new Date()).toISOString() }).then(() => void 0),
+      ok: (key) => clearShipAttention(state2, key)
+    });
   }, sandboxTickDeps = function(emit2, c) {
     return {
       stateDir: cfg.ship.stateDir,
@@ -22597,7 +22906,7 @@ if (command === "passenger-sync-daemon") {
       log: (m) => emit2.emit(m)
     };
   };
-  requireArmed2 = requireArmed, parseTicketNumber2 = parseTicketNumber, routeRelayUrl2 = routeRelayUrl, passengerApiKeys2 = passengerApiKeys, endpointApiFor2 = endpointApiFor, periscopeEndpointDeps2 = periscopeEndpointDeps, periscopeMcpDeps2 = periscopeMcpDeps, endpointReconcileDeps2 = endpointReconcileDeps, releaseRefused2 = releaseRefused, doctorMachineId2 = doctorMachineId, baseHealth2 = baseHealth, sandboxTickDeps2 = sandboxTickDeps;
+  requireArmed2 = requireArmed, parseTicketNumber2 = parseTicketNumber, routeRelayUrl2 = routeRelayUrl, passengerApiKeys2 = passengerApiKeys, endpointApiFor2 = endpointApiFor, periscopeEndpointDeps2 = periscopeEndpointDeps, periscopeMcpDeps2 = periscopeMcpDeps, endpointReconcileDeps2 = endpointReconcileDeps, releaseRefused2 = releaseRefused, doctorMachineId2 = doctorMachineId, baseHealth2 = baseHealth, sandboxCacheRepos2 = sandboxCacheRepos, buildSandboxCachePass2 = buildSandboxCachePass, sandboxTickDeps2 = sandboxTickDeps;
   let cfg;
   let firstRun;
   let firstRunFromFlags = false;
@@ -22702,7 +23011,7 @@ if (command === "passenger-sync-daemon") {
   const DAEMON_SUBCOMMANDS = /* @__PURE__ */ new Set(["start", "stop", "status", "restart"]);
   const worktreeArgs = command === "worktree" ? splitWorktreeArgs(positional, cfg.routes.map((r) => r.route)) : void 0;
   const named = worktreeArgs ? worktreeArgs.route : command === "daemon" && DAEMON_SUBCOMMANDS.has(positional[1] ?? "") ? positional[2] : positional[1];
-  const fleetWide = command === "inbox" || command === "connect" || command === "disconnect" || command === "deprovision" || command === "agents" || command === "skills" || command === "logbook" || command === "repos" || command === "ship" || command === "projects" || command === "periscope" || command === "sandbox" || command === "whoami" || releaseFleetWide || command === "pause" || command === "resume" || command === "reload" || FLEET_CAPABLE.has(command) && !named && cfg.routes.length > 1 || worktreeArgs !== void 0 && !named && cfg.routes.length > 1;
+  const fleetWide = command === "inbox" || command === "connect" || command === "disconnect" || command === "deprovision" || command === "agents" || command === "skills" || command === "logbook" || command === "repos" || command === "ship" || command === "projects" || command === "periscope" || command === "whoami" || command === "sandbox" || releaseFleetWide || command === "pause" || command === "resume" || command === "reload" || FLEET_CAPABLE.has(command) && !named && cfg.routes.length > 1 || worktreeArgs !== void 0 && !named && cfg.routes.length > 1;
   let route2;
   try {
     route2 = fleetWide ? cfg.routes[0] : findRoute(cfg, named);
@@ -23051,7 +23360,14 @@ ${changed2.map((c) => `  - ${c}
     const out = /* @__PURE__ */ new Map();
     for (const c of routes) {
       const { settled } = await settleRepos(reposOf(c), (t) => t.name, (t) => resolveOneRepo(c, t));
-      for (const r of settled) if (r.config.sandbox && !out.has(r.name)) out.set(r.name, { name: r.name, decl: r.config.sandbox });
+      for (const r of settled) if (r.config.sandbox && !out.has(r.name)) {
+        let warm = {};
+        try {
+          warm = readWarmFiles(r.dir, `${r.config.branch.remote}/${r.config.branch.base}`, r.config.sandbox.warm ?? []);
+        } catch {
+        }
+        out.set(r.name, { name: r.name, decl: r.config.sandbox, warm });
+      }
     }
     return [...out.values()];
   }
@@ -24225,6 +24541,7 @@ ${cu.tail.trimEnd()}
       });
       if (controlServer) emit.emit(`control API listening on ${controlServer.path}`);
       const inFlight = /* @__PURE__ */ new Set();
+      const sandboxCachePass = cfg.ship.runner === "sandbox" ? buildSandboxCachePass(route2, cfg.ship, state, emit) : void 0;
       let sandboxBuilding = false;
       const stopReason = await runDaemonLoop({
         inFlight,
@@ -24233,6 +24550,7 @@ ${cu.tail.trimEnd()}
         ),
         runPass: () => runOnePass({
           inFlight,
+          sandboxCache: sandboxCachePass,
           route: route2,
           ship: cfg.ship,
           state,
@@ -24542,7 +24860,7 @@ ${cu.tail.trimEnd()}
           const found = cfg.routes.find((r) => r.route === routeArg);
           if (!found) throw new ReposError(`no route "${routeArg}" in the config (have: ${cfg.routes.map((r) => r.route).join(", ") || "none"})`);
           const named2 = value("route") ? void 0 : positional[3];
-          const dir = named2 ? repoDirOf(configText, dirname25(cfg.configFile), found.route, named2) : resolvePath(positional[value("route") ? 2 : 3] ?? ".");
+          const dir = named2 ? repoDirOf(configText, dirname26(cfg.configFile), found.route, named2) : resolvePath(positional[value("route") ? 2 : 3] ?? ".");
           const target = reposOf(found).find((t) => resolvePath(t.dir) === dir || t.name === named2);
           const o = target ? found.repoOverrides[target.name] : void 0;
           runReposCheck(dir, {
@@ -24565,7 +24883,7 @@ ${cu.tail.trimEnd()}
       if (sub === "hooks") {
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
-          const dir = repoDirOf(configText, dirname25(cfg.configFile), a.route, a.name);
+          const dir = repoDirOf(configText, dirname26(cfg.configFile), a.route, a.name);
           if (!existsSync45(dir)) throw new ReposError(`${dir} does not exist on disk`);
           const files = { exists: (r) => existsSync45(resolvePath(dir, r)), list: (r) => {
             try {
@@ -24732,7 +25050,7 @@ ${cu.tail.trimEnd()}
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text2 = configText;
-      const base = dirname25(cfg.configFile);
+      const base = dirname26(cfg.configFile);
       const isCheckout = (d) => existsSync45(`${d}/.git`);
       try {
         if (sub === "list") {
@@ -25408,7 +25726,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.stderr.write(`(dry run) would write resolved ids to ${resolvedPath}
 `);
         } else {
-          mkdirSync30(dirname25(resolvedPath), { recursive: true });
+          mkdirSync30(dirname26(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
           writeFileSync33(tmpPath, `${JSON.stringify(resolved, null, 2)}
@@ -25457,7 +25775,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             process.stderr.write(`(dry run) would write the minted API key to ${apiKeyFile}
 `);
           } else {
-            mkdirSync30(dirname25(apiKeyFile), { recursive: true });
+            mkdirSync30(dirname26(apiKeyFile), { recursive: true });
             writeFileSync33(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
@@ -26028,7 +26346,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       if (subS === "images") {
         const stateS = readSandboxState(cfg.ship.stateDir);
         const rows = declared.map((r) => {
-          const plan = planSandbox(r.name, r.decl);
+          const plan = planSandbox(r.name, r.decl, r.warm);
           return { repo: r.name, wants: plan.tag, tags: stateS[r.name]?.tags ?? [], ...sandboxImageStatus(stateS, plan) };
         });
         if (jsonS) {
@@ -26062,7 +26380,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       for (const t of targets) {
         await sandboxBuildTick([t], depsS, true);
         const after = readSandboxState(cfg.ship.stateDir);
-        const st = sandboxImageStatus(after, planSandbox(t.name, t.decl));
+        const st = sandboxImageStatus(after, planSandbox(t.name, t.decl, t.warm));
         if (st.status === "failed") failed = true;
         process.stdout.write(`${t.name}: ${st.status} \u2014 ${st.detail}
 `);
@@ -26781,7 +27099,7 @@ ${where.join("\n")}`);
       if (!route2.resolved) fail(`route ${route2.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route2, cfg.ship);
       const configText = readFileSync40(cfg.configFile, "utf8");
-      const cfgBase = dirname25(cfg.configFile);
+      const cfgBase = dirname26(cfg.configFile);
       const configured2 = configuredRepos(configText, route2.route, cfgBase);
       const dir = configured2.find((r) => r.name === SAMPLE_REPO)?.dir ?? sampleDir(configured2.map((r) => r.dir), route2.reposBasePath, route2.route.split("/")[0]);
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, route2.route);
@@ -26943,6 +27261,45 @@ ${where.join("\n")}`);
       if (results.some((r) => !r.ok)) process.exitCode = 1;
       break;
     }
+    case "sandbox": {
+      const settings = cacheSettingsOf(cfg.ship.sandbox);
+      if (positional[1] !== "cache") {
+        process.stderr.write("crew sandbox cache [--prune|--reset] [--json]\n");
+        process.exit(2);
+      }
+      if (!settings) {
+        process.stderr.write("crew sandbox cache: ship.sandbox.cacheVolume is not set, so there is no cache volume\n");
+        process.exit(2);
+      }
+      const cache = new SandboxCache(settings);
+      const served = cfg.routes.flatMap((r) => sandboxCacheRepos(r, cfg.ship));
+      try {
+        if (flag("reset")) {
+          await cache.reset();
+          process.stdout.write(`recreated volume ${settings.volume}; the next daemon pass refreshes every mirror
+`);
+          break;
+        }
+        const dropped = flag("prune") ? await cache.prune(served) : [];
+        const mirrors = await cache.list();
+        if (flag("json")) {
+          process.stdout.write(`${JSON.stringify({ volume: settings.volume, mirrors, dropped }, null, 2)}
+`);
+        } else {
+          for (const d of dropped) process.stdout.write(`dropped ${d.host}/${d.path}
+`);
+          if (mirrors.length === 0) process.stdout.write(`volume ${settings.volume}: no mirrors yet
+`);
+          for (const m of mirrors) process.stdout.write(`${m.repo.host}/${m.repo.path}  last refresh ${m.lastRefresh ?? "never"}
+`);
+        }
+      } catch (e) {
+        process.stderr.write(`crew sandbox cache: ${e instanceof Error ? e.message : String(e)}
+`);
+        process.exitCode = 1;
+      }
+      break;
+    }
     case "whoami": {
       const only = value("route") ?? positional[1];
       const wanted = only ? cfg.routes.filter((r) => r.route === only) : cfg.routes;
@@ -27761,7 +28118,7 @@ ${foreign.join("\n")}
         const declaredS = await sandboxReposOf(cfg.routes.filter((r) => r.enabled));
         const stateS = readSandboxState(cfg.ship.stateDir);
         for (const r of declaredS) {
-          const st = sandboxImageStatus(stateS, planSandbox(r.name, r.decl));
+          const st = sandboxImageStatus(stateS, planSandbox(r.name, r.decl, r.warm));
           process.stdout.write(`sandbox image:    ${r.name}: ${st.status.toUpperCase()} \u2014 ${st.detail}
 `);
         }
@@ -27824,4 +28181,6 @@ var endpointReconcileDeps2;
 var releaseRefused2;
 var doctorMachineId2;
 var baseHealth2;
+var sandboxCacheRepos2;
+var buildSandboxCachePass2;
 var sandboxTickDeps2;