@tablation/crew 0.53.3 → 0.53.4

package/dist/cli.js

@@ -4075,7 +4075,7 @@ function detectSystemd() {
 }
 
 // src/ship-attention.ts
-import { statfsSync } from "fs";
+import { existsSync as existsSync11, statfsSync } from "fs";
 
 // src/git.ts
 import { execFileSync } from "child_process";
@@ -4765,6 +4765,44 @@ function recheckBaseStops(state, route) {
   }
   return cleared;
 }
+var heldWorktreeKey = (repo, path) => `worktree_held:${repo}:${path}`;
+var HELD_WORKTREE_REMINDER_MS = 24 * 60 * 60 * 1e3;
+function noteHeldWorktree(state, h, nowMs = Date.now()) {
+  const store = state.shipAttention();
+  const previous = store.previous();
+  const key = heldWorktreeKey(h.repo, h.path);
+  const existing = previous.find((i) => i.key === key)?.held;
+  const nowIso = new Date(nowMs).toISOString();
+  const lastWarned = existing ? Date.parse(existing.lastWarnedAt) : NaN;
+  const warn = !existing ? "first" : existing.reason !== h.reason ? "changed" : !(nowMs - lastWarned < HELD_WORKTREE_REMINDER_MS) ? "reminder" : null;
+  const held = {
+    ...h,
+    firstSeenAt: existing?.firstSeenAt ?? nowIso,
+    lastWarnedAt: warn ? nowIso : existing.lastWarnedAt
+  };
+  const n = h.ticket.replace(/^\D+/, "");
+  const item = {
+    kind: "worktree_held",
+    key,
+    since: held.firstSeenAt,
+    held,
+    message: `${h.repo}: worktree ${h.path} for ${h.ticket} (${h.status}) is not swept: ${h.reason}. Fix by hand: \`crew drop ${n}\`, or commit/push or discard what is in it`
+  };
+  if (!existing || existing.reason !== h.reason || warn) store.persist(upsert(previous, item));
+  return warn;
+}
+function reconcileHeldWorktrees(state, repo, log, stillRefused) {
+  for (const i of state.shipAttention().previous()) {
+    if (i.kind !== "worktree_held" || !i.held || i.held.repo !== repo) continue;
+    const gone = !existsSync11(i.held.path);
+    if (!gone && !(stillRefused && !stillRefused.has(i.held.path))) continue;
+    clearShipAttention(state, i.key);
+    log.emit(
+      gone ? `worktree ${i.held.path} is gone; clearing the hold` : `worktree ${i.held.path} is no longer held; clearing the hold`,
+      { ticket: i.held.ticket, step: "worktree" }
+    );
+  }
+}
 function openShipAttention(state, nowMs = Date.now()) {
   const stale = staleRelease(state.releaseHeartbeat().at(), nowMs);
   const stored = state.shipAttention().previous();
@@ -7187,7 +7225,7 @@ var alreadyReported = (ticket, g, events) => events.some((e) => e.record_id ===
 
 // src/agent.ts
 import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
-import { readFileSync as readFileSync12, existsSync as existsSync13, statSync as statSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync8, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync14, 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";
@@ -7605,7 +7643,7 @@ function expandSkillMarkers(text, lookup, opts = {}) {
 }
 
 // src/skills.ts
-import { readFileSync as readFileSync11, readdirSync as readdirSync4, existsSync as existsSync12 } from "fs";
+import { readFileSync as readFileSync11, readdirSync as readdirSync4, existsSync as existsSync13 } from "fs";
 import { join as join13 } from "path";
 import { parse as parseYaml } from "yaml";
 import { TablationClient as TablationClient3, StaleWriteError as StaleWriteError8, TablationApiError as TablationApiError2 } from "@tablation/client";
@@ -7622,7 +7660,7 @@ ${additions}`;
 }
 
 // src/agents.ts
-import { readFileSync as readFileSync10, existsSync as existsSync11 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync12 } from "fs";
 import { join as join12 } from "path";
 import { TablationClient as TablationClient2, StaleWriteError as StaleWriteError7, TablationApiError } from "@tablation/client";
 var PERSONA_NAME = {
@@ -7638,10 +7676,10 @@ var AgentsSyncError = class extends Error {
 };
 function personaDefaultPrompt(promptsDir, role) {
   const briefPath = join12(promptsDir, "personas", `lane-${role}.md`);
-  if (!existsSync11(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
+  if (!existsSync12(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
   if (SELF_CONTAINED_ROLES.has(role)) return readFileSync10(briefPath, "utf8");
   const commonPath = join12(promptsDir, "personas", "common.md");
-  if (!existsSync11(commonPath)) return readFileSync10(briefPath, "utf8");
+  if (!existsSync12(commonPath)) return readFileSync10(briefPath, "utf8");
   return `${readFileSync10(commonPath, "utf8")}${readFileSync10(briefPath, "utf8")}`;
 }
 async function resolveAgentId(route, role, opts) {
@@ -8103,7 +8141,7 @@ function parseSkillFile(path) {
 }
 function listLocalSkills(promptsDir) {
   const dir = join13(promptsDir, "skills");
-  if (!existsSync12(dir)) return [];
+  if (!existsSync13(dir)) return [];
   return readdirSync4(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join13(dir, f)));
 }
 async function syncSkills(route, opts) {
@@ -8356,17 +8394,17 @@ var AgentSpawnError = class extends AgentError {
 };
 function planAgentRun(o) {
   const briefPath = join14(o.route.promptsDir, "personas", `lane-${o.role}.md`);
-  if (!existsSync13(briefPath)) {
+  if (!existsSync14(briefPath)) {
     throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
   }
   const commonPath = join14(o.route.promptsDir, "personas", "common.md");
-  const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync13(commonPath);
+  const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync14(commonPath);
   const now = o.now ?? (() => Date.now());
   const routeLabel = routeSlug(o.route.route);
   const digestPath2 = join14(o.stateDir, `digest-${routeLabel}-${o.role}.md`);
   let digest;
   let ageSeconds;
-  if (existsSync13(digestPath2)) {
+  if (existsSync14(digestPath2)) {
     ageSeconds = Math.floor((now() - statSync5(digestPath2).mtimeMs) / 1e3);
     if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync12(digestPath2, "utf8");
   }
@@ -8869,12 +8907,12 @@ async function reattachRun(streamPath, sc, emit, o = {}) {
 }
 
 // src/run-worktree.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { dirname as dirname7, join as join16 } from "path";
 
 // src/ports.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { join as join15 } from "path";
 var run = (cmd, args) => {
   try {
@@ -8920,7 +8958,7 @@ function ticketForPort(port, s = DEFAULT_PORTS) {
 }
 function worktreeExists(parent, prefix, n) {
   for (const name of [`${prefix}${n}`, `${prefix}${String(n).padStart(3, "0")}`]) {
-    if (existsSync14(join15(parent, name, ".git"))) return true;
+    if (existsSync15(join15(parent, name, ".git"))) return true;
   }
   return false;
 }
@@ -8996,7 +9034,7 @@ function planRunWorktree(dir, cfg, t, role, opts = {}) {
   const existing = worktreeForNumber(dir, num);
   const located = locateBranchForTicket(dir, cfg, t, role);
   const baseRef = hasRemote ? `${remote}/${base}` : base;
-  if (existing && !existing.prunable && existsSync15(existing.path)) {
+  if (existing && !existing.prunable && existsSync16(existing.path)) {
     const branch = existing.branch;
     if (status(existing.path).length > 0) {
       return { action: opts.resumeInterrupted ? "resume-dirty" : "leave-dirty", path: existing.path, branch };
@@ -9061,7 +9099,7 @@ function worktreeHoldsUnpushed(path, remote) {
 }
 async function finishRunWorktree(dir, cfg, branch) {
   const wt = worktrees(dir).find((w) => w.branch === branch && !w.prunable && w.path !== dir);
-  if (!wt || !existsSync15(wt.path)) return { kind: "none" };
+  if (!wt || !existsSync16(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)) {
@@ -9073,7 +9111,7 @@ async function finishRunWorktree(dir, cfg, branch) {
     if (pids.length) await killGently(pids);
   }
   gitOk(dir, ["worktree", "remove", wt.path]);
-  return existsSync15(wt.path) ? { kind: "kept-dirty", path: wt.path } : { kind: "removed", path: wt.path };
+  return existsSync16(wt.path) ? { kind: "kept-dirty", path: wt.path } : { kind: "removed", path: wt.path };
 }
 
 // src/handoff-guard.ts
@@ -9333,12 +9371,12 @@ async function guardRunStrays(route, ship, tracker, role, workingId, since2, log
 
 // src/connect-wizard.ts
 import { delimiter, dirname as dirname8, join as join17 } from "path";
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync16, mkdirSync as mkdirSync7, writeFileSync as writeFileSync9 } from "fs";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync17, mkdirSync as mkdirSync7, writeFileSync as writeFileSync9 } from "fs";
 import { stringify } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
 function shouldRunWizard(opts) {
   if (!opts.isTTY) return false;
-  const exists = opts.configExists ?? existsSync16;
+  const exists = opts.configExists ?? existsSync17;
   return !configSearchPath(opts.crewHome).some((p) => exists(p));
 }
 function firstRunConfigPath() {
@@ -9450,7 +9488,7 @@ Wrote ${o.configPath}.
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, existsSync as existsSync17, copyFileSync, mkdirSync as mkdirSync8, mkdtempSync, rmSync as rmSync7 } from "fs";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, existsSync as existsSync18, copyFileSync, mkdirSync as mkdirSync8, mkdtempSync, rmSync as rmSync7 } from "fs";
 import { dirname as dirname9, join as join18 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 
@@ -10141,7 +10179,7 @@ async function bump(o, size) {
   }
   const files = o.repo.release.versionFiles.map((f) => join18(o.cwd, f));
   const first = files[0];
-  if (!existsSync17(first)) {
+  if (!existsSync18(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
     return null;
   }
@@ -10177,7 +10215,7 @@ function writeChangelog(o, version, entries) {
     o.emit.emit(`would prepend ${entries.length} entr(ies) to ${file}`);
     return;
   }
-  const existing = existsSync17(path) ? readFileSync13(path, "utf8") : "# Changelog\n";
+  const existing = existsSync18(path) ? readFileSync13(path, "utf8") : "# Changelog\n";
   writeFileSync10(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
@@ -10283,7 +10321,7 @@ function openReleaseCheckout(o) {
   }
   for (const f of o.repo.worktrees.copy) {
     const src = join18(o.cwd, f);
-    if (!existsSync17(src)) continue;
+    if (!existsSync18(src)) continue;
     mkdirSync8(dirname9(join18(dir, f)), { recursive: true });
     copyFileSync(src, join18(dir, f));
   }
@@ -10868,7 +10906,7 @@ function missingReleaserWarning(repo, release, ships, now = Date.now()) {
 }
 
 // src/watch.ts
-import { watch as watchFile, existsSync as existsSync18, statSync as statSync6, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
+import { watch as watchFile, existsSync as existsSync19, 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`;
@@ -10969,7 +11007,7 @@ function renderHeaders(states, now = Date.now()) {
   return states.map((s) => renderHeader(s, now)).join("");
 }
 function readFrom(file, from) {
-  if (!existsSync18(file)) return { events: [], offset: from };
+  if (!existsSync19(file)) return { events: [], offset: from };
   const size = statSync6(file).size;
   if (size < from) return readFrom(file, 0);
   if (size === from) return { events: [], offset: from };
@@ -12182,7 +12220,7 @@ function schedulerInstalled(plan, exists, crontab) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync19, readFileSync as readFileSync14, readdirSync as readdirSync5 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync14, readdirSync as readdirSync5 } from "fs";
 import { basename as basename8, dirname as dirname11, join as join19, resolve as resolve4 } from "path";
 function planWorktreeSweep(target, tickets, contract) {
   const terminal = new Set(contract.statuses.resolved.filter((s) => s !== contract.statuses.verified));
@@ -12261,16 +12299,31 @@ function orphanedWorktreeDirs(target, tickets, contract) {
   );
   return siblingWorktreeDirs(target).filter((d) => deployed.has(d.number)).map((d) => d.path);
 }
-function warnOrphanedWorktreeDirs(paths, log) {
+function warnOrphanedWorktreeDirs(paths, log, held) {
   for (const p of paths) {
-    log.warn(`orphaned directory ${p}: its ticket is deployed but it is not a registered worktree; the sweep will not delete it \u2014 remove it by hand`, { step: "worktree" });
+    const number = DIR_NUMBER_SUFFIXED.exec(basename8(p))?.[1];
+    const when = held && number ? noteHeldWorktree(held.state, { repo: held.repo, path: p, ticket: number, status: "deployed", reason: "orphaned directory" }) : "first";
+    if (when) {
+      log.warn(`orphaned directory ${p}: its ticket is deployed but it is not a registered worktree; the sweep will not delete it \u2014 remove it by hand`, { step: "worktree" });
+    }
   }
 }
-async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin", base) {
+async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin", base, held) {
+  const refused = [];
+  const refuse = (a, reason, detail) => {
+    refused.push(a.path);
+    const when = held ? noteHeldWorktree(held.state, { repo: held.repo, path: a.path, ticket: a.ticket.issue_id, status: a.ticket.status, reason }) : "first";
+    if (when) {
+      log.warn(
+        `not removing worktree ${a.path} for ${a.ticket.issue_id} (${a.ticket.status}): ${detail}`,
+        { ticket: a.ticket.issue_id, step: "worktree" }
+      );
+    }
+  };
   let removed = 0;
   let keptBranches = 0;
   for (const a of actions) {
-    if (!dryRun && base && !a.keepBranch && existsSync19(a.path) && isHandBackMerge(a.path, base)) {
+    if (!dryRun && base && !a.keepBranch && existsSync20(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`,
@@ -12278,25 +12331,19 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         );
       }
     }
-    if (!dryRun && existsSync19(a.path)) {
+    if (!dryRun && existsSync20(a.path)) {
       let dirty = false;
       try {
         dirty = status(a.path).length > 0;
       } catch {
       }
       if (dirty) {
-        log.warn(
-          `not removing worktree ${a.path} for ${a.ticket.issue_id} (${a.ticket.status}): it has uncommitted changes`,
-          { ticket: a.ticket.issue_id, step: "worktree" }
-        );
+        refuse(a, "uncommitted changes", "it has uncommitted changes");
         continue;
       }
     }
-    if (!dryRun && a.requirePushed && a.branch && existsSync19(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" }
-      );
+    if (!dryRun && a.requirePushed && a.branch && existsSync20(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
+      refuse(a, "unpushed commits", `${a.branch} has commits that are not on ${remote}`);
       continue;
     }
     const n = Number(a.ticket.issue_id.replace(/^\D+/, ""));
@@ -12320,7 +12367,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
     try {
       git(cwd, ["worktree", "remove", "--force", a.path]);
     } catch (e) {
-      log.warn(`could not remove worktree ${a.path} for ${a.ticket.issue_id}: ${e.message}`, { ticket: a.ticket.issue_id, step: "worktree" });
+      refuse(a, "removal failed", `could not remove it: ${e.message}`);
       continue;
     }
     if (!a.keepBranch && a.branch) {
@@ -12336,7 +12383,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
     removed++;
   }
   if (!dryRun && actions.length) gitOk(cwd, ["worktree", "prune"]);
-  return { removed, keptBranches };
+  return { removed, keptBranches, refused };
 }
 function isHandBackMerge(path, base) {
   if (gitOk(path, ["rev-parse", "-q", "--verify", "MERGE_HEAD"]) === null) return false;
@@ -12449,12 +12496,12 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync20, readdirSync as readdirSync6, rmSync as rmSync8, statSync as statSync7 } from "fs";
+import { existsSync as existsSync21, readdirSync as readdirSync6, rmSync as rmSync8, statSync as statSync7 } from "fs";
 import { join as join20 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
   const dir = join20(stateDir, "streams");
-  if (!existsSync20(dir)) return [];
+  if (!existsSync21(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
   return readdirSync6(dir).map((name) => join20(dir, name)).filter((path) => {
     try {
@@ -12482,7 +12529,7 @@ function applyStreamSweep(paths, dryRun, log) {
   return removed;
 }
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
-  if (!existsSync20(stateDir)) return [];
+  if (!existsSync21(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
   return readdirSync6(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join20(stateDir, name)).filter((path) => {
     try {
@@ -12494,13 +12541,13 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync20, existsSync as existsSync26, mkdirSync as mkdirSync13, writeFileSync as writeFileSync14, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync2, statSync as statSync9 } from "fs";
+import { readFileSync as readFileSync20, existsSync as existsSync27, 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";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync21, mkdirSync as mkdirSync9, readFileSync as readFileSync15, chmodSync } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync9, readFileSync as readFileSync15, chmodSync } from "fs";
 import { dirname as dirname12, join as join21 } from "path";
 var SshKeyError = class extends Error {
 };
@@ -12510,7 +12557,7 @@ function shipSshKeyPathFor(stateDir) {
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync21(privateKeyPath)) {
+  if (!existsSync22(privateKeyPath)) {
     mkdirSync9(dirname12(privateKeyPath), { recursive: true });
     try {
       execFileSync3("ssh-keygen", [
@@ -12531,7 +12578,7 @@ function ensureShipSshKeypair(stateDir) {
     }
     chmodSync(privateKeyPath, 384);
   }
-  if (!existsSync21(publicKeyPath)) {
+  if (!existsSync22(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
   const publicKey = readFileSync15(publicKeyPath, "utf8").trim();
@@ -12750,7 +12797,7 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync22, mkdirSync as mkdirSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync11, unlinkSync as unlinkSync3, readdirSync as readdirSync7 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync11, unlinkSync as unlinkSync3, readdirSync as readdirSync7 } from "fs";
 import { randomInt } from "crypto";
 import { join as join22 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
@@ -12823,7 +12870,7 @@ function tunnelStatePath(stateDir, workspaceId) {
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
-  if (!existsSync22(path)) return void 0;
+  if (!existsSync23(path)) return void 0;
   try {
     return JSON.parse(readFileSync16(path, "utf8"));
   } catch {
@@ -12931,7 +12978,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
 }
 function readAllPersistedWorkspaceIds(stateDir) {
   const dir = join22(stateDir, "passengers");
-  if (!existsSync22(dir)) return [];
+  if (!existsSync23(dir)) return [];
   return readdirSync7(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
@@ -13052,7 +13099,7 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn4 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync23, mkdirSync as mkdirSync11, readFileSync as readFileSync17, writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, readdirSync as readdirSync8 } from "fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync11, readFileSync as readFileSync17, writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, readdirSync as readdirSync8 } from "fs";
 import { join as join23 } from "path";
 
 // src/secret-compare.ts
@@ -13146,7 +13193,7 @@ function syncDaemonStatePath(stateDir, workspaceId) {
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
-  if (!existsSync23(path)) return void 0;
+  if (!existsSync24(path)) return void 0;
   try {
     return JSON.parse(readFileSync17(path, "utf8"));
   } catch {
@@ -13177,7 +13224,7 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
   const dir = join23(stateDir, "passengers");
-  if (!existsSync23(dir)) return [];
+  if (!existsSync24(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync8(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
@@ -13234,11 +13281,11 @@ function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync12, readFileSync as readFileSync19, readdirSync as readdirSync10, rmSync as rmSync9, statSync as statSync8, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync12, readFileSync as readFileSync19, readdirSync as readdirSync10, rmSync as rmSync9, statSync as statSync8, writeFileSync as writeFileSync13 } from "fs";
 import { join as join25 } from "path";
 
 // src/interrupted.ts
-import { existsSync as existsSync24, readdirSync as readdirSync9, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync9, readFileSync as readFileSync18 } from "fs";
 import { join as join24 } from "path";
 var INTERRUPTED_MARKER = "<!-- crew:interrupted -->";
 function interruptedComment(b) {
@@ -13257,7 +13304,7 @@ var pidAlive = (pid) => {
 };
 function runFinished(streamPath) {
   const path = `${streamPath}.meta.json`;
-  if (!existsSync24(path)) return false;
+  if (!existsSync25(path)) return false;
   try {
     return JSON.parse(readFileSync18(path, "utf8")).running !== true;
   } catch {
@@ -13266,7 +13313,7 @@ function runFinished(streamPath) {
 }
 function orphanedStreams(o) {
   const dir = join24(o.stateDir, "streams");
-  if (!existsSync24(dir)) return [];
+  if (!existsSync25(dir)) return [];
   const ownerAlive = o.isOwnerAlive ?? pidAlive;
   const out = [];
   for (const name of readdirSync9(dir)) {
@@ -13380,7 +13427,7 @@ function computeTreeSignature(paths) {
 }
 function makeStaleChecker(paths, opts = {}) {
   const initial = computeTreeSignature(paths);
-  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync25(opts.reloadSentinel);
+  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync26(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
   return join25(stateDir, "reload-requested");
@@ -14271,7 +14318,7 @@ if (command === "passenger-sync-daemon") {
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
       const staleTimer = join26(homedir8(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync26(staleTimer)) {
+      if (existsSync27(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -14297,7 +14344,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 (!existsSync26(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync27(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}`));
     }
@@ -14315,7 +14362,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) => existsSync26(p);
+    const unitExists = (p) => existsSync27(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 });
@@ -14412,6 +14459,7 @@ ${changed2.map((c) => `  - ${c}
   }
   async function sweepClosedTickets(c, target, branch, tracker, dryRun2, remit, idle = false) {
     try {
+      if (!dryRun2) reconcileHeldWorktrees(state, target.name, remit);
       if (idle && !sweepCandidatesExist(target.dir, branch.base)) return;
       const truncated = (limit) => remit.warn(`ticket lookup for the sweep hit its ${limit}-row limit; some tickets may be missed`, { step: "worktree" });
       const nums = /* @__PURE__ */ new Set([
@@ -14421,12 +14469,14 @@ ${changed2.map((c) => `  - ${c}
       ]);
       const scoped = ticketsByRepo(c, await tracker.ticketsByNumbers([...nums], truncated)).byRepo.get(target.name) ?? [];
       const actions = planWorktreeSweep(target, scoped, tracker.contract);
-      warnOrphanedWorktreeDirs(orphanedWorktreeDirs(target, scoped, tracker.contract), remit);
+      const orphanDirs = orphanedWorktreeDirs(target, scoped, tracker.contract);
+      warnOrphanedWorktreeDirs(orphanDirs, remit, dryRun2 ? void 0 : { state, repo: target.name });
       if (actions.length) {
         remit.enter("worktree");
-        const r = await applyWorktreeSweep(target.dir, actions, dryRun2, remit, branch.remote, branch.base);
+        const r = await applyWorktreeSweep(target.dir, actions, dryRun2, remit, branch.remote, branch.base, { state, repo: target.name });
         remit.emit(`swept ${r.removed} worktree(s), kept ${r.keptBranches} branch(es)`, { step: "worktree" });
-      }
+        if (!dryRun2) reconcileHeldWorktrees(state, target.name, remit, /* @__PURE__ */ new Set([...r.refused, ...orphanDirs]));
+      } else if (!dryRun2) reconcileHeldWorktrees(state, target.name, remit, new Set(orphanDirs));
       const orphaned = planLocalBranchCleanup(target.dir, branch.base, scoped, tracker.contract);
       if (orphaned.length) applyLocalBranchCleanup(target.dir, orphaned, dryRun2, remit);
       const stale = planRemoteBranchCleanup(target.dir, branch.remote, branch.base, scoped, tracker.contract);
@@ -15484,7 +15534,7 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync26(resolvedPath) ? JSON.parse(readFileSync20(resolvedPath, "utf8")) : {};
+        const raw = existsSync27(resolvedPath) ? JSON.parse(readFileSync20(resolvedPath, "utf8")) : {};
         raw.agentPersonas = personaResult.agentPersonas;
         if (skillResult) raw.agentSkills = skillResult.agentSkills;
         if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
@@ -15554,7 +15604,7 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync26(resolvedPath) ? JSON.parse(readFileSync20(resolvedPath, "utf8")) : {};
+        const raw = existsSync27(resolvedPath) ? JSON.parse(readFileSync20(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
         mkdirSync13(dirOf(resolvedPath), { recursive: true });
         writeFileSync14(resolvedPath, `${JSON.stringify(raw, null, 2)}
@@ -15577,7 +15627,7 @@ ${changed2.map((c) => `  - ${c}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync26(resolvePath(p.replace(/^~(?=\/|$)/, homedir8()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync27(resolvePath(p.replace(/^~(?=\/|$)/, homedir8()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -15592,7 +15642,7 @@ ${changed2.map((c) => `  - ${c}
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       let resolvedRemotes;
-      if (existsSync26(resolvedFile)) {
+      if (existsSync27(resolvedFile)) {
         try {
           resolvedRemotes = JSON.parse(readFileSync20(resolvedFile, "utf8"));
         } catch {
@@ -15609,14 +15659,14 @@ ${changed2.map((c) => `  - ${c}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync26(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync27(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 = existsSync26(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync27(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({
@@ -15665,7 +15715,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 (existsSync26(resolvedFile)) {
+          if (existsSync27(resolvedFile)) {
             const raw = JSON.parse(readFileSync20(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
@@ -15920,7 +15970,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
         let previous;
-        const hadPreviousFile = existsSync26(resolvedPath);
+        const hadPreviousFile = existsSync27(resolvedPath);
         if (hadPreviousFile) {
           try {
             previous = JSON.parse(readFileSync20(resolvedPath, "utf8"));
@@ -16216,15 +16266,20 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           await tracker.ticketsByNumbers(remoteBranchTicketNumbers(r.dir, r.config.branch.remote, r.config.branch.base), truncated)
         ).byRepo.get(r.name) ?? [];
         const actions = planWorktreeSweep(r, wtTickets, tracker.contract);
-        warnOrphanedWorktreeDirs(orphanedWorktreeDirs(r, wtTickets, tracker.contract), emit);
+        const orphanDirs = orphanedWorktreeDirs(r, wtTickets, tracker.contract);
+        warnOrphanedWorktreeDirs(orphanDirs, emit, dryRun ? void 0 : { state, repo: r.name });
         const stale = planRemoteBranchCleanup(r.dir, r.config.branch.remote, r.config.branch.base, brTickets, tracker.contract);
         if (stale.length) {
           anything = true;
           applyRemoteBranchCleanup(r.dir, r.config.branch.remote, stale, dryRun, emit);
         }
-        if (!actions.length) continue;
+        if (!actions.length) {
+          if (!dryRun) reconcileHeldWorktrees(state, r.name, emit, new Set(orphanDirs));
+          continue;
+        }
         anything = true;
-        const res = await applyWorktreeSweep(r.dir, actions, dryRun, emit, r.config.branch.remote, r.config.branch.base);
+        const res = await applyWorktreeSweep(r.dir, actions, dryRun, emit, r.config.branch.remote, r.config.branch.base, { state, repo: r.name });
+        if (!dryRun) reconcileHeldWorktrees(state, r.name, emit, /* @__PURE__ */ new Set([...res.refused, ...orphanDirs]));
         emit.emit(
           `swept ${res.removed} worktree(s) for ${r.name}, kept ${res.keptBranches} branch(es)`,
           { step: "worktree" }
@@ -16728,6 +16783,14 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
               // Additive (CREW-1379): `unsafe` means a ship must not cut a
               // worktree or release from this base. `version` stays 1.
               baseBranch: baseHealth(r),
+              // Additive (CREW-2051): worktrees the sweep refuses to remove.
+              heldWorktrees: openShipAttention(state).filter((i) => i.kind === "worktree_held" && i.held?.repo === r.name).map((i) => ({
+                path: i.held.path,
+                ticket: i.held.ticket,
+                status: i.held.status,
+                reason: i.held.reason,
+                firstSeenAt: i.held.firstSeenAt
+              })),
               worktreePrefix: r.config.worktrees.prefix,
               // A repo with no explicit `worktrees.prefix` no longer names its
               // worktrees `<prefix><number>` (ISSUE-969) — the checkout's own
@@ -16827,7 +16890,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       );
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync26(evFile) ? statSync9(evFile).size : 0;
+        const evSize = existsSync27(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"

package/package.json

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