@tablation/crew 0.49.5 → 0.50.0

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve4, dirname as dirname12, join as join24, basename as basename9 } from "path";
+import { resolve as resolve4, dirname as dirname12, join as join25, basename as basename9 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir8 } from "os";
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync6 } from "child_process";
 
 // src/argv.ts
 var VALUE_FLAGS = /* @__PURE__ */ new Set([
@@ -3586,6 +3586,8 @@ function planLaunchd(ship, crewHome, job) {
   const scheduleKeys = persistent ? `  <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
+  <true/>
+  <key>AbandonProcessGroup</key>
   <true/>` : `  <key>StartInterval</key>
   <integer>${INTERVAL_SECONDS}</integer>
   <key>RunAtLoad</key>
@@ -3650,6 +3652,9 @@ StandardOutput=append:${schedulerLog}
 StandardError=append:${schedulerLog}
 Restart=on-failure
 RestartSec=5
+# CREW-1775: a restart stops only the daemon; agent runs it started live in
+# their own process groups and the next daemon reattaches to them.
+KillMode=process
 
 [Install]
 WantedBy=default.target
@@ -3727,6 +3732,13 @@ function planCron(ship, crewHome, job) {
     schedulerLog
   };
 }
+function unitAbandonsAgents(plan, read) {
+  const path = plan.unitPaths[0];
+  if (!path || plan.mechanism !== "launchd" && plan.mechanism !== "systemd") return null;
+  const text = read(path);
+  if (text === null) return null;
+  return plan.mechanism === "launchd" ? /<key>AbandonProcessGroup<\/key>\s*<true\/>/.test(text) : /^KillMode=process\s*$/m.test(text);
+}
 function planInstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
   if (hostShip === "macos") return planLaunchd(ship, crewHome, job);
   if (hostShip === "linux" && hasSystemd) return planSystemd(ship, crewHome, job);
@@ -4931,6 +4943,8 @@ var Tracker = class {
    * writes pass its seat's agent key so the event log and rule context see an
    * agent, not the ship's human principal.
    */
+  /** Told once per failed best-effort read (`events`); poll.ts points it at the pass's emitter. */
+  onReadFailure;
   constructor(route, ship, opts = {}) {
     this.route = route;
     if (!route.resolved) {
@@ -5372,10 +5386,16 @@ var Tracker = class {
    */
   async events(type, limit = 500) {
     const filters = encodeURIComponent(JSON.stringify([{ columnName: "event_type", operator: "EQ", value: type }]));
-    const res = await this.eventsFetch("GET", `/events?limit=${limit}&filters=${filters}`);
-    if (res.status === 404) return [];
-    if (!res.ok) throw new Error(`reading ${type} events failed: HTTP ${res.status}`);
-    const rows = await res.json();
+    let rows;
+    try {
+      const res = await this.eventsFetch("GET", `/events?limit=${limit}&filters=${filters}`);
+      if (res.status === 404) return [];
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      rows = await res.json();
+    } catch (err) {
+      this.onReadFailure?.(`reading ${type} events failed: ${err instanceof Error ? err.message : String(err)}`);
+      return [];
+    }
     return rows.filter((e) => e.event_type === type).sort((a, b) => Date.parse(b.occurred_at ?? b.created_at ?? "") - Date.parse(a.occurred_at ?? a.created_at ?? ""));
   }
   /** The newest event of `type` on a ticket, or undefined — e.g. the `pushed` tip QA verifies against. */
@@ -6112,7 +6132,7 @@ function operatorTodo(tickets, contract, operatorId) {
 }
 
 // src/digest.ts
-var DIRECTION_EVENT_TYPES = ["conflict_handed_back", "requeued", "bounced", "conflict_escalated"];
+var DIRECTION_EVENT_TYPES = ["conflict_handed_back", "requeued", "bounced", "conflict_escalated", "interrupted"];
 function displayKey2(t) {
   return t.issue_tag ?? t.issue_id ?? "?";
 }
@@ -6241,7 +6261,7 @@ ${sorted(held).map((t) => `| ${displayKey2(t)} | ${stopOf(t)} |`).join("\n")}
     "## Current queue \u2014 built for you by the poll\n",
     "\nAlready filtered to your lane, and already ordered by the Step 2 rule.\nTicket bodies are deliberately omitted: fetch the full record of only the\nticket you actually pick up. **Do not re-fetch the whole tracker.** This\ndigest comes from the same API call the poll just made, moments ago.\n",
     '\n"new since last poll" counts comments from someone other than you since\nthe poll watermark \u2014 the same signal that woke this run.\n',
-    '\n"runner direction" is the newest instruction the crew itself posted to the\nevent log (not Comments) that no push has answered yet: `conflict_handed_back`\n(merge the base into the branch and resolve), `requeued`, `bounced`,\n`conflict_escalated`. It is direction, same as a comment from a hold: act on it.\n',
+    '\n"runner direction" is the newest instruction the crew itself posted to the\nevent log (not Comments) that no push has answered yet: `conflict_handed_back`\n(merge the base into the branch and resolve), `requeued`, `bounced`,\n`conflict_escalated`, `interrupted` (an earlier run on this seat was cut short; its\nuncommitted worktree is yours, resume it). It is direction, same as a comment from a hold: act on it.\n',
     "\n**`repo` is the checkout a ticket's work happens in** \u2014 an area spans\nseveral repositories, so cut the worktree beside THAT directory, not beside\nwhichever one you started in. A ticket marked **NO CHECKOUT** is not yours:\nthis ship has no clone of its repository, and another ship may serve it.\n\n**Use the `branch` and `worktree` columns verbatim.** They are that\nrepository's own naming convention, rendered for THIS ticket \u2014 cut the\nworktree at `<repo>/../<worktree>`, on branch `<branch>`. Do not derive\neither yourself, and prefer these over the Environment section's own worked\nexample if the two ever disagree \u2014 that example is illustrative only,\nrendered before any ticket is picked.\n",
     ...i.workModes && [...i.workModes.modes.values()].some((m) => m !== "automatic") ? ["\n**Manual / hybrid projects.** Some projects on this board are not fully automatic. In a `manual` project no lane touches any ticket, and a ticket with no project is treated the same way, so none appear below. In a `hybrid` project a ticket appears below only when it is assigned to an agent. An `accepted` ticket that is absent for either reason is not yours to claim \u2014 do not go looking for it.\n"] : [],
     "\n### Step 1 \u2014 open tickets that may be yours to act on\n",
@@ -6455,14 +6475,23 @@ async function runStalledSweep(o, stalled) {
 async function decideCycle(o) {
   const { route, ship, state, emit } = o;
   const tracker = new Tracker(route, ship);
+  tracker.onReadFailure = (m) => emit.warn(m);
   emit.enter("poll");
+  const optional = async (what, read, fallback) => {
+    try {
+      return await read;
+    } catch (err) {
+      emit.warn(`reading ${what} failed: ${err instanceof Error ? err.message : String(err)}`);
+      return fallback;
+    }
+  };
   const [tickets, comments, crewRows, epicRows, ships, projectModes, stalledEvents] = await Promise.all([
     tracker.openTickets(),
     tracker.comments(200),
     tracker.crewRows(),
-    tracker.epicRows(),
-    tracker.shipRows(),
-    tracker.projectWorkModes(),
+    optional("epics", tracker.epicRows(), []),
+    optional("ships", tracker.shipRows(), []),
+    optional("project work modes", tracker.projectWorkModes(), /* @__PURE__ */ new Map()),
     tracker.events("stalled")
   ]);
   const directionEvents = (await Promise.all([...DIRECTION_EVENT_TYPES, "pushed"].map((t) => tracker.events(t)))).flat();
@@ -7096,8 +7125,9 @@ ${g.tail}
 var alreadyReported = (ticket, g, events) => events.some((e) => e.record_id === ticket.id && e.event_type === "gate_red" && (e.message ?? "").includes(`${GATE_RED_MARKER} ${g.sha.slice(0, 8)}`));
 
 // src/agent.ts
-import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync12, existsSync as existsSync12, statSync as statSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync8, createWriteStream } from "fs";
+import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
+import { readFileSync as readFileSync12, existsSync as existsSync12, statSync as statSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync8, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
+import { StringDecoder } from "string_decoder";
 import { finished } from "stream/promises";
 import { join as join14, dirname as dirname6 } from "path";
 import { createHash as createHash2 } from "crypto";
@@ -8274,6 +8304,7 @@ function planAgentRun(o) {
     streamPath: join14(streamsDir, `${base}.jsonl`),
     eventsPath: join14(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
+    ticketRecordId: o.ticketRecordId ?? null,
     agentLog,
     promptVersion: o.route.resolved?.agentPersonas?.[o.role]?.historyId,
     promptSha
@@ -8297,6 +8328,43 @@ function describePlan(p) {
     `stream:  ${p.streamPath}`
   ].join("\n");
 }
+var pidPathFor = (streamPath) => `${streamPath}.pid`;
+function readRunSidecar(streamPath) {
+  try {
+    const sc = JSON.parse(readFileSync12(pidPathFor(streamPath), "utf8"));
+    return typeof sc.pid === "number" && typeof sc.spawnedAt === "string" && typeof sc.role === "string" ? sc : null;
+  } catch {
+    return null;
+  }
+}
+function runIsAlive(sc) {
+  try {
+    process.kill(sc.pid, 0);
+  } catch (e) {
+    if (e.code !== "EPERM") return false;
+  }
+  const ps = spawnSync5("ps", ["-o", "lstart=", "-p", String(sc.pid)], { encoding: "utf8" });
+  const started = Date.parse(ps.stdout.trim());
+  if (ps.status !== 0 || Number.isNaN(started)) return ps.status === 0;
+  return Math.abs(started - Date.parse(sc.spawnedAt)) < 15e3;
+}
+function identityOf(plan, adapterHarness) {
+  return {
+    role: plan.role,
+    route: plan.route,
+    ticket: plan.ticket ?? null,
+    model: plan.model,
+    toolchain: plan.toolchain ?? LEGACY_TOOLCHAIN_HARNESS,
+    harness: adapterHarness,
+    provider: plan.provider ?? LEGACY_TOOLCHAIN_PROVIDER,
+    eventsPath: plan.eventsPath,
+    streamPath: plan.streamPath,
+    agentLog: plan.agentLog ? withoutKey(plan.agentLog) : void 0,
+    promptVersion: plan.promptVersion,
+    promptSha: plan.promptSha
+  };
+}
+var withoutKey = ({ apiKey: _apiKey, ...rest }) => rest;
 function openSink(path) {
   try {
     mkdirSync6(dirname6(path), { recursive: true });
@@ -8310,172 +8378,300 @@ function endSink(sink) {
   sink.end();
   return finished(sink).catch(() => void 0);
 }
+var FileTail = class {
+  offset = 0;
+  decoder = new StringDecoder("utf8");
+  path;
+  constructor(path) {
+    this.path = path;
+  }
+  poll() {
+    let fd;
+    try {
+      fd = openSync3(this.path, "r");
+    } catch {
+      return "";
+    }
+    try {
+      let text = "";
+      const chunk = Buffer.alloc(64 * 1024);
+      for (; ; ) {
+        const n = readSync(fd, chunk, 0, chunk.length, this.offset);
+        if (n <= 0) break;
+        this.offset += n;
+        text += this.decoder.write(chunk.subarray(0, n));
+      }
+      return text;
+    } finally {
+      closeSync3(fd);
+    }
+  }
+};
+var TAIL_POLL_MS = 200;
+var RunObserver = class {
+  cycles = [];
+  attribution = new TicketAttributionTracker();
+  result;
+  /** Set once the stream carries the harness's final result (turn count or cost). */
+  sawResult = false;
+  muted = false;
+  buf = "";
+  mapper;
+  id;
+  adapter;
+  eventsSink;
+  emitCycle;
+  constructor(id, adapter, eventsSink, emitCycle) {
+    this.id = id;
+    this.adapter = adapter;
+    this.eventsSink = eventsSink;
+    this.emitCycle = emitCycle;
+    this.mapper = adapter.createStreamMapper?.() ?? { map: (p) => adapter.mapStreamLine(p), flush: () => [] };
+  }
+  feed(text) {
+    this.buf += text;
+    const lines = this.buf.split("\n");
+    this.buf = lines.pop() ?? "";
+    for (const line of lines) this.handleLine(line);
+  }
+  end() {
+    if (this.buf) this.handleLine(this.buf);
+    this.buf = "";
+    try {
+      this.consume(void 0, this.mapper.flush());
+    } catch {
+    }
+  }
+  handleLine(line) {
+    if (!line) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return;
+    }
+    try {
+      const got = this.adapter.extractResult(parsed);
+      if (got) {
+        this.result = { ...this.result, ...Object.fromEntries(Object.entries(got).filter(([, v]) => v !== void 0)) };
+        if (got.numTurns !== void 0 || got.costUsd !== void 0) this.sawResult = true;
+      }
+      this.consume(parsed, this.mapper.map(parsed));
+    } catch {
+    }
+  }
+  // Turns mapped events (and, when there is a source line, its token usage)
+  // into sink writes and buffered cycles. `parsed` is undefined for events
+  // the mapper flushes at end of stream, which have no line of their own.
+  consume(parsed, events) {
+    const plan = this.id;
+    let turnText = "";
+    for (const ev of events) {
+      const e = {
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        cycle: this.emitCycle,
+        route: plan.route,
+        step: "agent",
+        level: "info",
+        message: ev.kind === "tool" ? `${ev.tool ?? "tool"}${ev.target ? ` ${ev.target}` : ""}` : ev.kind,
+        role: plan.role,
+        ...plan.ticket ? { ticket: plan.ticket } : {},
+        data: { kind: ev.kind, ...ev.text ? { text: ev.text } : {}, ...ev.tool ? { tool: ev.tool } : {}, ...ev.target ? { target: ev.target } : {} }
+      };
+      if (!this.muted) this.eventsSink?.write(`${JSON.stringify(e)}
+`);
+      if ((ev.kind === "thought" || ev.kind === "text") && ev.text) {
+        turnText += `${ev.text}
+`;
+        const cycleIndex = this.cycles.length;
+        this.cycles.push({
+          cycleIndex,
+          occurredAt: e.at,
+          thinking: ev.text,
+          // A conversational `text` turn is tagged 'assistant' so it's
+          // distinguishable from a thinking block once both share this
+          // buffer (ISSUE-594) — matching the precedent
+          // `agent-chat.service.ts`'s logChatRun (ISSUE-504) already set
+          // for the same column. A `thought` cycle stays untagged, same
+          // as before this change.
+          ...ev.kind === "text" ? { role: "assistant" } : {}
+        });
+        if (!this.muted) {
+          this.eventsSink?.write(`${JSON.stringify({
+            ...e,
+            message: "cycle",
+            data: { kind: "cycle", cycleIndex, text: ev.text }
+          })}
+`);
+        }
+      }
+    }
+    const turnTokens = parsed === void 0 ? void 0 : this.adapter.extractTurnTokens(parsed);
+    if (turnTokens !== void 0) this.attribution.add(turnText, turnTokens);
+  }
+};
+async function finishRun(id, obs, emit, startedAt, end, agentLogKey) {
+  const attributedTicket = obs.attribution.winner(id.ticket ?? void 0);
+  const identity = { toolchain: id.toolchain, harness: id.harness, provider: id.provider };
+  const { result } = obs;
+  try {
+    writeFileSync8(`${id.streamPath}.meta.json`, JSON.stringify({
+      route: id.route,
+      role: id.role,
+      ticket: id.ticket,
+      attributedTicket: attributedTicket ?? null,
+      startedAt,
+      exitCode: end.code,
+      model: id.model,
+      ...end.interrupted ? { interrupted: end.interrupted } : {},
+      ...identity,
+      sessionId: result?.sessionId ?? null,
+      numTurns: result?.numTurns ?? null,
+      totalCostUsd: result?.costUsd ?? null
+    }));
+  } catch {
+  }
+  const ms2 = Date.now() - Date.parse(startedAt);
+  emit.emit(end.interrupted ? "agent run interrupted" : `agent run finished (exit ${end.code ?? "unknown"})`, {
+    data: {
+      ms: ms2,
+      code: end.code,
+      ...end.interrupted ? { interrupted: end.interrupted } : {},
+      ...identity,
+      ...result?.sessionId ? { sessionId: result.sessionId } : {},
+      ...result?.numTurns !== void 0 ? { numTurns: result.numTurns } : {},
+      ...result?.costUsd !== void 0 ? { totalCostUsd: result.costUsd } : {}
+    }
+  });
+  if (id.agentLog && agentLogKey) {
+    try {
+      await reportAgentRun({ ...id.agentLog, apiKey: agentLogKey }, {
+        ticketReference: attributedTicket,
+        outcome: end.interrupted ? "interrupted" : end.code === 0 || end.code === null && obs.sawResult ? "success" : "error",
+        startedAt,
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        cycles: obs.cycles,
+        model: id.model,
+        tokensIn: result?.inputTokens,
+        tokensOut: result?.outputTokens,
+        cacheReadTokens: result?.cacheReadTokens,
+        cacheWriteTokens: result?.cacheWriteTokens,
+        costUsd: result?.costUsd,
+        harness: identity.harness,
+        provider: identity.provider,
+        promptVersion: id.promptVersion,
+        promptSha: id.promptSha
+      });
+    } catch (e) {
+      emit.warn(`could not report agent log: ${e.message}`, { step: "agent" });
+    }
+  }
+  return { ms: ms2, ticket: attributedTicket };
+}
 function spawnAgent(plan, emit) {
   const adapter = adapterFor(plan.harness ?? LEGACY_TOOLCHAIN_HARNESS);
   const started = Date.now();
   const startedAt = new Date(started).toISOString();
   for (const w of plan.warnings ?? []) emit.warn(w, { step: "agent", role: plan.role });
-  const rawSink = openSink(plan.streamPath);
   const eventsSink = openSink(plan.eventsPath);
+  const id = identityOf(plan, adapter.harness);
   return new Promise((resolve5, reject) => {
+    let streamFd;
+    try {
+      mkdirSync6(dirname6(plan.streamPath), { recursive: true });
+      streamFd = openSync3(plan.streamPath, "a");
+    } catch (e) {
+      void endSink(eventsSink);
+      reject(new AgentSpawnError(`cannot open the stream file ${plan.streamPath}: ${e.message}`));
+      return;
+    }
     const child = spawn2(plan.bin, plan.args, {
       cwd: plan.cwd,
       env: { ...scrubbedEnv(process.env, adapter.harness), ...plan.setEnv },
-      stdio: ["pipe", "pipe", "inherit"]
+      stdio: ["pipe", streamFd, "inherit"],
+      detached: true
     });
-    let buf = "";
-    let result;
-    const cycles = [];
-    const attribution = new TicketAttributionTracker();
-    const mapper = adapter.createStreamMapper?.() ?? { map: (p) => adapter.mapStreamLine(p), flush: () => [] };
-    const handleLine = (line) => {
-      if (!line) return;
-      try {
-        rawSink?.write(`${line}
-`);
-      } catch {
-      }
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        return;
-      }
+    closeSync3(streamFd);
+    if (child.pid !== void 0) {
+      const sidecar = {
+        pid: child.pid,
+        ownerPid: process.pid,
+        spawnedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        role: plan.role,
+        route: plan.route,
+        ticket: plan.ticket ?? null,
+        ticketRecordId: plan.ticketRecordId ?? null,
+        model: plan.model,
+        toolchain: id.toolchain,
+        harness: id.harness,
+        provider: id.provider,
+        eventsPath: plan.eventsPath,
+        agentLog: id.agentLog,
+        promptVersion: plan.promptVersion,
+        promptSha: plan.promptSha
+      };
       try {
-        const got = adapter.extractResult(parsed);
-        if (got) result = { ...result, ...Object.fromEntries(Object.entries(got).filter(([, v]) => v !== void 0)) };
-        consume(parsed, mapper.map(parsed));
+        writeFileSync8(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
       } catch {
       }
-    };
-    const consume = (parsed, events) => {
-      {
-        let turnText = "";
-        for (const ev of events) {
-          const e = {
-            at: (/* @__PURE__ */ new Date()).toISOString(),
-            cycle: emit.cycle,
-            route: plan.route,
-            step: "agent",
-            level: "info",
-            message: ev.kind === "tool" ? `${ev.tool ?? "tool"}${ev.target ? ` ${ev.target}` : ""}` : ev.kind,
-            role: plan.role,
-            ...plan.ticket ? { ticket: plan.ticket } : {},
-            data: { kind: ev.kind, ...ev.text ? { text: ev.text } : {}, ...ev.tool ? { tool: ev.tool } : {}, ...ev.target ? { target: ev.target } : {} }
-          };
-          eventsSink?.write(`${JSON.stringify(e)}
-`);
-          if ((ev.kind === "thought" || ev.kind === "text") && ev.text) {
-            turnText += `${ev.text}
-`;
-            const cycleIndex = cycles.length;
-            cycles.push({
-              cycleIndex,
-              occurredAt: e.at,
-              thinking: ev.text,
-              // A conversational `text` turn is tagged 'assistant' so it's
-              // distinguishable from a thinking block once both share this
-              // buffer (ISSUE-594) — matching the precedent
-              // `agent-chat.service.ts`'s logChatRun (ISSUE-504) already set
-              // for the same column. A `thought` cycle stays untagged, same
-              // as before this change.
-              ...ev.kind === "text" ? { role: "assistant" } : {}
-            });
-            eventsSink?.write(`${JSON.stringify({
-              ...e,
-              message: "cycle",
-              data: { kind: "cycle", cycleIndex, text: ev.text }
-            })}
-`);
-          }
-        }
-        const turnTokens = parsed === void 0 ? void 0 : adapter.extractTurnTokens(parsed);
-        if (turnTokens !== void 0) attribution.add(turnText, turnTokens);
-      }
-    };
-    child.stdout.on("data", (chunk) => {
-      buf += chunk.toString("utf8");
-      const lines = buf.split("\n");
-      buf = lines.pop() ?? "";
-      for (const line of lines) handleLine(line);
-    });
+    }
+    const obs = new RunObserver(id, adapter, eventsSink, emit.cycle);
+    const tail = new FileTail(plan.streamPath);
+    const timer = setInterval(() => obs.feed(tail.poll()), TAIL_POLL_MS);
     let spawnFailed = false;
     child.on("error", (err) => {
       spawnFailed = true;
+      clearInterval(timer);
       reject(new AgentSpawnError(`cannot run ${plan.bin}: ${err.message}`));
     });
     child.on("close", async (code) => {
-      if (buf) handleLine(buf);
-      try {
-        consume(void 0, mapper.flush());
-      } catch {
-      }
-      await Promise.all([endSink(rawSink), endSink(eventsSink)]);
+      clearInterval(timer);
+      obs.feed(tail.poll());
+      obs.end();
+      await endSink(eventsSink);
       if (spawnFailed) return;
-      const attributedTicket = attribution.winner(plan.ticket);
-      const identity = {
-        toolchain: plan.toolchain ?? LEGACY_TOOLCHAIN_HARNESS,
-        harness: adapter.harness,
-        provider: plan.provider ?? LEGACY_TOOLCHAIN_PROVIDER
-      };
-      try {
-        writeFileSync8(`${plan.streamPath}.meta.json`, JSON.stringify({
-          route: plan.route,
-          role: plan.role,
-          ticket: plan.ticket ?? null,
-          attributedTicket: attributedTicket ?? null,
-          startedAt,
-          exitCode: code ?? 1,
-          model: plan.model,
-          ...identity,
-          sessionId: result?.sessionId ?? null,
-          numTurns: result?.numTurns ?? null,
-          totalCostUsd: result?.costUsd ?? null
-        }));
-      } catch {
-      }
-      const ms2 = Date.now() - started;
-      emit.emit(`agent run finished (exit ${code ?? 1})`, {
-        data: {
-          ms: ms2,
-          code: code ?? 1,
-          ...identity,
-          ...result?.sessionId ? { sessionId: result.sessionId } : {},
-          ...result?.numTurns !== void 0 ? { numTurns: result.numTurns } : {},
-          ...result?.costUsd !== void 0 ? { totalCostUsd: result.costUsd } : {}
-        }
-      });
-      if (plan.agentLog) {
-        try {
-          await reportAgentRun(plan.agentLog, {
-            ticketReference: attributedTicket,
-            outcome: (code ?? 1) === 0 ? "success" : "error",
-            startedAt,
-            finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            cycles,
-            model: plan.model,
-            tokensIn: result?.inputTokens,
-            tokensOut: result?.outputTokens,
-            cacheReadTokens: result?.cacheReadTokens,
-            cacheWriteTokens: result?.cacheWriteTokens,
-            costUsd: result?.costUsd,
-            harness: identity.harness,
-            provider: identity.provider,
-            promptVersion: plan.promptVersion,
-            promptSha: plan.promptSha
-          });
-        } catch (e) {
-          emit.warn(`could not report agent log: ${e.message}`, { step: "agent" });
-        }
-      }
+      const { ms: ms2 } = await finishRun(id, obs, emit, startedAt, { code: code ?? 1 }, plan.agentLog?.apiKey);
       resolve5({ code: code ?? 1, ms: ms2 });
     });
-    child.stdin.on("error", (err) => {
+    child.stdin?.on("error", (err) => {
       emit.warn(`agent closed stdin before the prompt was delivered: ${err.message}`, { step: "agent" });
     });
-    child.stdin.end(plan.prompt);
+    child.stdin?.end(plan.prompt);
   });
 }
+async function reattachRun(streamPath, sc, emit, o = {}) {
+  const adapter = adapterFor(sc.harness);
+  const isAlive = o.isAlive ?? runIsAlive;
+  const id = { ...sc, streamPath };
+  const eventsSink = openSink(sc.eventsPath);
+  const obs = new RunObserver(id, adapter, eventsSink, emit.cycle);
+  const tail = new FileTail(streamPath);
+  obs.muted = true;
+  obs.feed(tail.poll());
+  obs.muted = false;
+  const adopted = isAlive(sc);
+  if (adopted) {
+    o.onAdopted?.();
+    const pollMs = o.pollMs ?? TAIL_POLL_MS;
+    while (isAlive(sc)) {
+      obs.feed(tail.poll());
+      await new Promise((r) => setTimeout(r, pollMs));
+    }
+  }
+  obs.feed(tail.poll());
+  obs.end();
+  await endSink(eventsSink);
+  const interrupted = obs.sawResult ? void 0 : adopted ? "no-result" : "daemon-exit";
+  const { ms: ms2, ticket } = await finishRun(
+    id,
+    obs,
+    emit,
+    sc.spawnedAt,
+    { code: null, ...interrupted ? { interrupted } : {} },
+    o.agentLogKey
+  );
+  return { adopted, ...interrupted ? { interrupted } : {}, ms: ms2, ticket };
+}
 
 // src/run-worktree.ts
 import { existsSync as existsSync14 } from "fs";
@@ -8584,6 +8780,8 @@ var describeRunWorktreePlan = (p) => {
       return `reusing ${p.path} (${p.branch} is already level with the remote)`;
     case "recut":
       return `${p.branch} is gone from the remote and ${p.path} held no work of its own \u2014 re-cut it fresh from ${p.base}`;
+    case "resume-dirty":
+      return `${p.path} has uncommitted changes from this seat's previous run (interrupted) \u2014 resuming`;
     case "leave-dirty":
       return `left ${p.path} alone: it has uncommitted changes (someone may be editing it by hand)`;
     case "leave-unpushed":
@@ -8595,7 +8793,7 @@ function newBranchName(cfg, t, role) {
   const { prefix } = ticketBranchContext(t);
   return branchRenderer(t, role)(effectiveBranchTemplate(cfg, prefix));
 }
-function planRunWorktree(dir, 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);
@@ -8605,7 +8803,9 @@ function planRunWorktree(dir, cfg, t, role) {
   const baseRef = hasRemote ? `${remote}/${base}` : base;
   if (existing && !existing.prunable && existsSync14(existing.path)) {
     const branch = existing.branch;
-    if (status(existing.path).length > 0) return { action: "leave-dirty", path: existing.path, branch };
+    if (status(existing.path).length > 0) {
+      return { action: opts.resumeInterrupted ? "resume-dirty" : "leave-dirty", path: existing.path, branch };
+    }
     if (!branch) return { action: "leave-unpushed", path: existing.path, branch: "(detached HEAD)" };
     if (!hasRemote) return { action: "reuse", path: existing.path, branch };
     if (remoteBranchExists(dir, remote, branch)) {
@@ -8632,6 +8832,8 @@ function applyRunWorktree(dir, cfg, plan) {
     case "leave-dirty":
     case "leave-unpushed":
       return null;
+    case "resume-dirty":
+      return plan.path;
     case "reuse":
       if (!worktrees(dir).some((w) => w.path === plan.path)) git(dir, ["worktree", "add", plan.path, plan.branch]);
       return plan.path;
@@ -10447,7 +10649,7 @@ function missingReleaserWarning(repo, release, ships, now = Date.now()) {
 }
 
 // src/watch.ts
-import { watch as watchFile, existsSync as existsSync17, statSync as statSync6, openSync as openSync3, readSync, closeSync as closeSync3 } from "fs";
+import { watch as watchFile, existsSync as existsSync17, statSync as statSync6, 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`;
@@ -10552,10 +10754,10 @@ function readFrom(file, from) {
   const size = statSync6(file).size;
   if (size < from) return readFrom(file, 0);
   if (size === from) return { events: [], offset: from };
-  const fd = openSync3(file, "r");
+  const fd = openSync4(file, "r");
   const buf = Buffer.alloc(size - from);
-  readSync(fd, buf, 0, buf.length, from);
-  closeSync3(fd);
+  readSync2(fd, buf, 0, buf.length, from);
+  closeSync4(fd);
   const text = buf.toString("utf8");
   const lastNewline = text.lastIndexOf("\n");
   if (lastNewline === -1) return { events: [], offset: from };
@@ -11794,7 +11996,7 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync18, existsSync as existsSync24, mkdirSync as mkdirSync13, writeFileSync as writeFileSync14, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync2, statSync as statSync9 } from "fs";
+import { readFileSync as readFileSync18, existsSync as existsSync25, mkdirSync as mkdirSync13, writeFileSync as writeFileSync14, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync2, statSync as statSync9 } from "fs";
 import { createInterface } from "readline/promises";
 import { dirname as dirOf, resolve as resolvePath } from "path";
 
@@ -12534,8 +12736,85 @@ function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync17, readdirSync as readdirSync8, rmSync as rmSync9, statSync as statSync8, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync17, readdirSync as readdirSync9, rmSync as rmSync9, statSync as statSync8, writeFileSync as writeFileSync13 } from "fs";
+import { join as join24 } from "path";
+
+// src/interrupted.ts
+import { existsSync as existsSync23, readdirSync as readdirSync8 } from "fs";
 import { join as join23 } from "path";
+var INTERRUPTED_MARKER = "<!-- crew: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 orphanedStreams(o) {
+  const dir = join23(o.stateDir, "streams");
+  if (!existsSync23(dir)) return [];
+  const ownerAlive = o.isOwnerAlive ?? pidAlive;
+  const out = [];
+  for (const name of readdirSync8(dir)) {
+    if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
+    const streamPath = join23(dir, name);
+    if (existsSync23(`${streamPath}.meta.json`)) 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
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
 var defaultSleep = (ms2) => new Promise((resolve5) => setTimeout(resolve5, ms2));
@@ -12547,7 +12826,18 @@ async function runDaemonLoop(o) {
   let passes = 0;
   for (; ; ) {
     if (o.signal?.aborted) return "aborted";
-    const result = await o.runPass();
+    let result;
+    try {
+      result = await o.runPass();
+    } catch (err) {
+      passes++;
+      o.onPassError?.(err);
+      if (o.maxPasses !== void 0 && passes >= o.maxPasses) return "maxPasses";
+      if (o.signal?.aborted) return "aborted";
+      await sleep(backoff);
+      backoff = Math.min(backoff * 2, ceiling);
+      continue;
+    }
     passes++;
     if (result.started.length > 0) {
       backoff = floor;
@@ -12573,8 +12863,8 @@ function latestMtime(path) {
   if (stat.isFile()) return stat.mtimeMs;
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
-  for (const entry of readdirSync8(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join23(path, entry.name)));
+  for (const entry of readdirSync9(path, { withFileTypes: true })) {
+    latest = Math.max(latest, latestMtime(join24(path, entry.name)));
   }
   return latest;
 }
@@ -12583,13 +12873,13 @@ function computeTreeSignature(paths) {
 }
 function makeStaleChecker(paths, opts = {}) {
   const initial = computeTreeSignature(paths);
-  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync23(opts.reloadSentinel);
+  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync24(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join23(stateDir, "reload-requested");
+  return join24(stateDir, "reload-requested");
 }
 function daemonStampFor(stateDir) {
-  return join23(stateDir, "daemon.started");
+  return join24(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
   mkdirSync12(stateDir, { recursive: true });
@@ -12652,6 +12942,11 @@ async function runOnePass(o) {
   const spawn5 = o.spawnRoleAgent ?? runRoleAgent;
   const breaker = o.spawnBreaker ?? new SpawnBreaker();
   const ctx = { route: o.route, ship: o.ship, state: o.state, emit, getSessionStore: o.getSessionStore };
+  try {
+    await (o.reconcile ?? reconcileForRoute)(ctx, o);
+  } catch (e) {
+    emit.warn(`could not reconcile earlier agent runs: ${e.message}`, { step: "agent" });
+  }
   const decision = await decide(ctx);
   o.state.attention(o.route.route).persist(decision.attention);
   if (decision.sweep.length) {
@@ -12749,6 +13044,54 @@ async function publishShipAttention(o) {
   } catch {
   }
 }
+async function reconcileForRoute(ctx, o) {
+  const { route, ship, emit } = ctx;
+  await reconcileRuns({
+    stateDir: ship.stateDir,
+    routeLabel: routeSlug(route.route),
+    emit,
+    state: o.state,
+    maxConcurrentAgents: o.maxConcurrentAgents,
+    inFlight: o.inFlight,
+    agentLogKey: async (role) => (await resolveSeatKey(route, role, ctx.getSessionStore)).apiKey,
+    afterRun: async (sc, result) => {
+      const identity = await resolveSeatKey(route, sc.role, ctx.getSessionStore);
+      const tracker = new Tracker(route, ship, { apiKey: identity.apiKey });
+      const memberId = route.resolved?.seats[sc.role];
+      try {
+        if (!sc.ticketRecordId) return;
+        if (result.interrupted) {
+          if (!memberId) return;
+          const t = await tracker.ticket(sc.ticketRecordId);
+          const target = repoTargetFor(route, t.repo_id);
+          const num = String(t[tracker.contract.columns.key] ?? "").replace(/^\D+/, "");
+          const wt = target && num ? worktreeForNumber(target.dir, num) : null;
+          let dirty = null;
+          try {
+            if (wt) dirty = status(wt.path).length > 0;
+          } catch {
+          }
+          await tracker.postEvent(sc.ticketRecordId, interruptedComment({
+            branch: wt?.branch ?? null,
+            dirty,
+            reason: result.interrupted === "daemon-exit" ? "the crew daemon exited" : "it exited without a result"
+          }), memberId, "interrupted");
+        } else {
+          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" });
+        });
+      }
+    }
+  });
+}
 async function runRoleAgent(role, decision, ctx) {
   const { route, ship, emit } = ctx;
   const identity = await resolveSeatKey(route, role, ctx.getSessionStore);
@@ -12838,6 +13181,7 @@ async function runRoleAgent(role, decision, ctx) {
     cycle: emit.cycle,
     ticket: ticketHint,
     repo: ticketRepo,
+    ticketRecordId: workingId,
     ...personaPromptOptions(await fetchPersonaPrompt(route, role, { userAgent: ship.userAgent })),
     skillOverrides: await fetchSkillOverrides(route, { userAgent: ship.userAgent }),
     agentPersona: await fetchSeatPersona(route, role, { userAgent: ship.userAgent }),
@@ -13414,14 +13758,14 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join24(homedir8(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync24(staleTimer)) {
+      const staleTimer = join25(homedir8(), ".config", "systemd", "user", `${label}.timer`);
+      if (existsSync25(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
         );
         if (!dryRun) {
-          spawnSync5("systemctl", ["--user", "disable", "--now", `${label}.timer`], { cwd: CREW_HOME });
+          spawnSync6("systemctl", ["--user", "disable", "--now", `${label}.timer`], { cwd: CREW_HOME });
           try {
             unlinkSync5(staleTimer);
           } catch {
@@ -13441,7 +13785,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 (!existsSync24(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync25(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}`);
       problems.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
     }
@@ -13459,8 +13803,8 @@ 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) => existsSync24(p);
-    const crontab = o.host === "linux" ? spawnSync5("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
+    const unitExists = (p) => existsSync25(p);
+    const crontab = o.host === "linux" ? spawnSync6("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 });
     for (const n of plan.notes) process.stdout.write(`fix: ${n}
@@ -14411,7 +14755,7 @@ ${changed2.map((c) => `  - ${c}
           }
           let failed = false;
           for (const cmd2 of commands) {
-            const res2 = spawnSync5(cmd2[0], cmd2.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
+            const res2 = spawnSync6(cmd2[0], cmd2.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
             if (res2.stdout) process.stdout.write(res2.stdout);
             if (res2.stderr) process.stderr.write(res2.stderr);
             if (cmd2 === control.startCommand && (res2.error || res2.status !== 0)) {
@@ -14429,7 +14773,7 @@ ${changed2.map((c) => `  - ${c}
 `);
           break;
         }
-        const res = spawnSync5(cmd[0], cmd.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
+        const res = spawnSync6(cmd[0], cmd.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
         if (res.stdout) process.stdout.write(res.stdout);
         if (res.stderr) process.stderr.write(res.stderr);
         if (daemonSub !== "status" && (res.error || res.status !== 0)) {
@@ -14452,7 +14796,7 @@ ${changed2.map((c) => `  - ${c}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join24(CREW_HOME, "src"), join24(CREW_HOME, "dist"), join24(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join25(CREW_HOME, "src"), join25(CREW_HOME, "dist"), join25(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -14473,6 +14817,9 @@ ${changed2.map((c) => `  - ${c}
 `)
           })
         }),
+        onPassError: (err) => emit.error(
+          `daemon pass failed, continuing: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
+        ),
         checkStale: makeStaleChecker(watchPaths, { reloadSentinel: reloadSentinelFor(cfg.ship.stateDir) }),
         onPass: (result) => {
           if (result.started.length) emit.emit(`daemon pass started: ${result.started.join(", ")}`);
@@ -14611,7 +14958,7 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync24(resolvedPath) ? JSON.parse(readFileSync18(resolvedPath, "utf8")) : {};
+        const raw = existsSync25(resolvedPath) ? JSON.parse(readFileSync18(resolvedPath, "utf8")) : {};
         raw.agentPersonas = personaResult.agentPersonas;
         raw.agentSkills = skillResult.agentSkills;
         if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
@@ -14671,7 +15018,7 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync24(resolvedPath) ? JSON.parse(readFileSync18(resolvedPath, "utf8")) : {};
+        const raw = existsSync25(resolvedPath) ? JSON.parse(readFileSync18(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
         mkdirSync13(dirOf(resolvedPath), { recursive: true });
         writeFileSync14(resolvedPath, `${JSON.stringify(raw, null, 2)}
@@ -14694,7 +15041,7 @@ ${changed2.map((c) => `  - ${c}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync24(resolvePath(p.replace(/^~(?=\/|$)/, homedir8()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync25(resolvePath(p.replace(/^~(?=\/|$)/, homedir8()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -14709,7 +15056,7 @@ ${changed2.map((c) => `  - ${c}
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       let resolvedRemotes;
-      if (existsSync24(resolvedFile)) {
+      if (existsSync25(resolvedFile)) {
         try {
           resolvedRemotes = JSON.parse(readFileSync18(resolvedFile, "utf8"));
         } catch {
@@ -14726,14 +15073,14 @@ ${changed2.map((c) => `  - ${c}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync24(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync25(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}
 `);
           }
           break;
         }
         const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir8()));
-        const top = existsSync24(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync25(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({
@@ -14782,7 +15129,7 @@ ${changed2.map((c) => `  - ${c}
           const created = await rowTracker.createRepoRow(rowPayload);
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
-          if (existsSync24(resolvedFile)) {
+          if (existsSync25(resolvedFile)) {
             const raw = JSON.parse(readFileSync18(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
@@ -15029,7 +15376,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           operator = await pickOperator(found.holds);
         }
         let previous;
-        const hadPreviousFile = existsSync24(resolvedPath);
+        const hadPreviousFile = existsSync25(resolvedPath);
         if (hadPreviousFile) {
           try {
             previous = JSON.parse(readFileSync18(resolvedPath, "utf8"));
@@ -15132,7 +15479,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         const keyPersisted = keychainBacked || apiKeyFile !== void 0;
         const wizard = firstRun;
         const writeFirstRun = wizard !== void 0 && !dryRun && keyPersisted;
-        const routeDir = value("dir") ?? (writeFirstRun ? join24(DEFAULT_REPOS_BASE_PATH, found.workspaceSlug) : void 0);
+        const routeDir = value("dir") ?? (writeFirstRun ? join25(DEFAULT_REPOS_BASE_PATH, found.workspaceSlug) : void 0);
         const routeBlock = renderConnection(
           found,
           route2,
@@ -15508,7 +15855,19 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         process.exit(2);
       }
       const roleWt = positional.find((p) => p === "dev" || p === "design" || p === "qa");
-      const planWt = planRunWorktree(repoWt.dir, repoWt.config, ticketWt, roleWt);
+      let resumeWt = false;
+      try {
+        const trWt = new Tracker(routeWt, cfg.ship);
+        const heldWt = Object.values(routeWt.resolved?.seats ?? {}).includes(ticketWt[trWt.contract.columns.assignee]);
+        if (heldWt) {
+          const cut = await trWt.latestEvent(ticketWt.id, "interrupted");
+          const pushed = await trWt.latestEvent(ticketWt.id, "pushed");
+          const at = (e) => e?.occurred_at ?? e?.created_at ?? "";
+          resumeWt = cut !== void 0 && at(cut) > at(pushed);
+        }
+      } catch {
+      }
+      const planWt = planRunWorktree(repoWt.dir, repoWt.config, ticketWt, roleWt, { resumeInterrupted: resumeWt });
       if (dryRun) {
         emit.emit(`would ${describeRunWorktreePlan(planWt)}`);
         break;
@@ -15654,7 +16013,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       }
       const host = hostPlatform();
       const control = host === "windows" ? null : planDaemonControl(CREW_HOME, host, detectSystemd());
-      const unitStatus = control?.statusCommand ? spawnSync5(control.statusCommand[0], control.statusCommand.slice(1), { cwd: CREW_HOME, encoding: "utf8" }) : null;
+      const unitStatus = control?.statusCommand ? spawnSync6(control.statusCommand[0], control.statusCommand.slice(1), { cwd: CREW_HOME, encoding: "utf8" }) : null;
       const unitRunning = unitStatus !== null && !unitStatus.error && unitStatus.status === 0;
       if (!unitRunning) {
         process.stdout.write("crew reload: no daemon unit is running \u2014 nothing to reload (the next run reads crew.yaml fresh)\n");
@@ -15666,7 +16025,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       process.stdout.write("crew reload: requested \u2014 the daemon finishes its in-flight pass, then relaunches with the new config\n");
       if (flag("now") && control?.stopCommand && control.startCommand) {
         for (const cmd of [control.stopCommand, control.startCommand]) {
-          const res = spawnSync5(cmd[0], cmd.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
+          const res = spawnSync6(cmd[0], cmd.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
           if (cmd === control.startCommand && (res.error || res.status !== 0)) {
             process.stderr.write(`crew reload: ${cmd.join(" ")} exited ${res.status ?? "error"}
 `);
@@ -15922,13 +16281,28 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       );
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync24(evFile) ? statSync9(evFile).size : 0;
+        const evSize = existsSync25(evFile) ? statSync9(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"
         );
       } catch {
       }
+      if (host !== "windows") {
+        const unitPlan = planInstall(cfg.ship, CREW_HOME, host, detectSystemd(), "run");
+        const abandons = unitAbandonsAgents(unitPlan, (p) => {
+          try {
+            return readFileSync18(p, "utf8");
+          } catch {
+            return null;
+          }
+        });
+        if (abandons === false) {
+          process.stdout.write(
+            "scheduler unit:    WARN the installed unit does not leave agent runs alone when the daemon restarts (no AbandonProcessGroup / KillMode=process) \u2014 a daemon crash or relaunch kills the run in flight; run `crew install`\n"
+          );
+        }
+      }
       const daemonStartedAt = readDaemonStarted(cfg.ship.stateDir);
       if (daemonStartedAt !== null) {
         const changed2 = configChangedAfter(daemonConfigPaths(cfg), daemonStartedAt);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.49.5",
+  "version": "0.50.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",