@tablation/crew 0.81.0 → 0.82.0

package/dist/cli.js

@@ -6479,7 +6479,7 @@ var Tracker = class {
    * `beatIdle` in a `finally` — the same shape as `setCrewStatus`'s
    * working/idle pair, one level up (ship, not seat).
    */
-  async beatEngaged(shipName2, connectionName, ticketRecordId) {
+  async beatEngaged(shipName2, connectionName, ticketRecordId, since2) {
     const row = await this.myShipRow(shipName2);
     if (!row) return;
     await this.client.records.update(this.route.resolved.shipsModelId, row.id, {
@@ -6487,7 +6487,7 @@ var Tracker = class {
       host: hostname(),
       pid: process.pid,
       engaged: true,
-      engaged_since: (/* @__PURE__ */ new Date()).toISOString(),
+      engaged_since: since2 ?? (/* @__PURE__ */ new Date()).toISOString(),
       engaged_connection: connectionName,
       engaged_ticket_id: ticketRecordId,
       ...this.attentionPatch(row)
@@ -8561,6 +8561,8 @@ function planAgentRun(o) {
     eventsPath: join19(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
@@ -8975,6 +8977,8 @@ function spawnAgent(plan, emit, hintMoved) {
         route: plan.route,
         ticket: plan.ticket ?? null,
         ticketRecordId: plan.ticketRecordId ?? null,
+        repo: plan.repo ?? null,
+        routeName: plan.routeName,
         model: plan.model,
         toolchain: id.toolchain,
         harness: id.harness,
@@ -9546,7 +9550,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve5, dirname as dirname20, join as join37, basename as basename12 } from "path";
+import { resolve as resolve5, dirname as dirname20, join as join38, basename as basename12 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir10 } from "os";
 import { spawnSync as spawnSync7 } from "child_process";
@@ -13379,6 +13383,164 @@ Passed: ${passed}.${willClose ? " Closing this alert." : ""}`,
   return out;
 }
 
+// src/live-runs.ts
+import { existsSync as existsSync24, readdirSync as readdirSync10 } from "fs";
+import { join as join28 } from "path";
+
+// src/interrupted.ts
+import { existsSync as existsSync23, readdirSync as readdirSync9, readFileSync as readFileSync21 } from "fs";
+import { join as join27 } from "path";
+var INTERRUPTED_MARKER = calloutHeader("NOTE", "Interrupted");
+function interruptedComment(b) {
+  const tree = b.dirty === null ? "The worktree could not be checked." : b.dirty ? "The worktree has uncommitted changes \u2014 they are this seat's own, from that run." : "The worktree is clean.";
+  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 (!existsSync23(path)) return false;
+  try {
+    return JSON.parse(readFileSync21(path, "utf8")).running !== true;
+  } catch {
+    return true;
+  }
+}
+function orphanedStreams(o) {
+  const dir = join27(o.stateDir, "streams");
+  if (!existsSync23(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 = join27(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
+function liveRuns(stateDir, isAlive = runIsAlive) {
+  const dir = join28(stateDir, "streams");
+  if (!existsSync24(dir)) return [];
+  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 || !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 slug = routeSlug(o.route.route);
+  const seatSiblings = siblingRuns(all.filter((r) => r.role === o.role && r.route === slug), 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" });
+    }
+  }
+  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 describeRun(run2, route, seatIds, worktreeOf = (d, n) => {
+  try {
+    return worktreeForNumber(d, n)?.path ?? null;
+  } catch {
+    return null;
+  }
+}) {
+  const ownRoute = run2.route === routeSlug(route.route);
+  const repoDir = run2.repo ? reposOf(route).find((t) => t.name === run2.repo)?.dir : void 0;
+  const num = run2.ticket?.replace(/^\D+/, "") ?? "";
+  return {
+    role: run2.role,
+    seat: ownRoute ? seatIds[run2.role] ?? null : null,
+    ticket: run2.ticket,
+    ticketRecordId: run2.ticketRecordId,
+    repo: run2.repo ?? null,
+    worktree: repoDir && num ? worktreeOf(repoDir, num) : null,
+    stream: run2.streamPath,
+    pid: run2.pid,
+    startedAt: run2.spawnedAt
+  };
+}
+
 // src/projects-cmd.ts
 async function buildProjectsReport(routes, open) {
   return Promise.all(routes.map(async (r) => {
@@ -13588,7 +13750,7 @@ function missingReleaserWarning(repo, release, ships, now = Date.now()) {
 }
 
 // src/watch.ts
-import { watch as watchFile, existsSync as existsSync23, statSync as statSync7, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
+import { watch as watchFile, existsSync as existsSync25, statSync as statSync7, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
 var E = "\x1B[";
 var dim = (s) => `${E}2m${s}${E}0m`;
 var bold = (s) => `${E}1m${s}${E}0m`;
@@ -13689,7 +13851,7 @@ function renderHeaders(states, now = Date.now()) {
   return states.map((s) => renderHeader(s, now)).join("");
 }
 function readFrom(file, from) {
-  if (!existsSync23(file)) return { events: [], offset: from };
+  if (!existsSync25(file)) return { events: [], offset: from };
   const size = statSync7(file).size;
   if (size < from) return readFrom(file, 0);
   if (size === from) return { events: [], offset: from };
@@ -13932,17 +14094,17 @@ function nextRoles(decision, ran) {
 }
 
 // src/ship-name.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync16, readFileSync as readFileSync22, renameSync as renameSync2, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync23, renameSync as renameSync2, writeFileSync as writeFileSync18 } from "fs";
 import { dirname as dirname14 } from "path";
 import { parseDocument } from "yaml";
 
 // src/machine-id.ts
 import { execFileSync as execFileSync4 } from "child_process";
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync24, mkdirSync as mkdirSync15, readFileSync as readFileSync21, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname13, join as join27 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync15, readFileSync as readFileSync22, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname13, join as join29 } from "path";
 function machineIdPathFor(stateDir) {
-  return join27(stateDir, "machine-id");
+  return join29(stateDir, "machine-id");
 }
 var sha256 = (s) => createHash4("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
@@ -13955,8 +14117,8 @@ function readRawMachineId(platform2 = process.platform) {
       return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(out)?.[1];
     }
     for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
-      if (existsSync24(p)) {
-        const id = readFileSync21(p, "utf8").trim();
+      if (existsSync26(p)) {
+        const id = readFileSync22(p, "utf8").trim();
         if (id) return id;
       }
     }
@@ -13967,8 +14129,8 @@ function readRawMachineId(platform2 = process.platform) {
 function ensureMachineId(stateDir, opts = {}) {
   if (opts.override?.trim()) return sha256(opts.override.trim());
   const path = machineIdPathFor(stateDir);
-  if (existsSync24(path)) {
-    const cached = readFileSync21(path, "utf8").trim();
+  if (existsSync26(path)) {
+    const cached = readFileSync22(path, "utf8").trim();
     if (/^[0-9a-f]{64}$/.test(cached)) return cached;
   }
   const raw = (opts.read ?? readRawMachineId)();
@@ -14046,19 +14208,19 @@ async function syncRouteName(i) {
   return { status: "ok", ...base, action, name: i.local };
 }
 function readSyncedName(resolvedFile) {
-  if (!existsSync25(resolvedFile)) return void 0;
+  if (!existsSync27(resolvedFile)) return void 0;
   try {
-    const v = JSON.parse(readFileSync22(resolvedFile, "utf8")).shipName;
+    const v = JSON.parse(readFileSync23(resolvedFile, "utf8")).shipName;
     return typeof v === "string" ? v : void 0;
   } catch {
     return void 0;
   }
 }
 function writeSyncedName(resolvedFile, name) {
-  if (!existsSync25(resolvedFile)) return;
+  if (!existsSync27(resolvedFile)) return;
   let raw;
   try {
-    raw = JSON.parse(readFileSync22(resolvedFile, "utf8"));
+    raw = JSON.parse(readFileSync23(resolvedFile, "utf8"));
   } catch {
     return;
   }
@@ -14073,7 +14235,7 @@ function writeSyncedName(resolvedFile, name) {
 async function reconcileShipName(i) {
   let local = i.ship.name;
   try {
-    local = shipNameOfYaml(readFileSync22(i.configFile, "utf8")) ?? local;
+    local = shipNameOfYaml(readFileSync23(i.configFile, "utf8")) ?? local;
   } catch {
   }
   const resolvedFile = resolvedPathFor(i.stateDir, i.route);
@@ -14097,7 +14259,7 @@ async function reconcileShipName(i) {
   }
   if (result.status !== "ok") return result;
   if (result.action === "adopt" || result.action === "row-wins") {
-    const text = readFileSync22(i.configFile, "utf8");
+    const text = readFileSync23(i.configFile, "utf8");
     writeFileSync18(i.configFile, setShipNameInYaml(text, result.name));
     i.ship.name = result.name;
     if (result.action === "row-wins") {
@@ -14743,7 +14905,7 @@ function describeCapability(i) {
 }
 
 // src/agents-sync-run.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync17, readFileSync as readFileSync23, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync24, writeFileSync as writeFileSync19 } from "fs";
 import { dirname as dirname15 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
@@ -14777,7 +14939,7 @@ async function runAgentsSync(target, o) {
   for (const s of skillResult?.outcomes ?? []) o.say(describeSkillSyncOutcome(s));
   if (!dryRun) {
     const resolvedPath = resolvedPathFor(o.stateDir, target.route);
-    const raw = existsSync26(resolvedPath) ? JSON.parse(readFileSync23(resolvedPath, "utf8")) : {};
+    const raw = existsSync28(resolvedPath) ? JSON.parse(readFileSync24(resolvedPath, "utf8")) : {};
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
@@ -14886,7 +15048,7 @@ async function showLogEntry(route, entryId, opts = {}) {
 
 // src/repos-check.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { readFileSync as readFileSync24 } from "fs";
+import { readFileSync as readFileSync25 } from "fs";
 import { basename as basename8 } from "path";
 var POSIX_SHELL = /^(?:ba|z|da|k|a|mk)?sh$|^fish$/;
 function checkHookSyntax(script, shell) {
@@ -14927,7 +15089,7 @@ function checkRepoSpec(dir, opts = {}) {
   }
   let parsed;
   try {
-    parsed = parseRepoConfig(readFileSync24(file, "utf8"), file);
+    parsed = parseRepoConfig(readFileSync25(file, "utf8"), file);
   } catch (e) {
     if (!(e instanceof RepoConfigError)) throw e;
     return { ...empty, file, error: e.message, exitCode: 1 };
@@ -14984,7 +15146,7 @@ import { isMap as isMap2, parseDocument as parseDocument3, YAMLMap } from "yaml"
 
 // src/repos-cmd.ts
 import { homedir as homedir9 } from "os";
-import { basename as basename9, join as join28, resolve as resolve3 } from "path";
+import { basename as basename9, join as join30, resolve as resolve3 } from "path";
 import { isMap, isSeq, parseDocument as parseDocument2, stringify as stringify2 } from "yaml";
 var ReposError = class extends Error {
 };
@@ -15262,7 +15424,7 @@ function planRepoClone(i) {
   }
   const ship = doc.get("ship", true);
   const basePath = String(m.get("reposBasePath") ?? (isMap(ship) ? ship.get("reposBasePath") : void 0) ?? "~/Crew");
-  const target = i.dir ? expandDir(i.dir, i.base) : join28(expandDir(basePath, i.base), i.route.split("/")[0], name);
+  const target = i.dir ? expandDir(i.dir, i.base) : join30(expandDir(basePath, i.base), i.route.split("/")[0], name);
   const add = planRepoAdd({ text: i.text, base: i.base, route: i.route, path: target, origin: remote, resolved: i.resolved, name, isCheckout: i.isCheckout });
   return { ...add, remote, target };
 }
@@ -15661,7 +15823,7 @@ ${run2.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename10, dirname as dirname17, join as join29 } from "path";
+import { basename as basename10, dirname as dirname17, join as join31 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -15684,8 +15846,8 @@ has something safe to work on: its test and build hooks always pass, it has no
 remote, and \`crew sample-ticket --remove\` deletes it.
 `;
 function sampleDir(existing, reposBase, workspace) {
-  if (existing.length > 0) return join29(dirname17(existing[0]), SAMPLE_REPO);
-  return join29(reposBase, workspace, SAMPLE_REPO);
+  if (existing.length > 0) return join31(dirname17(existing[0]), SAMPLE_REPO);
+  return join31(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
 function sampleDescription() {
@@ -15777,8 +15939,8 @@ function schedulerInstalled(plan, exists, crontab) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync27, readFileSync as readFileSync25, readdirSync as readdirSync9 } from "fs";
-import { basename as basename11, dirname as dirname18, join as join30, resolve as resolve4 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync26, readdirSync as readdirSync11 } from "fs";
+import { basename as basename11, dirname as dirname18, join as join32, 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;
@@ -15837,7 +15999,7 @@ function siblingWorktreeDirs(target) {
   const registered = new Set(worktrees(target.dir).map((w) => resolve4(w.path)));
   let names;
   try {
-    names = readdirSync9(parent);
+    names = readdirSync11(parent);
   } catch {
     return [];
   }
@@ -15845,7 +16007,7 @@ function siblingWorktreeDirs(target) {
   for (const name of names) {
     if (!name.startsWith(stem)) continue;
     const m = DIR_NUMBER_SUFFIXED.exec(name);
-    const path = join30(parent, name);
+    const path = join32(parent, name);
     if (m && !registered.has(resolve4(path))) out.push({ path, number: m[1] });
   }
   return out;
@@ -15880,7 +16042,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
   let removed = 0;
   let keptBranches = 0;
   for (const a of actions) {
-    if (!dryRun && base && !a.keepBranch && existsSync27(a.path) && isHandBackMerge(a.path, base)) {
+    if (!dryRun && base && !a.keepBranch && existsSync29(a.path) && isHandBackMerge(a.path, base)) {
       if (gitOk(a.path, ["merge", "--abort"]) !== null) {
         log.emit(
           `abandoned the hand-back merge of ${base} in ${a.path}: ${a.ticket.issue_id} deployed without it`,
@@ -15888,7 +16050,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         );
       }
     }
-    if (!dryRun && existsSync27(a.path)) {
+    if (!dryRun && existsSync29(a.path)) {
       let dirty = false;
       try {
         dirty = status(a.path).length > 0;
@@ -15899,7 +16061,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         continue;
       }
     }
-    if (!dryRun && a.requirePushed && a.branch && existsSync27(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
+    if (!dryRun && a.requirePushed && a.branch && existsSync29(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
       refuse(a, "unpushed commits", `${a.branch} has commits that are not on ${remote}`);
       continue;
     }
@@ -15948,7 +16110,7 @@ function isHandBackMerge(path, base) {
   if (!msgPath) return false;
   let first;
   try {
-    first = readFileSync25(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
+    first = readFileSync26(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
   } catch {
     return false;
   }
@@ -16053,14 +16215,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync28, readdirSync as readdirSync10, rmSync as rmSync13, statSync as statSync8 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync30, readdirSync as readdirSync12, rmSync as rmSync13, statSync as statSync8 } from "fs";
+import { join as join33 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join31(stateDir, "streams");
-  if (!existsSync28(dir)) return [];
+  const dir = join33(stateDir, "streams");
+  if (!existsSync30(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync10(dir).map((name) => join31(dir, name)).filter((path) => {
+  return readdirSync12(dir).map((name) => join33(dir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -16086,9 +16248,9 @@ function applyStreamSweep(paths, dryRun, log) {
   return removed;
 }
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
-  if (!existsSync28(stateDir)) return [];
+  if (!existsSync30(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync10(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join31(stateDir, name)).filter((path) => {
+  return readdirSync12(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join33(stateDir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -16098,23 +16260,23 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync31, existsSync as existsSync34, mkdirSync as mkdirSync22, writeFileSync as writeFileSync23, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync15 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync31, existsSync as existsSync35, mkdirSync as mkdirSync22, writeFileSync as writeFileSync23, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync16 } from "fs";
 import { createInterface } from "readline/promises";
 import { dirname as dirOf, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync29, mkdirSync as mkdirSync18, readFileSync as readFileSync26, chmodSync } from "fs";
-import { dirname as dirname19, join as join32 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync18, readFileSync as readFileSync27, chmodSync } from "fs";
+import { dirname as dirname19, join as join34 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join32(stateDir, "ssh", "id_ed25519");
+  return join34(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync29(privateKeyPath)) {
+  if (!existsSync31(privateKeyPath)) {
     mkdirSync18(dirname19(privateKeyPath), { recursive: true });
     try {
       execFileSync6("ssh-keygen", [
@@ -16135,10 +16297,10 @@ function ensureShipSshKeypair(stateDir) {
     }
     chmodSync(privateKeyPath, 384);
   }
-  if (!existsSync29(publicKeyPath)) {
+  if (!existsSync31(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync26(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync27(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -16355,9 +16517,9 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync30, mkdirSync as mkdirSync19, readFileSync as readFileSync27, writeFileSync as writeFileSync20, unlinkSync as unlinkSync3, readdirSync as readdirSync11 } from "fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync28, writeFileSync as writeFileSync20, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
 import { randomInt } from "crypto";
-import { join as join33 } from "path";
+import { join as join35 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn5(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -16424,20 +16586,20 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join33(stateDir, "passengers", `${workspaceId}.json`);
+  return join35(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
-  if (!existsSync30(path)) return void 0;
+  if (!existsSync32(path)) return void 0;
   try {
-    return JSON.parse(readFileSync27(path, "utf8"));
+    return JSON.parse(readFileSync28(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync19(join33(stateDir, "passengers"), { recursive: true });
+  mkdirSync19(join35(stateDir, "passengers"), { recursive: true });
   writeFileSync20(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -16535,9 +16697,9 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join33(stateDir, "passengers");
-  if (!existsSync30(dir)) return [];
-  return readdirSync11(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
+  const dir = join35(stateDir, "passengers");
+  if (!existsSync32(dir)) return [];
+  return readdirSync13(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
 // src/mcp-endpoint-registry.ts
@@ -16657,8 +16819,8 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn6 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync31, mkdirSync as mkdirSync20, readFileSync as readFileSync28, writeFileSync as writeFileSync21, unlinkSync as unlinkSync4, readdirSync as readdirSync12 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync20, readFileSync as readFileSync29, writeFileSync as writeFileSync21, unlinkSync as unlinkSync4, readdirSync as readdirSync14 } from "fs";
+import { join as join36 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -16747,20 +16909,20 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join34(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join36(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
-  if (!existsSync31(path)) return void 0;
+  if (!existsSync33(path)) return void 0;
   try {
-    return JSON.parse(readFileSync28(path, "utf8"));
+    return JSON.parse(readFileSync29(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync20(join34(stateDir, "passengers"), { recursive: true });
+  mkdirSync20(join36(stateDir, "passengers"), { recursive: true });
   writeFileSync21(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -16781,10 +16943,10 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join34(stateDir, "passengers");
-  if (!existsSync31(dir)) return [];
+  const dir = join36(stateDir, "passengers");
+  if (!existsSync33(dir)) return [];
   const suffix = "-sync.json";
-  return readdirSync12(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
+  return readdirSync14(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
 function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
   const alive = deps.isPidAlive ?? isPidAlive;
@@ -16870,98 +17032,9 @@ function describeCause(err) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync30, readdirSync as readdirSync14, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync22 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync30, readdirSync as readdirSync15, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync22 } from "fs";
+import { join as join37 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
-
-// src/interrupted.ts
-import { existsSync as existsSync32, readdirSync as readdirSync13, readFileSync as readFileSync29 } from "fs";
-import { join as join35 } 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 (!existsSync32(path)) return false;
-  try {
-    return JSON.parse(readFileSync29(path, "utf8")).running !== true;
-  } catch {
-    return true;
-  }
-}
-function orphanedStreams(o) {
-  const dir = join35(o.stateDir, "streams");
-  if (!existsSync32(dir)) return [];
-  const ownerAlive = o.isOwnerAlive ?? pidAlive;
-  const out = [];
-  for (const name of readdirSync13(dir)) {
-    if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join35(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/daemon.ts
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
 var defaultSleep = (ms2) => new Promise((resolve6) => setTimeout(resolve6, ms2));
@@ -17030,8 +17103,8 @@ function latestMtime(path) {
   if (stat.isFile()) return stat.mtimeMs;
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
-  for (const entry of readdirSync14(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join36(path, entry.name)));
+  for (const entry of readdirSync15(path, { withFileTypes: true })) {
+    latest = Math.max(latest, latestMtime(join37(path, entry.name)));
   }
   return latest;
 }
@@ -17040,13 +17113,13 @@ function computeTreeSignature(paths) {
 }
 function makeStaleChecker(paths, opts = {}) {
   const initial = computeTreeSignature(paths);
-  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync33(opts.reloadSentinel);
+  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync34(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join36(stateDir, "reload-requested");
+  return join37(stateDir, "reload-requested");
 }
 function daemonStampFor(stateDir) {
-  return join36(stateDir, "daemon.started");
+  return join37(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
   mkdirSync21(stateDir, { recursive: true });
@@ -17309,13 +17382,15 @@ async function reconcileForRoute(ctx, o) {
           await guardRunHandoff(route, ship, tracker, sc.role, sc.ticketRecordId, emit, sc.spawnedAt);
         }
       } finally {
-        if (memberId) {
-          await tracker.setCrewStatus(memberId, "idle").catch((e) => {
-            emit.warn(`could not clear crew status: ${e.message}`, { step: "agent" });
-          });
-        }
-        await tracker.beatIdle(ship.name).catch((e) => {
-          emit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
+        await settleRunEnd({
+          tracker,
+          shipName: ship.name,
+          route,
+          role: sc.role,
+          memberId,
+          ownTicketRecordId: sc.ticketRecordId,
+          stateDir: ship.stateDir,
+          emit
         });
       }
     }
@@ -17469,18 +17544,16 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
     await spawnAgent(plan, emit, hintMoved);
     await guardRunHandoff(route, ship, tracker, role, workingId, emit, runStart);
   } finally {
-    if (memberId) {
-      try {
-        await tracker.setCrewStatus(memberId, "idle");
-      } catch (e) {
-        emit.warn(`could not clear crew status: ${e.message}`, { step: "agent" });
-      }
-    }
-    try {
-      await tracker.beatIdle(ship.name);
-    } catch (e) {
-      emit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
-    }
+    await settleRunEnd({
+      tracker,
+      shipName: ship.name,
+      route,
+      role,
+      memberId,
+      ownTicketRecordId: workingId,
+      stateDir: ship.stateDir,
+      emit
+    });
   }
 }
 async function buildEnvironment(route, ship, ticket) {
@@ -17922,7 +17995,7 @@ if (command === "passenger-sync-daemon") {
     } else {
       const toleratesNoRoutes = command === "repos" || command === "ship" || command === "disconnect" && flag("reset") || command === "connect" && flag("sign-out");
       const configless = command === "connect" && flag("sign-out") || command === "disconnect" && flag("reset");
-      if (configless && !existsSync34(findConfigFile(CREW_HOME))) {
+      if (configless && !existsSync35(findConfigFile(CREW_HOME))) {
         cfg = loadConfig(CREW_HOME, firstRunConfigPath(), { text: "ship: {}\n", allowNoRoutes: true });
       } else {
         cfg = loadConfig(CREW_HOME, void 0, toleratesNoRoutes ? { allowNoRoutes: true } : {});
@@ -18160,8 +18233,8 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join37(homedir10(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync34(staleTimer)) {
+      const staleTimer = join38(homedir10(), ".config", "systemd", "user", `${label}.timer`);
+      if (existsSync35(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -18188,7 +18261,7 @@ if (command === "passenger-sync-daemon") {
     const tracker = new Tracker(c, cfg.ship);
     problems.push(...validateContract(tracker.contract).map((p) => `contract: ${p}`));
     for (const r of await resolvedRepos(c)) {
-      if (!existsSync34(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync35(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
       if (!satisfies(host, r.config.platform)) problems.push(`repo ${r.name}: requires ${r.config.platform}, this host is ${host}`);
       readiness.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
     }
@@ -18206,7 +18279,7 @@ if (command === "passenger-sync-daemon") {
   }
   async function doctorFix(o) {
     const routes = await Promise.all(routesInScope(cfg.routes, named).map((c) => gatherHealth({ route: c.route, enabled: c.enabled, hasRepos: reposOf(c).length > 0 }, () => routeProblems(c))));
-    const unitExists = (p) => existsSync34(p);
+    const unitExists = (p) => existsSync35(p);
     const crontab = o.host === "linux" ? spawnSync7("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
     const schedulerAbsent = o.host !== "windows" ? !schedulerInstalled(planInstall(cfg.ship, CREW_HOME, o.host, detectSystemd(), "run"), unitExists, crontab) : true;
     const plan = planFix({ routes, schedulerAbsent, host: o.host });
@@ -18995,18 +19068,16 @@ ${cu.tail.trimEnd()}
           await guardRunHandoff(w.route, cfg.ship, fleetTracker, w.role, fleetWorkingId, wemit, runStart);
         } finally {
           dropLock();
-          if (fleetMemberId) {
-            try {
-              await fleetTracker.setCrewStatus(fleetMemberId, "idle");
-            } catch (e) {
-              wemit.warn(`could not clear crew status: ${e.message}`, { step: "agent" });
-            }
-          }
-          try {
-            await fleetTracker.beatIdle(cfg.ship.name);
-          } catch (e) {
-            wemit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
-          }
+          await settleRunEnd({
+            tracker: fleetTracker,
+            shipName: cfg.ship.name,
+            route: w.route,
+            role: w.role,
+            memberId: fleetMemberId,
+            ownTicketRecordId: fleetWorkingId,
+            stateDir: cfg.ship.stateDir,
+            emit: wemit
+          });
         }
         if (!skipInlineRelease) await releaseFleet();
         break;
@@ -19236,18 +19307,16 @@ ${cu.tail.trimEnd()}
           await guardRunHandoff(route, cfg.ship, tracker2, current, workingId, emit, runStart);
         } finally {
           dropLock();
-          if (memberId) {
-            try {
-              await tracker2.setCrewStatus(memberId, "idle");
-            } catch (e) {
-              emit.warn(`could not clear crew status: ${e.message}`, { step: "agent" });
-            }
-          }
-          try {
-            await tracker2.beatIdle(cfg.ship.name);
-          } catch (e) {
-            emit.warn(`could not beat ship idle: ${e.message}`, { step: "agent" });
-          }
+          await settleRunEnd({
+            tracker: tracker2,
+            shipName: cfg.ship.name,
+            route,
+            role: current,
+            memberId,
+            ownTicketRecordId: workingId,
+            stateDir: cfg.ship.stateDir,
+            emit
+          });
         }
         ran.push(current);
         if (ran.length >= maxRoles || explicitRole) break;
@@ -19331,7 +19400,7 @@ ${cu.tail.trimEnd()}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join37(CREW_HOME, "src"), join37(CREW_HOME, "dist"), join37(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join38(CREW_HOME, "src"), join38(CREW_HOME, "dist"), join38(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -19560,7 +19629,7 @@ ${cu.tail.trimEnd()}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync34(resolvedPath) ? JSON.parse(readFileSync31(resolvedPath, "utf8")) : {};
+        const raw = existsSync35(resolvedPath) ? JSON.parse(readFileSync31(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
         mkdirSync22(dirOf(resolvedPath), { recursive: true });
         writeFileSync23(resolvedPath, `${JSON.stringify(raw, null, 2)}
@@ -19664,10 +19733,10 @@ ${cu.tail.trimEnd()}
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
           const dir = repoDirOf(configText, dirname20(cfg.configFile), a.route, a.name);
-          if (!existsSync34(dir)) throw new ReposError(`${dir} does not exist on disk`);
-          const files = { exists: (r) => existsSync34(resolvePath(dir, r)), list: (r) => {
+          if (!existsSync35(dir)) throw new ReposError(`${dir} does not exist on disk`);
+          const files = { exists: (r) => existsSync35(resolvePath(dir, r)), list: (r) => {
             try {
-              return readdirSync15(resolvePath(dir, r));
+              return readdirSync16(resolvePath(dir, r));
             } catch {
               return [];
             }
@@ -19783,7 +19852,7 @@ ${cu.tail.trimEnd()}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync34(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync35(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -19812,7 +19881,7 @@ ${cu.tail.trimEnd()}
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       let resolvedRemotes;
-      if (existsSync34(resolvedFile)) {
+      if (existsSync35(resolvedFile)) {
         try {
           resolvedRemotes = JSON.parse(readFileSync31(resolvedFile, "utf8"));
         } catch {
@@ -19821,7 +19890,7 @@ ${cu.tail.trimEnd()}
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text = configText;
       const base = dirname20(cfg.configFile);
-      const isCheckout = (d) => existsSync34(`${d}/.git`);
+      const isCheckout = (d) => existsSync35(`${d}/.git`);
       try {
         if (sub === "list") {
           if (flag("json")) {
@@ -19831,7 +19900,7 @@ ${cu.tail.trimEnd()}
               base,
               resolved: resolvedRemotes,
               originOf,
-              exists: (d) => existsSync34(d),
+              exists: (d) => existsSync35(d),
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
@@ -19852,7 +19921,7 @@ ${cu.tail.trimEnd()}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync34(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync35(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
             process.stdout.write(`${r.name}	${r.dir}	${note}
 `);
           }
@@ -19864,9 +19933,9 @@ ${cu.tail.trimEnd()}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir"), isCheckout });
-          if (existsSync34(plan2.target) && (existsSync34(`${plan2.target}/.git`) || readdirSync15(plan2.target).length > 0)) {
+          if (existsSync35(plan2.target) && (existsSync35(`${plan2.target}/.git`) || readdirSync16(plan2.target).length > 0)) {
             throw new ReposError(
-              existsSync34(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
+              existsSync35(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
             );
           }
           if (dryRun) {
@@ -19891,7 +19960,7 @@ ${cu.tail.trimEnd()}
           break;
         }
         const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir10()));
-        const top = existsSync34(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync35(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
         if (!top) throw new ReposError(`${target} is not a git checkout`);
         const origin = originOf(top);
         const plan = planRepoAdd({
@@ -19943,7 +20012,7 @@ ${cu.tail.trimEnd()}
           const created = await rowTracker.createRepoRow(rowPayload);
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
-          if (existsSync34(resolvedFile)) {
+          if (existsSync35(resolvedFile)) {
             const raw = JSON.parse(readFileSync31(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
@@ -20360,7 +20429,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
         let previous;
-        const hadPreviousFile = existsSync34(resolvedPath);
+        const hadPreviousFile = existsSync35(resolvedPath);
         if (hadPreviousFile) {
           try {
             previous = JSON.parse(readFileSync31(resolvedPath, "utf8"));
@@ -21402,7 +21471,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
         if (row) {
           await tracker.deleteRepoRow(row.id);
-          if (existsSync34(resolvedFile)) {
+          if (existsSync35(resolvedFile)) {
             const raw = JSON.parse(readFileSync31(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
@@ -21410,21 +21479,21 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
 `);
           }
         }
-        if (existsSync34(join37(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync15(dir, { recursive: true, force: true });
+        if (existsSync35(join38(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync15(dir, { recursive: true, force: true });
         say("removed", { dir, closed }, `removed the sample repo${closed.length ? `, closed ${closed.join(", ")}` : ""}`);
         break;
       }
       const projectId = route.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
-      const fresh = !existsSync34(join37(dir, ".git"));
-      if (existsSync34(dir) && fresh && readdirSync15(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      const fresh = !existsSync35(join38(dir, ".git"));
+      if (existsSync35(dir) && fresh && readdirSync16(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
       if (dryRun) {
         say("dry-run", { dir, newCheckout: fresh, repoRow: row?.id ?? null }, `would ${fresh ? "create" : "reuse"} ${dir}${row ? "" : ", create the Repos row"}, and file one ${tracker.contract.statuses.approved} ticket`);
         break;
       }
       if (fresh) {
         mkdirSync22(dir, { recursive: true });
-        writeFileSync23(join37(dir, "README.md"), SAMPLE_README);
-        writeFileSync23(join37(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        writeFileSync23(join38(dir, "README.md"), SAMPLE_README);
+        writeFileSync23(join38(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync7("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -21442,7 +21511,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           spec: { platform: "unix", releaseMode: "integrate", ciProvider: "none" }
         });
         repoId = (await tracker.createRepoRow(payload)).id;
-        if (existsSync34(resolvedFile)) {
+        if (existsSync35(resolvedFile)) {
           const raw = JSON.parse(readFileSync31(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
@@ -21573,6 +21642,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       const todo = await statusTracker.openTickets().then((open) => operatorTodo(open, statusTracker.contract, route.resolved?.operator ?? "")).catch(() => []);
       const projects = projectModeLabels(await statusTracker.projectRowsWithModes().catch(() => []));
       const crewMinVersion = await readCrewFloor(route, cfg.ship) ?? null;
+      const runs = liveRuns(cfg.ship.stateDir);
       if (flag("json")) {
         const nameSync = await reconcileRouteShipName({ route, ship: cfg.ship, configFile: cfg.configFile, readOnly: true });
         const repos = await resolvedRepos(route);
@@ -21590,7 +21660,9 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             label: ROLE_LABEL[r],
             crewId: seatId ?? null,
             name: crewRow?.name ?? null,
-            personaName
+            personaName,
+            // Additive (CREW-2822): how many runs this seat has live right now.
+            running: runs.filter((x) => x.role === r && x.route === routeSlug(route.route)).length
           };
         });
         process.stdout.write(`${JSON.stringify({
@@ -21633,6 +21705,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             roles: ROLE_NAMES.map((r) => ({ name: r, label: ROLE_LABEL[r], paused: state.isRolePaused(r) })),
             seats: seats2
           },
+          // Additive (CREW-2822): every live run on this ship. `version` stays 1.
+          runs: runs.map((x) => describeRun(x, route, seatIds)),
           watermark: state.watermark(),
           route: {
             name: route.route,
@@ -21745,6 +21819,10 @@ watermark:  ${state.watermark()}
 `
         );
       }
+      for (const x of runs) {
+        process.stdout.write(`running:    ${x.role} \u2014 ${x.ticket ?? "(no ticket)"}${x.repo ? ` in ${x.repo}` : ""} (pid ${x.pid}, since ${x.spawnedAt})
+`);
+      }
       if (shipRows.length) {
         process.stdout.write("ships:\n");
         for (const s of shipRows) {
@@ -21773,7 +21851,7 @@ watermark:  ${state.watermark()}
           }
           for (const r of repos) {
             const remote = r.config.branch.remote;
-            if (existsSync34(r.dir)) {
+            if (existsSync35(r.dir)) {
               pushAuth.push({
                 route: c.route,
                 repo: r.name,
@@ -21834,7 +21912,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
 `);
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync34(evFile) ? statSync10(evFile).size : 0;
+        const evSize = existsSync35(evFile) ? statSync10(evFile).size : 0;
         process.stdout.write(
           evSize > cfg.ship.eventsRotateBytes * 4 ? `events log:        WARN ${evFile} is ${Math.round(evSize / 1048576)} MB (> 4x eventsRotateBytes); run \`crew reap\` to rotate it
 ` : "events log:        ok\n"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.81.0",
+  "version": "0.82.0",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",