@tablation/crew 0.17.0 → 0.19.0

package/README.md

@@ -206,6 +206,7 @@ crew doctor [route] [--fix]    preflight; --fix enables clean routes, offers cre
 crew ports [route]             which checkout owns which ports, and what is up
 crew reap [route]              kill servers left behind by removed worktrees
 crew drop [route] NNN          remove a merged ticket's worktree and branch
+crew worktree [route] NNN      cut (or refresh) this run's worktree for a ticket from the remote; prints its path
 crew sync [route]              fast-forward the checkout and its worktrees from the remote
 crew pause|resume [route] [R|release]  pause everything, one role, or releases only (passengers keep running)
 crew log [route]               tail the log

package/dist/cli.js

@@ -2575,6 +2575,9 @@ function detectSystemd() {
   return !res.error;
 }
 
+// src/ship-attention.ts
+import { statfsSync } from "fs";
+
 // src/git.ts
 import { execFileSync } from "child_process";
 import {
@@ -3049,14 +3052,94 @@ function baseAttention(repo, outcome, remote, base, nowIso = (/* @__PURE__ */ ne
   if (outcome.action === "level" || outcome.action === "fast-forwarded") return { clear: baseUnsafeKey(repo) };
   return null;
 }
+var diskLowKey = (repo) => `disk_low:${repo}`;
+var LOW_DISK_BYTES = 2 * 1024 ** 3;
+var gib = (bytes) => (bytes / 1024 ** 3).toFixed(1);
+function diskAttention(repo, freeBytes, thresholdBytes = LOW_DISK_BYTES, nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (freeBytes >= thresholdBytes) return { clear: diskLowKey(repo) };
+  return {
+    raise: {
+      kind: "disk_low",
+      key: diskLowKey(repo),
+      since: nowIso,
+      message: `${repo}: only ${gib(freeBytes)} GiB free beside the checkout (need ${gib(thresholdBytes)}) \u2014 no worktree can be set up until space is freed. Resumes automatically once there is room`
+    }
+  };
+}
+function freeBytesAt(dir) {
+  try {
+    const s = statfsSync(dir);
+    return Number(s.bavail) * Number(s.bsize);
+  } catch {
+    return null;
+  }
+}
+async function checkRepoDisks(o, freeAt = freeBytesAt, thresholdBytes = LOW_DISK_BYTES) {
+  for (const target of reposOf(o.route)) {
+    const free = freeAt(target.dir);
+    if (free === null) continue;
+    const att = diskAttention(target.name, free, thresholdBytes);
+    if ("raise" in att) await raiseShipAttention(o, att.raise);
+    else clearShipAttention(o.state, att.clear);
+  }
+}
+function parseHookMissing(key, routeName) {
+  const prefix = `hook_missing:${routeName}/`;
+  if (!key.startsWith(prefix)) return null;
+  const rest = key.slice(prefix.length);
+  const slash = rest.lastIndexOf("/");
+  if (slash <= 0) return null;
+  return { repo: rest.slice(0, slash), hook: rest.slice(slash + 1) };
+}
 function repoStopFor(items, route) {
-  const stops = new Map(items.filter((i) => i.kind === "base_unsafe").map((i) => [i.key, i.message]));
+  const stops = /* @__PURE__ */ new Map();
+  for (const i of items) {
+    let repo = null;
+    if (i.kind === "base_unsafe") repo = i.key.slice("base_unsafe:".length);
+    else if (i.kind === "disk_low") repo = i.key.slice("disk_low:".length);
+    else if (i.kind === "hook_missing") {
+      const h = parseHookMissing(i.key, route.route);
+      if (h?.hook === "setup") repo = h.repo;
+    }
+    if (repo && !stops.has(repo)) stops.set(repo, i.message);
+  }
   if (stops.size === 0) return () => null;
   return (t) => {
     const name = repoTargetFor(route, t.repo_id)?.name;
-    return name ? stops.get(baseUnsafeKey(name)) ?? null : null;
+    return name ? stops.get(name) ?? null : null;
   };
 }
+function recheckEnvironmentStops(state, route, ship, deps = {}) {
+  const onPath = deps.onPath ?? findOnPath;
+  const dockerProblem = deps.dockerProblem ?? dockerPathProblem;
+  const cleared = [];
+  for (const item of state.shipAttention().previous()) {
+    if (item.kind === "docker_missing") {
+      if (!dockerProblem(ship)) {
+        clearShipAttention(state, item.key);
+        cleared.push("docker");
+      }
+      continue;
+    }
+    if (item.kind !== "hook_missing") continue;
+    const h = parseHookMissing(item.key, route.route);
+    const target = h && reposOf(route).find((t) => t.name === h.repo);
+    if (!h || !target) continue;
+    let cfg;
+    try {
+      cfg = resolveRepoConfig(loadRepoConfig(target.dir), void 0, target.dir);
+    } catch {
+      continue;
+    }
+    const script = cfg.hooks[h.hook];
+    const cmd = script ? hookCommand(script) : null;
+    if (!cmd || onPath(cmd, pathFor(ship))) {
+      clearShipAttention(state, item.key);
+      cleared.push(`${h.repo}/${h.hook}`);
+    }
+  }
+  return cleared;
+}
 function recheckBaseStops(state, route) {
   const open = state.shipAttention().previous().filter((i) => i.kind === "base_unsafe");
   const cleared = [];
@@ -4695,6 +4778,10 @@ async function decideCycle(o) {
   for (const repo of recheckBaseStops(state, route)) {
     emit.emit(`${repo}: primary checkout is level again \u2014 building lanes resume for that repo`, { step: "select" });
   }
+  for (const what of recheckEnvironmentStops(state, route, ship)) {
+    emit.emit(`${what}: no longer missing from the scheduler PATH \u2014 stop cleared`, { step: "select" });
+  }
+  await checkRepoDisks({ state, emit, route, ship });
   const selectionInput = {
     repoStop: repoStopFor(openShipAttention(state), route),
     tickets,
@@ -6010,11 +6097,18 @@ function applyRunWorktree(dir, cfg, plan) {
       return plan.path;
   }
 }
+function worktreeHoldsUnpushed(path, remote) {
+  const out = gitOk(path, ["for-each-ref", "--contains", "HEAD", "--count=1", "--format=%(refname)", `refs/remotes/${remote}/`]);
+  return out === null || out.trim() === "";
+}
 async function finishRunWorktree(dir, cfg, branch) {
   const wt = worktrees(dir).find((w) => w.branch === branch && !w.prunable && w.path !== dir);
   if (!wt || !existsSync9(wt.path)) return { kind: "none" };
   if (cfg.hooks.handoff) return { kind: "kept-handoff", path: wt.path };
   if (status(wt.path).length > 0) return { kind: "kept-dirty", path: wt.path };
+  if (remoteConfigured(dir, cfg.branch.remote) && worktreeHoldsUnpushed(wt.path, cfg.branch.remote)) {
+    return { kind: "kept-unpushed", path: wt.path };
+  }
   const n = Number(wt.path.match(/(\d+)$/)?.[1] ?? NaN);
   if (Number.isFinite(n)) {
     const pids = pidsInWorktree(wt.path, n);
@@ -6114,7 +6208,7 @@ async function enforceHandoff(i) {
   }
 }
 async function guardRunHandoff(route, ship, tracker, role, workingId, log) {
-  if (role !== "dev" && role !== "design" || !workingId) return null;
+  if (!workingId || role !== "dev" && role !== "design" && role !== "qa") return null;
   const seatId = route.resolved?.seats[role];
   if (!seatId) return null;
   try {
@@ -6127,6 +6221,10 @@ async function guardRunHandoff(route, ship, tracker, role, workingId, log) {
       labels: { ...route.labels, ...o?.labels },
       branch: { ...route.branch, ...o?.branch }
     }, target.dir);
+    if (role === "qa") {
+      await retireRunWorktree(tracker, target.dir, cfg, t, role, seatId, ship.name, log);
+      return null;
+    }
     const affinity = await tracker.claimAffinity();
     const outcome = await enforceHandoff({
       writer: tracker,
@@ -6158,6 +6256,7 @@ async function retireRunWorktree(tracker, dir, cfg, t, role, seatId, shipName2,
       log.emit(`${t.issue_id}: kept worktree ${o.path} \u2014 this repo's handoff hook serves from it`, at);
       await tracker.postEvent(t.id, `worktree kept on ship ${shipName2} at \`${o.path}\`: the repo's \`handoff\` hook serves from it. QA on another ship cuts its own from \`${cfg.branch.remote}/${branch}\` instead.`, seatId);
     } else if (o.kind === "kept-dirty") log.warn(`${t.issue_id}: left worktree ${o.path} \u2014 it has uncommitted changes`, at);
+    else if (o.kind === "kept-unpushed") log.warn(`${t.issue_id}: left worktree ${o.path} \u2014 its branch has commits that are not on ${cfg.branch.remote}`, at);
   } catch (e) {
     log.warn(`could not retire the run's worktree: ${e.message}`, { step: "handoff" });
   }
@@ -8936,18 +9035,22 @@ import { existsSync as existsSync15 } from "fs";
 import { basename as basename6 } 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;
   const byNumber = new Map(tickets.map((t) => [t.issue_id.replace(/^\D+/, ""), t]));
   const actions = [];
   for (const w of worktrees(target.dir)) {
     const m = /(?:^|-)(\d+)$/.exec(basename6(w.path));
     if (!m) continue;
     const ticket = byNumber.get(m[1]);
-    if (!ticket || !terminal.has(ticket.status)) continue;
+    if (!ticket) continue;
+    const isVerified = ticket.status === verified;
+    if (!isVerified && !terminal.has(ticket.status)) continue;
     actions.push({
       ticket,
       path: w.path,
       branch: w.branch,
-      keepBranch: ticket.status !== contract.statuses.deployed
+      keepBranch: ticket.status !== contract.statuses.deployed,
+      ...isVerified ? { requirePushed: true } : {}
     });
   }
   return actions;
@@ -8970,6 +9073,13 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin")
         continue;
       }
     }
+    if (!dryRun && a.requirePushed && a.branch && existsSync15(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
+      log.warn(
+        `not removing worktree ${a.path} for ${a.ticket.issue_id} (${a.ticket.status}): ${a.branch} has commits that are not on ${remote}`,
+        { ticket: a.ticket.issue_id, step: "worktree" }
+      );
+      continue;
+    }
     const n = Number(a.ticket.issue_id.replace(/^\D+/, ""));
     const pids = pidsInWorktree(a.path, n);
     if (pids.length) {
@@ -10966,8 +11076,9 @@ ${changed2.map((c) => `  - ${c}
       }
       try {
         const terminal = await tracker.terminalTickets();
+        const verifiedNow = (await tracker.openTickets()).filter((t) => t.status === tracker.contract.statuses.verified);
         const scoped = ticketsByRepo(c, terminal).byRepo.get(target.name) ?? [];
-        const actions = planWorktreeSweep(target, scoped, tracker.contract);
+        const actions = planWorktreeSweep(target, [...scoped, ...ticketsByRepo(c, verifiedNow).byRepo.get(target.name) ?? []], tracker.contract);
         if (actions.length) {
           remit.enter("worktree");
           const r = await applyWorktreeSweep(target.dir, actions, dryRun, remit, repo.branch.remote);
@@ -12344,8 +12455,12 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       const tracker = new Tracker(route, cfg.ship);
       const terminal = await tracker.terminalTickets();
       const { byRepo } = ticketsByRepo(route, terminal);
+      const verifiedByRepo = ticketsByRepo(
+        route,
+        (await tracker.openTickets()).filter((t) => t.status === tracker.contract.statuses.verified)
+      ).byRepo;
       for (const r of await resolvedRepos(route)) {
-        const actions = planWorktreeSweep(r, byRepo.get(r.name) ?? [], tracker.contract);
+        const actions = planWorktreeSweep(r, [...byRepo.get(r.name) ?? [], ...verifiedByRepo.get(r.name) ?? []], tracker.contract);
         const stale = planRemoteBranchCleanup(r.dir, r.config.branch.remote, r.config.branch.base, byRepo.get(r.name) ?? [], tracker.contract);
         if (stale.length) {
           anything = true;

package/package.json

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