@tablation/crew 0.94.0 → 0.95.0

package/crew.example.yaml

@@ -56,6 +56,7 @@ ship:
   #       deep: { model: claude-opus-5-5 }
   #     args: []                   # appended to the harness argv
   #     env: {}                    # added to the session environment
+  #     maxRunMinutes: 240         # wall-clock limit per agent run (default 240; 0 = none); a route's maxRunMinutes overrides it (CREW-2786)
   #   gemini: { harness: gemini, bin: gemini, model: gemini-2.5-pro }
 
   # shell: bash                      # defaults per platform

package/dist/cli.js

@@ -2665,7 +2665,8 @@ var ROUTE_KEYS = /* @__PURE__ */ new Set([
   "promptSet",
   "hostPassengers",
   "hostPeriscopes",
-  "toolchain"
+  "toolchain",
+  "maxRunMinutes"
 ]);
 function parseWorktreeName(v, where, file) {
   const problem = typeof v === "string" ? worktreeNameProblem(v) : "must be a string";
@@ -3075,7 +3076,21 @@ Create the first of those:
 function expandCommand(cmd, base) {
   return cmd.includes("/") || cmd.startsWith("~") ? expand(cmd, base) : cmd;
 }
-var TOOLCHAIN_KEYS = /* @__PURE__ */ new Set(["harness", "bin", "launcher", "launcherBin", "model", "tiers", "args", "env", "maxThinkingTokens", "auth"]);
+var TOOLCHAIN_KEYS = /* @__PURE__ */ new Set(["harness", "bin", "launcher", "launcherBin", "model", "tiers", "args", "env", "maxThinkingTokens", "auth", "maxRunMinutes"]);
+var MAX_RUN_MINUTES_CEILING = Math.floor((2 ** 31 - 1) / 6e4);
+function parseMaxRunMinutes(raw, where, missing) {
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0) {
+    missing.add(`${where} must be a non-negative integer number of minutes, 0 for no limit (got "${String(raw)}")`);
+    return void 0;
+  }
+  if (n > MAX_RUN_MINUTES_CEILING) {
+    missing.add(`${where} is too large (${n}); the most it can be is ${MAX_RUN_MINUTES_CEILING} minutes \u2014 use 0 for no limit`);
+    return void 0;
+  }
+  return n;
+}
 function parsePair(raw, missing) {
   if (raw === void 0) return void 0;
   if (!Array.isArray(raw)) {
@@ -3132,6 +3147,7 @@ function parseToolchains(raw, base, missing, file) {
     if (!Number.isInteger(maxThinkingTokens) || maxThinkingTokens < 0) {
       missing.add(`${where}.maxThinkingTokens must be a non-negative integer (got "${entryRaw.maxThinkingTokens}")`);
     }
+    const maxRunMinutes = parseMaxRunMinutes(entryRaw.maxRunMinutes, `${where}.maxRunMinutes`, missing);
     let auth;
     if (entryRaw.auth !== void 0) {
       if (entryRaw.auth !== "subscription" && entryRaw.auth !== "inherit") {
@@ -3153,7 +3169,8 @@ function parseToolchains(raw, base, missing, file) {
       tiers,
       args: Array.isArray(args) ? args.map(String) : [],
       env: Object.fromEntries(Object.entries(env).map(([k, v]) => [k, String(v)])),
-      maxThinkingTokens
+      maxThinkingTokens,
+      ...maxRunMinutes !== void 0 ? { maxRunMinutes } : {}
     });
   }
   return out;
@@ -3161,6 +3178,7 @@ function parseToolchains(raw, base, missing, file) {
 function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, toolchainNames) {
   rejectUnknownKeys(c, ROUTE_KEYS, `${where}`, file);
   const toolchain = c?.toolchain === void 0 ? void 0 : String(c.toolchain);
+  const maxRunMinutes = parseMaxRunMinutes(c?.maxRunMinutes, `${where}.maxRunMinutes`, missing);
   if (toolchain !== void 0 && !toolchainNames.has(toolchain)) {
     missing.add(`${where}.toolchain "${toolchain}" is not defined in ship.toolchains (have: ${[...toolchainNames].join(", ")})`);
   }
@@ -3224,6 +3242,7 @@ function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, t
     repoOverrides,
     worktreePrefix: c?.worktreePrefix ? String(c.worktreePrefix) : void 0,
     ...toolchain !== void 0 ? { toolchain } : {},
+    ...maxRunMinutes !== void 0 ? { maxRunMinutes } : {},
     promptsDir: resolvePromptsDir(c?.promptSet ? String(c.promptSet) : void 0, crewHome, base),
     weight,
     baseUrl: String(c?.baseUrl ?? raw.ship?.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, ""),
@@ -7563,6 +7582,28 @@ var Tracker = class {
     if (!auth.commentShip) missing.push(`Comments.${this.contract.comments.ship}`);
     return missing;
   }
+  /**
+   * The runtime-map columns (ISSUE-2791) this workspace's template has not
+   * taken yet, as `table.column` names for `crew doctor`. Each is read as its
+   * default when absent, so this is informational: `Repos.forge_host`
+   * (default `github.com`), `Ships.kind` (`developer_machine`),
+   * `Ships.instance_class` and `Ships.relay_url` (blank). A table the route
+   * does not have is skipped, not reported.
+   */
+  async missingRuntimeColumns() {
+    const wanted = [
+      [this.route.resolved?.reposModelId, "Repos", ["forge_host"]],
+      [this.route.resolved?.shipsModelId, "Ships", ["kind", "instance_class", "relay_url"]]
+    ];
+    const missing = [];
+    for (const [modelId, label, columns] of wanted) {
+      if (!modelId) continue;
+      const have = await this.columnNames(modelId);
+      if (have.size === 0) continue;
+      for (const c of columns) if (!have.has(c)) missing.push(`${label}.${c}`);
+    }
+    return missing;
+  }
   /**
    * The public `/v/<slug>/r/<token>` link for one ticket (ISSUE-928) —
    * fetch-or-create via `POST /views/:viewId/record-links`, so a repeated
@@ -9190,6 +9231,55 @@ function skillMarkerWarnings(promptsDir, personaPrompts) {
   return out;
 }
 
+// src/run-limit.ts
+var DEFAULT_MAX_RUN_MINUTES = 240;
+var KILL_GRACE_MS = 5e3;
+var WALL_CLOCK_REASON = "wall-clock";
+function resolveMaxRunMinutes(route2, toolchain) {
+  return route2 ?? toolchain ?? DEFAULT_MAX_RUN_MINUTES;
+}
+function deadlineFor(spawnedAt, maxRunMinutes) {
+  if (!maxRunMinutes || maxRunMinutes <= 0) return void 0;
+  const t = Date.parse(spawnedAt);
+  return Number.isNaN(t) ? void 0 : new Date(t + maxRunMinutes * 6e4).toISOString();
+}
+function msUntilDeadline(deadline, now = Date.now()) {
+  if (!deadline) return void 0;
+  const t = Date.parse(deadline);
+  return Number.isNaN(t) ? void 0 : t - now;
+}
+async function killRunGroup(pid, o = {}) {
+  const alive = o.isAlive ?? ((p) => {
+    try {
+      process.kill(p, 0);
+      return true;
+    } catch (e) {
+      return e.code === "EPERM";
+    }
+  });
+  const signal = (sig) => {
+    try {
+      process.kill(-pid, sig);
+    } catch {
+      try {
+        process.kill(pid, sig);
+      } catch {
+      }
+    }
+  };
+  signal("SIGTERM");
+  const end = Date.now() + (o.graceMs ?? KILL_GRACE_MS);
+  while (alive(pid) && Date.now() < end) await new Promise((r) => setTimeout(r, 50));
+  if (alive(pid)) signal("SIGKILL");
+}
+var RUN_KILLED_MARKER = "<!-- crew:run-killed -->";
+function runKilledComment(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 `${RUN_KILLED_MARKER}
+
+The agent run on this ticket was stopped at its wall-clock limit of ${b.limitMinutes} minutes before it handed on${b.branch ? `; its branch is \`${b.branch}\`` : ""}. ${tree} The worktree is left as it was. The next run on this seat resumes from it rather than starting over.`;
+}
+
 // src/agent.ts
 var DIGEST_MAX_AGE_SECONDS = 600;
 var LEGACY_TOOLCHAIN_HARNESS = "claude";
@@ -9299,6 +9389,7 @@ function planAgentRun(o) {
     toolchain: toolchain.name,
     harness: toolchain.harness,
     provider: toolchainProvider(toolchain),
+    maxRunMinutes: resolveMaxRunMinutes(o.route.maxRunMinutes, toolchain.maxRunMinutes),
     resolution: { toolchain: seat.toolchainWhy, model: seat.modelWhy },
     warnings: [...seat.warnings ?? [], ...expanded.warnings],
     prompt,
@@ -9388,6 +9479,17 @@ function identityOf(plan, adapterHarness) {
     promptSha: plan.promptSha
   };
 }
+async function killForDeadline(pid, emit, role, ticket, spawnedAt, limitMinutes) {
+  const elapsedMs = Date.now() - Date.parse(spawnedAt);
+  const limit = limitMinutes ?? Math.round(elapsedMs / 6e4);
+  emit.emit(`run_killed: ${role} run exceeded its wall-clock limit of ${limit} min (ran ${Math.round(elapsedMs / 6e4)} min)`, {
+    role,
+    ...ticket ? { ticket } : {},
+    data: { event: "run_killed", reason: WALL_CLOCK_REASON, limitMinutes: limit, elapsedMs, pid }
+  });
+  await killRunGroup(pid);
+  return { limitMinutes: limit, elapsedMs };
+}
 var withoutKey = ({ apiKey: _apiKey, ...rest }) => rest;
 function openSink(path) {
   try {
@@ -9747,13 +9849,16 @@ function spawnAgent(plan, emit, hintMoved) {
       detached: true
     });
     closeSync3(streamFd);
+    const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const deadline = deadlineFor(spawnedAt, plan.maxRunMinutes);
     if (child.pid !== void 0) {
       const sidecar = {
         pid: child.pid,
         ownerPid: process.pid,
-        spawnedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        spawnedAt,
         role: plan.role,
         route: plan.route,
+        ...deadline ? { deadline, maxRunMinutes: plan.maxRunMinutes } : {},
         ticket: plan.ticket ?? null,
         ticketRecordId: plan.ticketRecordId ?? null,
         repo: plan.repo ?? null,
@@ -9773,25 +9878,45 @@ function spawnAgent(plan, emit, hintMoved) {
       }
     }
     const obs = new RunObserver(id, adapter, eventsSink, emit.cycle);
-    const meta = { pid: child.pid ?? null };
+    const meta = { pid: child.pid ?? null, ...deadline ? { deadline } : {} };
     obs.onClaim = () => writeRunMeta(id, startedAt, obs.liveTicket, meta);
     if (child.pid !== void 0) writeRunMeta(id, startedAt, obs.liveTicket, meta);
     const tail3 = new FileTail(plan.streamPath);
     const timer = setInterval(() => obs.feed(tail3.poll()), TAIL_POLL_MS);
+    let killed;
+    const limitTimer = child.pid !== void 0 && deadline ? setTimeout(() => {
+      const pid = child.pid;
+      void killForDeadline(pid, emit, plan.role, obs.liveTicket ?? plan.ticket ?? null, spawnedAt, plan.maxRunMinutes).then((k) => {
+        killed = k;
+      });
+    }, Math.max(0, msUntilDeadline(deadline) ?? 0)) : void 0;
     let spawnFailed = false;
     child.on("error", (err3) => {
       spawnFailed = true;
       clearInterval(timer);
+      clearTimeout(limitTimer);
       reject(new AgentSpawnError(`cannot run ${plan.bin}: ${err3.message}`));
     });
     child.on("close", async (code) => {
       clearInterval(timer);
+      clearTimeout(limitTimer);
       obs.feed(tail3.poll());
       obs.end();
       await endSink(eventsSink);
       if (spawnFailed) return;
-      const { ms: ms3, handoffPending } = await finishRun(id, obs, emit, startedAt, { code: code ?? 1 }, plan.agentLog?.apiKey, hintMoved);
-      resolve6({ code: code ?? 1, ms: ms3, ...handoffPending ? { handoffPending } : {} });
+      if (limitTimer && !killed && !obs.sawResult && msUntilDeadline(deadline) <= 0) {
+        killed = { limitMinutes: plan.maxRunMinutes ?? 0, elapsedMs: Date.now() - Date.parse(spawnedAt) };
+      }
+      const { ms: ms3, handoffPending } = await finishRun(
+        id,
+        obs,
+        emit,
+        startedAt,
+        { code: code ?? 1, ...killed ? { interrupted: WALL_CLOCK_REASON } : {} },
+        plan.agentLog?.apiKey,
+        hintMoved
+      );
+      resolve6({ code: code ?? 1, ms: ms3, ...handoffPending ? { handoffPending } : {}, ...killed ? { killed } : {} });
     });
     child.stdin?.on("error", (err3) => {
       emit.warn(`agent closed stdin before the prompt was delivered: ${err3.message}`, { step: "agent" });
@@ -9810,18 +9935,23 @@ async function reattachRun(streamPath, sc, emit, o = {}) {
   obs.feed(tail3.poll());
   obs.muted = false;
   const adopted = isAlive(sc);
+  let killed;
   if (adopted) {
     o.onAdopted?.();
     const pollMs = o.pollMs ?? TAIL_POLL_MS;
     while (isAlive(sc)) {
       obs.feed(tail3.poll());
+      if (!killed && (msUntilDeadline(sc.deadline) ?? 1) <= 0) {
+        killed = await killForDeadline(sc.pid, emit, sc.role, obs.liveTicket ?? sc.ticket, sc.spawnedAt, sc.maxRunMinutes);
+        continue;
+      }
       await new Promise((r) => setTimeout(r, pollMs));
     }
   }
   obs.feed(tail3.poll());
   obs.end();
   await endSink(eventsSink);
-  const interrupted = obs.sawResult ? void 0 : adopted ? "no-result" : "daemon-exit";
+  const interrupted = killed ? WALL_CLOCK_REASON : obs.sawResult ? void 0 : adopted ? "no-result" : "daemon-exit";
   const { ms: ms3, ticket } = await finishRun(
     id,
     obs,
@@ -9830,7 +9960,7 @@ async function reattachRun(streamPath, sc, emit, o = {}) {
     { code: null, ...interrupted ? { interrupted } : {} },
     o.agentLogKey
   );
-  return { adopted, ...interrupted ? { interrupted } : {}, ms: ms3, ticket };
+  return { adopted, ...interrupted ? { interrupted } : {}, ...killed ? { killed } : {}, ms: ms3, ticket };
 }
 
 // src/seat-keys.ts
@@ -14331,7 +14461,8 @@ function describeRun(run2, route2, seatIds, worktreeOf = (d, n) => {
     worktree: repoDir && num ? worktreeOf(repoDir, num) : null,
     stream: run2.streamPath,
     pid: run2.pid,
-    startedAt: run2.spawnedAt
+    startedAt: run2.spawnedAt,
+    deadline: run2.deadline ?? null
   };
 }
 
@@ -15505,7 +15636,10 @@ async function discover(o) {
         ...hostPeriscopes !== void 0 ? { host_periscopes: hostPeriscopes } : {},
         ...sshPublicKey !== void 0 ? { ssh_public_key: sshPublicKey } : {},
         ...ownerId !== void 0 ? { owner_id: ownerId } : {},
-        ...writeMachineId ? { machine_id: machineId } : {}
+        ...writeMachineId ? { machine_id: machineId } : {},
+        // ISSUE-2791: a ship connecting by hand is a developer machine; the
+        // column arrives with a template update, so only written when present.
+        ...shipColumns.has("kind") ? { kind: "developer_machine" } : {}
       });
       shipRowId = created.id;
       out.shipRow = { id: shipRowId, name: o.ship.name, action: "created", matchedBy };
@@ -18782,7 +18916,7 @@ async function reconcileForRoute(ctx, o) {
             if (wt) dirty = status(wt.path).length > 0;
           } catch {
           }
-          await tracker.postEvent(sc.ticketRecordId, interruptedComment({
+          await tracker.postEvent(sc.ticketRecordId, result.killed ? runKilledComment({ limitMinutes: result.killed.limitMinutes, branch: wt?.branch ?? null, dirty }) : interruptedComment({
             branch: wt?.branch ?? null,
             dirty,
             reason: result.interrupted === "daemon-exit" ? "the crew daemon exited" : "it exited without a result"
@@ -18805,6 +18939,23 @@ async function reconcileForRoute(ctx, o) {
     }
   });
 }
+async function postRunKilled(route2, tracker, ticketId, memberId, limitMinutes, emit) {
+  if (!ticketId || !memberId) return;
+  try {
+    const t = await tracker.ticket(ticketId);
+    const target = repoTargetFor(route2, t.repo_id);
+    const num = String(t[tracker.contract.columns.key] ?? "").replace(/^\D+/, "");
+    const wt = target && num ? worktreeForNumber(target.dir, num) : null;
+    let dirty = null;
+    try {
+      if (wt) dirty = status(wt.path).length > 0;
+    } catch {
+    }
+    await tracker.postEvent(ticketId, runKilledComment({ limitMinutes, branch: wt?.branch ?? null, dirty }), memberId, "interrupted");
+  } catch (e) {
+    emit.warn(`could not post the wall-clock limit comment: ${e.message}`, { step: "agent" });
+  }
+}
 async function runRoleAgent(role, decision, ctx, hooks) {
   const held = {};
   try {
@@ -18967,8 +19118,12 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
       } catch {
       }
     }
-    await spawnAgent(plan, emit, hintMoved);
-    await guardRunHandoff(route2, ship, tracker, role, workingId, emit, runStart);
+    const result = await spawnAgent(plan, emit, hintMoved);
+    if (result.killed) {
+      await postRunKilled(route2, tracker, workingId, memberId, result.killed.limitMinutes, emit);
+    } else {
+      await guardRunHandoff(route2, ship, tracker, role, workingId, emit, runStart);
+    }
   } finally {
     await settleRunEnd({
       tracker,
@@ -24403,7 +24558,7 @@ 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})
+        process.stdout.write(`running:    ${x.role} \u2014 ${x.ticket ?? "(no ticket)"}${x.repo ? ` in ${x.repo}` : ""} (pid ${x.pid}, since ${x.spawnedAt}${x.deadline ? `, deadline ${x.deadline}` : ""})
 `);
       }
       if (shipRows.length) {
@@ -24613,6 +24768,11 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       const missingAuthorship = await tracker.missingAuthorshipColumns();
       process.stdout.write(
         missingAuthorship.length === 0 ? "authorship:       filed_by_id, ship_id present\n" : `authorship:       missing ${missingAuthorship.join(", ")} \u2014 update the Issues template
+`
+      );
+      const missingRuntime = await tracker.missingRuntimeColumns();
+      process.stdout.write(
+        missingRuntime.length === 0 ? "runtime columns: forge_host, kind, instance_class, relay_url present\n" : `runtime columns: missing ${missingRuntime.join(", ")} \u2014 read as their defaults; update the Issues template
 `
       );
       process.stdout.write(

package/package.json

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