@tablation/crew 0.80.1 → 0.82.0

package/dist/cli.js

@@ -2055,6 +2055,7 @@ var SHIP_KEYS = /* @__PURE__ */ new Set([
   "baseUrl",
   "apiKey",
   "maxConcurrentAgents",
+  "roleConcurrency",
   "streamRetentionDays",
   "eventsRotateBytes",
   "reposBasePath",
@@ -2364,10 +2365,34 @@ Create the first of those:
   if (declaredPlatform && !isShipPlatform(declaredPlatform)) {
     missing.add(`ship.platform must be one of macos|linux|windows (got "${declaredPlatform}")`);
   }
-  const maxConcurrentAgents = shipRaw.maxConcurrentAgents === void 0 ? 2 : Number(shipRaw.maxConcurrentAgents);
+  const maxConcurrentAgentsSet = shipRaw.maxConcurrentAgents !== void 0;
+  let maxConcurrentAgents = maxConcurrentAgentsSet ? Number(shipRaw.maxConcurrentAgents) : 2;
   if (!Number.isInteger(maxConcurrentAgents) || maxConcurrentAgents < 1) {
     missing.add(`ship.maxConcurrentAgents must be a positive integer (got "${shipRaw.maxConcurrentAgents}")`);
   }
+  const roleConcurrency = {};
+  const roleConcurrencyRaw = shipRaw.roleConcurrency;
+  if (roleConcurrencyRaw !== void 0 && roleConcurrencyRaw !== null) {
+    if (typeof roleConcurrencyRaw !== "object" || Array.isArray(roleConcurrencyRaw)) {
+      missing.add("ship.roleConcurrency must be a map of role to a positive integer");
+    } else {
+      for (const [role, v] of Object.entries(roleConcurrencyRaw)) {
+        if (!ROLE_NAMES.includes(role)) {
+          missing.add(`ship.roleConcurrency.${role} is not a role (expected one of ${ROLE_NAMES.join(", ")})`);
+          continue;
+        }
+        const n = Number(v);
+        if (!Number.isInteger(n) || n < 1) {
+          missing.add(`ship.roleConcurrency.${role} must be a positive integer (got "${String(v)}")`);
+          continue;
+        }
+        roleConcurrency[role] = n;
+      }
+    }
+  }
+  if (!maxConcurrentAgentsSet && Object.keys(roleConcurrency).length > 0) {
+    maxConcurrentAgents = ROLE_NAMES.filter((r) => r !== "pair").reduce((n, r) => n + (roleConcurrency[r] ?? 1), 0);
+  }
   const streamRetentionDays = shipRaw.streamRetentionDays === void 0 ? 7 : Number(shipRaw.streamRetentionDays);
   if (!Number.isInteger(streamRetentionDays) || streamRetentionDays < 1) {
     missing.add(`ship.streamRetentionDays must be a positive integer (got "${shipRaw.streamRetentionDays}")`);
@@ -2431,6 +2456,8 @@ Create the first of those:
       logFile: expand(shipRaw.logFile ?? join9(tmpdir(), "crew.log"), base),
       userAgent: shipRaw.userAgent ?? `Mozilla/5.0 CrewAgent/${crewVersion(crewHome)}`,
       maxConcurrentAgents,
+      maxConcurrentAgentsSet,
+      roleConcurrency,
       streamRetentionDays,
       eventsRotateBytes,
       relayHost: shipRaw.relayHost ? String(shipRaw.relayHost) : void 0,
@@ -4541,6 +4568,10 @@ function formatStaleOwnLock(scope, holder) {
   return `WARN lock ${scope} is held by ${holder}, but that process is gone \u2014 the next release cycle reclaims it
 `;
 }
+function roleCapWarnings(ship) {
+  if (!ship.maxConcurrentAgentsSet) return [];
+  return Object.entries(ship.roleConcurrency).filter(([, n]) => (n ?? 0) > ship.maxConcurrentAgents).map(([role, n]) => `ship.roleConcurrency.${role} is ${n}, above ship.maxConcurrentAgents (${ship.maxConcurrentAgents}); the ship-wide cap wins`);
+}
 
 // src/selftest.ts
 import { spawn as spawn3 } from "child_process";
@@ -5654,22 +5685,36 @@ var State = class _State {
     return { ok: false, heldBy };
   }
   /**
-   * The run lock (ISSUE-381): role-distinct AND capacity-limited, checked
-   * together.
+   * The run lock (ISSUE-381, CREW-2821): role-capped AND capacity-limited,
+   * checked together.
    *
-   * Role queues are disjoint by construction (`sliceFor`), so two sessions
-   * of the SAME role would collide on the same ticket if ever let run at
-   * once — that half is a plain exclusive lock, one per role name, and
-   * never relaxed. `max` is this machine's separate, configurable limit on
-   * how many DIFFERENT roles may run together; a role that clears its own
-   * lock but finds every slot taken must give the slot back its lock too,
-   * or a locked-but-not-running role would wedge itself out for the rest
-   * of the machine's uptime.
+   * Two sessions of one role must never take the same ticket. Before
+   * CREW-2821 that was guaranteed by an exclusive per-role lock; now the
+   * guarantee is the per-ticket lock (`acquireTicket`), so the role lock is a
+   * counted one: `roleMax` interchangeable slots, default 1. Slot 1 keeps the
+   * historical name `crew-role-<role>` (crew-macos reads it for the live pid),
+   * further slots are `crew-role-<role>-<n>`. `max` is this machine's separate
+   * limit on how many runs of ANY role may overlap; a role that clears its own
+   * lock but finds every slot taken must give its role lock back, or a
+   * locked-but-not-running role would wedge itself out for the rest of the
+   * machine's uptime.
    */
-  acquireRun(role, max) {
-    const roleLock = this.acquire(`crew-role-${role}`);
-    if (!roleLock.ok) {
-      return { ok: false, reason: `${role} is already running (pid ${roleLock.heldBy})` };
+  acquireRun(role, max, roleMax = 1) {
+    let roleLock;
+    const roleHolders = [];
+    for (let i = 1; i <= roleMax; i++) {
+      const got = this.acquire(i === 1 ? `crew-role-${role}` : `crew-role-${role}-${i}`);
+      if (got.ok) {
+        roleLock = got;
+        break;
+      }
+      roleHolders.push(got.heldBy);
+    }
+    if (!roleLock) {
+      return {
+        ok: false,
+        reason: roleMax === 1 ? `${role} is already running (pid ${roleHolders[0]})` : `${role} is already running ${roleMax} agents (its roleConcurrency cap; pid${roleHolders.length > 1 ? "s" : ""} ${[...new Set(roleHolders)].join(", ")})`
+      };
     }
     const slot = this.acquireN("crew-slot", max);
     if (!slot.ok) {
@@ -5684,6 +5729,27 @@ var State = class _State {
       roleLock.release();
     } };
   }
+  /**
+   * The per-ticket run lock (CREW-2821): held for the life of a run that works
+   * the ticket (`crew-ticket-<record id>`), so a second run of the same role
+   * on this ship walks past it instead of being handed the first run's
+   * ticket. Same stale-pid rule as every lock here.
+   */
+  acquireTicket(recordId) {
+    return this.acquire(`crew-ticket-${recordId}`);
+  }
+  /** Whether a live run on this ship holds `recordId`'s ticket lock. */
+  ticketInFlight(recordId) {
+    const file = this.path(`.${_State.safe(`crew-ticket-${recordId}`)}.lock`);
+    try {
+      const pid = Number.parseInt(readFileSync12(file, "utf8").trim(), 10);
+      if (!Number.isFinite(pid) || pid <= 0) return false;
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   /**
    * How many consecutive cycles the release phase has refused to deploy.
    *
@@ -6413,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, {
@@ -6421,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)
@@ -7063,7 +7129,14 @@ function newBranchName(cfg, t, role) {
 function planRunWorktree(dir, cfg, t, role, opts = {}) {
   const { remote, base } = cfg.branch;
   const hasRemote = remoteConfigured(dir, remote);
-  if (hasRemote) fetchRemote(dir, remote);
+  if (hasRemote) {
+    const unlock = acquireCheckoutLock(dir);
+    try {
+      fetchRemote(dir, remote);
+    } finally {
+      unlock();
+    }
+  }
   const num = t.issue_id.replace(/^\D+/, "");
   const existing = worktreeForNumber(dir, num);
   const located = locateBranchForTicket(dir, cfg, t, role);
@@ -8373,6 +8446,7 @@ var AgentError = class extends Error {
 };
 var AgentSpawnError = class extends AgentError {
 };
+var digestPathFor = (stateDir, routeLabel, role, runId) => join19(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
 function planAgentRun(o) {
   const briefPath = join19(o.route.promptsDir, "personas", `lane-${o.role}.md`);
   if (!existsSync18(briefPath)) {
@@ -8382,7 +8456,8 @@ function planAgentRun(o) {
   const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync18(commonPath);
   const now = o.now ?? (() => Date.now());
   const routeLabel = routeSlug(o.route.route);
-  const digestPath2 = join19(o.stateDir, `digest-${routeLabel}-${o.role}.md`);
+  const ownDigest = o.runId ? digestPathFor(o.stateDir, routeLabel, o.role, o.runId) : void 0;
+  const digestPath2 = ownDigest && existsSync18(ownDigest) ? ownDigest : digestPathFor(o.stateDir, routeLabel, o.role);
   let digest;
   let ageSeconds;
   if (existsSync18(digestPath2)) {
@@ -8413,7 +8488,7 @@ function planAgentRun(o) {
   });
   const promptSha = createHash3("sha256").update(expanded.text).digest("hex");
   const streamsDir = join19(o.stateDir, "streams");
-  const base = `${routeLabel}-${o.role}-${o.cycle}`;
+  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 { toolchain, model } = seat;
   const adapter = adapterFor(toolchain.harness);
@@ -8486,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
@@ -8900,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,
@@ -9471,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";
@@ -10955,8 +11034,15 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route, role) => join23(stateDir, `digest-${route}-${role}.md`);
-function writeDigest(o, d, role, stateDir) {
+var digestPath = (stateDir, route, role, runId) => join23(stateDir, `digest-${route}-${role}${runId ? `-${runId}` : ""}.md`);
+function otherRunsRemoved(tickets, own) {
+  if (!own) return tickets;
+  return tickets.filter((t) => t.id === own.ticket.id || !own.inFlight(t.id));
+}
+function ownRunBanner(own) {
+  return `**Your ticket for this run: ${own.ticket.issue_id}.** Work this one. Any other ticket a live run on this ship is already working has been left out of this digest: it belongs to that run.`;
+}
+function writeDigest(o, d, role, stateDir, runId, own) {
   const me = o.route.resolved?.seats[role];
   if (!me) return false;
   try {
@@ -11002,7 +11088,7 @@ function writeDigest(o, d, role, stateDir) {
         }
         return existingBranchForTicket(dir, repoFor(dir), t, role);
       },
-      tickets: role === "triage" ? triageSlice(d.tickets, o.route.resolved?.seats.triage, d.selectionInput.workModes) : withinWorkMode(sliceFor(d.tickets, role), d.selectionInput.workModes),
+      tickets: role === "triage" ? triageSlice(d.tickets, o.route.resolved?.seats.triage, d.selectionInput.workModes) : withinWorkMode(sliceFor(otherRunsRemoved(d.tickets, own), role), d.selectionInput.workModes),
       workModes: d.selectionInput.workModes,
       comments: d.comments,
       commentColumns: d.selectionInput.contract?.comments,
@@ -11021,8 +11107,11 @@ function writeDigest(o, d, role, stateDir) {
       blocked: d.blocked,
       blockerInfo: d.info
     };
-    const text = role === "qa" ? qaDigest(input) : buildingDigest(input);
-    const path = digestPath(stateDir, routeSlug(o.route.route), role);
+    const body = role === "qa" ? qaDigest(input) : buildingDigest(input);
+    const text = own ? `${ownRunBanner(own)}
+
+${body}` : body;
+    const path = digestPath(stateDir, routeSlug(o.route.route), role, runId);
     writeFileSync14(path, text);
     o.emit.emit(`queue digest written for ${role} (${Buffer.byteLength(text)} bytes)`, {
       data: { role, bytes: Buffer.byteLength(text) }
@@ -11063,7 +11152,7 @@ async function stampResumption(tracker, t, affinity) {
   }
   return { outcome: "unknown" };
 }
-async function resolveTopCandidate(tracker, candidates, seat, approvedStatus, buildingStatus, isServable, affinity) {
+async function resolveTopCandidate(tracker, candidates, seat, approvedStatus, buildingStatus, isServable, affinity, ticketLock) {
   const contended = [];
   const unservable = [];
   const held = [];
@@ -11076,41 +11165,58 @@ async function resolveTopCandidate(tracker, candidates, seat, approvedStatus, bu
       unservable.push(t.issue_id);
       continue;
     }
-    if (t.status !== approvedStatus) {
-      if (affinity?.isLiveHoldElsewhere?.(t)) {
-        return { ticket: t, claimed: false, contended, unservable, held, reaccepted: false, tookOverFrom: null };
-      }
-      if (affinity && t[affinity.column] !== affinity.shipId) {
-        const stamp = await stampResumption(tracker, t, affinity);
-        if (stamp.outcome === "stamped") {
-          return { ticket: stamp.ticket, claimed: false, contended, unservable, held, reaccepted: false, tookOverFrom: displacedHolder(t, affinity) };
-        }
-        (stamp.outcome === "held" ? held : contended).push(t.issue_id);
+    let releaseTicket;
+    if (ticketLock) {
+      const got = ticketLock(t);
+      if (!got) {
+        contended.push(t.issue_id);
         continue;
       }
+      releaseTicket = got;
+    }
+    const result = await resolveOne(tracker, t, seat, approvedStatus, buildingStatus, affinity, contended, unservable, held);
+    if (result === "walk") {
+      releaseTicket?.();
+      continue;
+    }
+    return releaseTicket ? { ...result, releaseTicket } : result;
+  }
+  return { ticket: null, claimed: false, contended, unservable, held, reaccepted: false, tookOverFrom: null };
+}
+async function resolveOne(tracker, t, seat, approvedStatus, buildingStatus, affinity, contended, unservable, held) {
+  if (t.status !== approvedStatus) {
+    if (affinity?.isLiveHoldElsewhere?.(t)) {
       return { ticket: t, claimed: false, contended, unservable, held, reaccepted: false, tookOverFrom: null };
     }
-    try {
-      const claimed = await tracker.updateTicket(
-        t.id,
-        {
-          status: buildingStatus,
-          assignee_id: seat,
-          ...affinity ? { [affinity.column]: affinity.shipId } : {}
-        },
-        t.updated_at
-      );
-      const reaccepted = !!affinity && t[affinity.column] === affinity.shipId;
-      return { ticket: { ...t, ...claimed }, claimed: true, contended, unservable, held, reaccepted, tookOverFrom: displacedHolder(t, affinity) };
-    } catch (e) {
-      if (e instanceof StaleWriteError6) {
-        contended.push(t.issue_id);
-        continue;
+    if (affinity && t[affinity.column] !== affinity.shipId) {
+      const stamp = await stampResumption(tracker, t, affinity);
+      if (stamp.outcome === "stamped") {
+        return { ticket: stamp.ticket, claimed: false, contended, unservable, held, reaccepted: false, tookOverFrom: displacedHolder(t, affinity) };
       }
-      throw e;
+      (stamp.outcome === "held" ? held : contended).push(t.issue_id);
+      return "walk";
     }
+    return { ticket: t, claimed: false, contended, unservable, held, reaccepted: false, tookOverFrom: null };
+  }
+  try {
+    const claimed = await tracker.updateTicket(
+      t.id,
+      {
+        status: buildingStatus,
+        assignee_id: seat,
+        ...affinity ? { [affinity.column]: affinity.shipId } : {}
+      },
+      t.updated_at
+    );
+    const reaccepted = !!affinity && t[affinity.column] === affinity.shipId;
+    return { ticket: { ...t, ...claimed }, claimed: true, contended, unservable, held, reaccepted, tookOverFrom: displacedHolder(t, affinity) };
+  } catch (e) {
+    if (e instanceof StaleWriteError6) {
+      contended.push(t.issue_id);
+      return "walk";
+    }
+    throw e;
   }
-  return { ticket: null, claimed: false, contended, unservable, held, reaccepted: false, tookOverFrom: null };
 }
 
 // src/conflict.ts
@@ -13277,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) => {
@@ -13486,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`;
@@ -13587,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 };
@@ -13830,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) {
@@ -13853,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;
       }
     }
@@ -13865,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)();
@@ -13944,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;
   }
@@ -13971,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);
@@ -13995,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") {
@@ -14641,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;
@@ -14675,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;
@@ -14784,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) {
@@ -14825,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 };
@@ -14882,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 {
 };
@@ -15160,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 };
 }
@@ -15559,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";
@@ -15582,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() {
@@ -15675,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;
@@ -15735,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 [];
   }
@@ -15743,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;
@@ -15778,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`,
@@ -15786,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;
@@ -15797,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;
     }
@@ -15846,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;
   }
@@ -15951,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 {
@@ -15984,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 {
@@ -15996,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", [
@@ -16033,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() {
@@ -16253,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";
@@ -16322,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)}
 `);
 }
@@ -16433,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
@@ -16555,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";
@@ -16645,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)}
 `);
 }
@@ -16679,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;
@@ -16768,95 +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";
-
-// 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) : 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 (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
+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";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
 var defaultSleep = (ms2) => new Promise((resolve6) => setTimeout(resolve6, ms2));
@@ -16925,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;
 }
@@ -16935,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 });
@@ -16966,6 +17144,7 @@ function configChangedAfter(files, startedAt) {
   }
   return null;
 }
+var TICKET_ROLES = /* @__PURE__ */ new Set(["dev", "design", "qa"]);
 var SPAWN_PARK_AFTER = 3;
 var SpawnBreaker = class {
   states = /* @__PURE__ */ new Map();
@@ -17063,46 +17242,69 @@ async function runOnePassUnguarded(o) {
   );
   const started = [];
   const skipped = [];
-  for (const role of order) {
-    if (!breaker.allows(role)) {
-      skipped.push({ role, reason: "agent recently failed to start \u2014 waiting before retry" });
-      continue;
-    }
-    const lock = o.state.acquireRun(role, o.maxConcurrentAgents);
-    if (!lock.ok) {
-      skipped.push({ role, reason: lock.reason });
-      continue;
-    }
-    started.push(role);
-    const run2 = spawn7(role, decision, ctx).then(() => {
-      breaker.recordSuccess(role);
-      clearShipAttention(o.state, `role_parked:${role}`);
-    }).catch(async (e) => {
-      const message = e.message;
-      if (!(e instanceof AgentSpawnError)) {
-        emit.warn(`${role} agent run failed: ${message}`, { step: "agent", role });
-        return;
+  const roleCap = (role) => TICKET_ROLES.has(role) ? o.roleConcurrency?.[role] ?? 1 : 1;
+  const live = new Map(order.map((r) => [r, 0]));
+  while (live.size) {
+    for (const role of order) {
+      const count = live.get(role);
+      if (count === void 0) continue;
+      if (!breaker.allows(role)) {
+        if (count === 0) skipped.push({ role, reason: "agent recently failed to start \u2014 waiting before retry" });
+        live.delete(role);
+        continue;
       }
-      const report = breaker.recordFailure(role, message);
-      if (report.firstOfMessage || report.parked) {
-        emit.warn(`${role} agent could not start: ${message}`, { step: "agent", role });
+      const lock = o.state.acquireRun(role, o.maxConcurrentAgents, roleCap(role));
+      if (!lock.ok) {
+        if (count === 0) skipped.push({ role, reason: lock.reason });
+        live.delete(role);
+        continue;
       }
-      if (report.parked) {
-        emit.error(
-          `${role} parked for ${Math.round(report.retryInMs / 1e3)}s after ${report.failures} consecutive failed starts \u2014 check that ship.agent.bin is installed and on PATH`
-        );
-        await raiseShipAttention({ state: o.state, emit, route: o.route, ship: o.ship }, {
-          kind: "role_parked",
-          key: `role_parked:${role}`,
-          message: `${role} agent is parked after ${report.failures} failed starts: ${message}`,
-          since: (/* @__PURE__ */ new Date()).toISOString()
-        });
+      started.push(role);
+      let ready = () => {
+      };
+      const settled = new Promise((resolve6) => {
+        ready = resolve6;
+      });
+      const run2 = spawn7(role, decision, ctx, { ready }).then(() => {
+        breaker.recordSuccess(role);
+        clearShipAttention(o.state, `role_parked:${role}`);
+      }).catch(async (e) => {
+        const message = e.message;
+        if (!(e instanceof AgentSpawnError)) {
+          emit.warn(`${role} agent run failed: ${message}`, { step: "agent", role });
+          return;
+        }
+        const report = breaker.recordFailure(role, message);
+        if (report.firstOfMessage || report.parked) {
+          emit.warn(`${role} agent could not start: ${message}`, { step: "agent", role });
+        }
+        if (report.parked) {
+          emit.error(
+            `${role} parked for ${Math.round(report.retryInMs / 1e3)}s after ${report.failures} consecutive failed starts \u2014 check that ship.agent.bin is installed and on PATH`
+          );
+          await raiseShipAttention({ state: o.state, emit, route: o.route, ship: o.ship }, {
+            kind: "role_parked",
+            key: `role_parked:${role}`,
+            message: `${role} agent is parked after ${report.failures} failed starts: ${message}`,
+            since: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      }).finally(() => {
+        lock.release();
+        ready(false);
+      });
+      if (o.inFlight) {
+        const set = o.inFlight;
+        set.add(run2);
+        void run2.finally(() => set.delete(run2));
+      }
+      if (roleCap(role) <= 1) {
+        live.delete(role);
+        continue;
       }
-    }).finally(() => lock.release());
-    if (o.inFlight) {
-      const set = o.inFlight;
-      set.add(run2);
-      void run2.finally(() => set.delete(run2));
+      const tookTicket = await settled;
+      if (tookTicket && count + 1 < roleCap(role)) live.set(role, count + 1);
+      else live.delete(role);
     }
   }
   await publishShipAttention(o);
@@ -17151,6 +17353,7 @@ async function reconcileForRoute(ctx, o) {
     emit,
     state: o.state,
     maxConcurrentAgents: o.maxConcurrentAgents,
+    roleConcurrency: o.roleConcurrency,
     inFlight: o.inFlight,
     agentLogKey: async (role) => (await resolveSeatKey(route, role, ctx.getSessionStore)).apiKey,
     afterRun: async (sc, result) => {
@@ -17179,20 +17382,32 @@ 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
         });
       }
     }
   });
 }
-async function runRoleAgent(role, decision, ctx) {
+async function runRoleAgent(role, decision, ctx, hooks) {
+  const held = {};
+  try {
+    await runRoleAgentLocked(role, decision, ctx, hooks, held);
+  } finally {
+    held.release?.();
+    hooks?.ready(false);
+  }
+}
+async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
   const { route, ship, emit } = ctx;
+  const runId = randomBytes2(3).toString("hex");
   const identity = await resolveSeatKey(route, role, ctx.getSessionStore);
   if (identity.kind === "ship" && SEAT_KEY_ROLES.includes(role)) {
     emit.warn(`${role} writes as the ship, not its own agent: ${identity.reason}`, { step: "agent", role });
@@ -17215,8 +17430,13 @@ async function runRoleAgent(role, decision, ctx) {
         claimStatuses(role, contract).approved,
         claimStatuses(role, contract).building,
         (t) => dirForRepo(route, t.repo_id) !== null,
-        withHoldCheck(await tracker.claimAffinity(), decision.selectionInput)
+        withHoldCheck(await tracker.claimAffinity(), decision.selectionInput),
+        (t) => {
+          const got = ctx.state.acquireTicket(t.id);
+          return got.ok ? got.release : null;
+        }
       );
+      held.release = result.releaseTicket;
       if (result.contended.length) {
         emit.emit(`claim contended for ${result.contended.join(", ")} \u2014 moved to the next candidate`, {
           step: "select",
@@ -17253,6 +17473,11 @@ async function runRoleAgent(role, decision, ctx) {
         if (idx >= 0) decision.tickets[idx] = result.ticket;
         writeDigest({ route, ship, state: ctx.state, emit }, decision, role, ship.stateDir);
       }
+      writeDigest({ route, ship, state: ctx.state, emit }, decision, role, ship.stateDir, runId, {
+        ticket: result.ticket,
+        inFlight: (id) => ctx.state.ticketInFlight(id)
+      });
+      hooks?.ready(true);
       ticketHint = result.ticket.issue_id;
       workingId = result.ticket.id;
       const target = repoTargetFor(route, result.ticket.repo_id);
@@ -17278,6 +17503,7 @@ async function runRoleAgent(role, decision, ctx) {
     environment: await buildEnvironment(route, ship, ticketHint),
     apiKey: identity.apiKey,
     cycle: emit.cycle,
+    runId,
     ticket: ticketHint,
     repo: ticketRepo,
     ticketRecordId: workingId,
@@ -17318,18 +17544,16 @@ async function runRoleAgent(role, decision, ctx) {
     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) {
@@ -17771,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 } : {});
@@ -18009,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)" : ""}
 `
@@ -18037,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}`));
     }
@@ -18055,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 });
@@ -18718,7 +18942,7 @@ ${cu.tail.trimEnd()}
 `);
           break;
         }
-        const fleetLock = state.acquireRun(w.role, cfg.ship.maxConcurrentAgents);
+        const fleetLock = state.acquireRun(w.role, cfg.ship.maxConcurrentAgents, cfg.ship.roleConcurrency[w.role] ?? 1);
         if (!fleetLock.ok) {
           wemit.emit(`${w.role} skipped this cycle \u2014 ${fleetLock.reason}`);
           if (!skipInlineRelease) await releaseFleet();
@@ -18741,8 +18965,20 @@ ${cu.tail.trimEnd()}
               claimStatuses(w.role, contract).approved,
               claimStatuses(w.role, contract).building,
               (t) => dirForRepo(w.route, t.repo_id) !== null,
-              withHoldCheck(await fleetTracker.claimAffinity(), w.decision.selectionInput)
+              withHoldCheck(await fleetTracker.claimAffinity(), w.decision.selectionInput),
+              (t) => {
+                const got = state.acquireTicket(t.id);
+                return got.ok ? got.release : null;
+              }
             );
+            if (result.releaseTicket) {
+              const roleLock = lock;
+              const releaseTicket = result.releaseTicket;
+              lock = { release: () => {
+                roleLock?.release();
+                releaseTicket();
+              } };
+            }
             if (result.contended.length) {
               wemit.emit(`claim contended for ${result.contended.join(", ")} \u2014 moved to the next candidate`, {
                 step: "select",
@@ -18832,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;
@@ -18914,7 +19148,7 @@ ${cu.tail.trimEnd()}
       const tracker2 = new Tracker(route, cfg.ship);
       while (current) {
         if (!dryRun) {
-          const got = state.acquireRun(current, cfg.ship.maxConcurrentAgents);
+          const got = state.acquireRun(current, cfg.ship.maxConcurrentAgents, cfg.ship.roleConcurrency[current] ?? 1);
           if (!got.ok) {
             emit.emit(`${current} skipped this cycle \u2014 ${got.reason}`);
             if (explicitRole) {
@@ -18942,8 +19176,20 @@ ${cu.tail.trimEnd()}
               claimStatuses(current, contract).approved,
               claimStatuses(current, contract).building,
               (t) => dirForRepo(route, t.repo_id) !== null,
-              withHoldCheck(await tracker2.claimAffinity(), decision.selectionInput)
+              withHoldCheck(await tracker2.claimAffinity(), decision.selectionInput),
+              (t) => {
+                const got = state.acquireTicket(t.id);
+                return got.ok ? got.release : null;
+              }
             );
+            if (result.releaseTicket) {
+              const roleLock = lock;
+              const releaseTicket = result.releaseTicket;
+              lock = { release: () => {
+                roleLock?.release();
+                releaseTicket();
+              } };
+            }
             if (result.contended.length) {
               emit.emit(`claim contended for ${result.contended.join(", ")} \u2014 moved to the next candidate`, {
                 step: "select",
@@ -19061,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;
@@ -19156,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);
@@ -19167,6 +19411,7 @@ ${cu.tail.trimEnd()}
           ship: cfg.ship,
           state,
           maxConcurrentAgents: cfg.ship.maxConcurrentAgents,
+          roleConcurrency: cfg.ship.roleConcurrency,
           spawnBreaker,
           configFile: cfg.configFile,
           newEmitter: () => new Emitter({
@@ -19384,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)}
@@ -19488,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 [];
             }
@@ -19607,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;
@@ -19636,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 {
@@ -19645,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")) {
@@ -19655,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 {
@@ -19676,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}
 `);
           }
@@ -19688,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) {
@@ -19715,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({
@@ -19767,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) };
@@ -20184,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"));
@@ -21226,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];
@@ -21234,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()}`);
@@ -21266,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 };
@@ -21397,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);
@@ -21414,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({
@@ -21457,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,
@@ -21569,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) {
@@ -21597,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,
@@ -21642,6 +21896,7 @@ watermark:  ${state.watermark()}
             } else if (p.state === "ok") passed++;
           }
         }
+        for (const message of roleCapWarnings(cfg.ship)) problems.push({ severity: "note", kind: "role_cap_above_ship_cap", message });
         problems.push(...attentionProblems(openShipAttention(state), problems));
         if (problems.some((p) => p.severity === "blocker")) process.exitCode = 1;
         process.stdout.write(`${JSON.stringify({ offline: flag("offline"), pushAuth, tools: toolRows, problems, passed }, null, 2)}
@@ -21653,9 +21908,11 @@ watermark:  ${state.watermark()}
 routes:            ${cfg.routes.map((c) => c.route).join(", ")}
 `
       );
+      for (const w of roleCapWarnings(cfg.ship)) process.stdout.write(`role concurrency: WARN ${w}
+`);
       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"