@tablation/crew 0.53.2 → 0.53.4

package/dist/cli.js

@@ -32,7 +32,7 @@ function doctorBaseReport(r, base, health) {
 }
 
 // src/cli.ts
-import { resolve as resolve4, dirname as dirname12, join as join25, basename as basename9 } from "path";
+import { resolve as resolve5, dirname as dirname13, join as join26, basename as basename9 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir8 } from "os";
 import { spawnSync as spawnSync6 } from "child_process";
@@ -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");
   }
@@ -8767,7 +8805,7 @@ function spawnAgent(plan, emit) {
   for (const w of plan.warnings ?? []) emit.warn(w, { step: "agent", role: plan.role });
   const eventsSink = openSink(plan.eventsPath);
   const id = identityOf(plan, adapter.harness);
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let streamFd;
     try {
       mkdirSync6(dirname6(plan.streamPath), { recursive: true });
@@ -8826,7 +8864,7 @@ function spawnAgent(plan, emit) {
       await endSink(eventsSink);
       if (spawnFailed) return;
       const { ms: ms2 } = await finishRun(id, obs, emit, startedAt, { code: code ?? 1 }, plan.agentLog?.apiKey);
-      resolve5({ code: code ?? 1, ms: ms2 });
+      resolve6({ code: code ?? 1, ms: ms2 });
     });
     child.stdin?.on("error", (err) => {
       emit.warn(`agent closed stdin before the prompt was delivered: ${err.message}`, { step: "agent" });
@@ -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,17 +12220,15 @@ function schedulerInstalled(plan, exists, crontab) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync19 } from "fs";
-import { basename as basename8 } from "path";
+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));
   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(basename8(w.path));
-    if (!m) continue;
-    const ticket = byNumber.get(m[1]);
+  for (const w of worktrees(target.dir).slice(1)) {
+    const ticket = ticketForWorktree(w, byNumber, contract);
     if (!ticket) continue;
     const isVerified = ticket.status === verified;
     if (!isVerified && !terminal.has(ticket.status)) continue;
@@ -12206,37 +12242,108 @@ function planWorktreeSweep(target, tickets, contract) {
   }
   return actions;
 }
+var DIR_NUMBER = /(?:^|-)(\d+)$/;
+var DIR_NUMBER_SUFFIXED = /(?:^|-)(\d+)(?:-[a-z0-9]{1,8})?$/;
+var BRANCH_STEM = /^(?:.*\/)?([^/]+?-\d+)(?:-.*)?$/;
+function ticketForWorktree(w, byNumber, contract) {
+  if (w.branch) {
+    const stem = BRANCH_STEM.exec(w.branch)?.[1];
+    const num = stem && /-(\d+)$/.exec(stem)?.[1];
+    const t = num ? byNumber.get(num) : void 0;
+    if (t && ticketStems(t).has(stem)) return t;
+  }
+  const dir = basename8(w.path);
+  const m = DIR_NUMBER.exec(dir);
+  if (m && byNumber.has(m[1])) return byNumber.get(m[1]);
+  if (!w.branch) {
+    const t = byNumber.get(DIR_NUMBER_SUFFIXED.exec(dir)?.[1] ?? "");
+    if (t && t.status === contract.statuses.deployed) return t;
+  }
+  return void 0;
+}
 function worktreeTicketNumbers(target) {
   const nums = /* @__PURE__ */ new Set();
-  for (const w of worktrees(target.dir)) {
-    const m = /(?:^|-)(\d+)$/.exec(basename8(w.path));
+  for (const w of worktrees(target.dir).slice(1)) {
+    if (w.branch) {
+      const n = /-(\d+)$/.exec(BRANCH_STEM.exec(w.branch)?.[1] ?? "")?.[1];
+      if (n) nums.add(n);
+    }
+    const m = DIR_NUMBER_SUFFIXED.exec(basename8(w.path));
     if (m) nums.add(m[1]);
   }
+  for (const d of siblingWorktreeDirs(target)) nums.add(d.number);
   return [...nums];
 }
-async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin") {
+function siblingWorktreeDirs(target) {
+  const parent = dirname11(target.dir.replace(/[/\\]+$/, ""));
+  const stem = `${basename8(target.dir.replace(/[/\\]+$/, ""))}-`;
+  const registered = new Set(worktrees(target.dir).map((w) => resolve4(w.path)));
+  let names;
+  try {
+    names = readdirSync5(parent);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (!name.startsWith(stem)) continue;
+    const m = DIR_NUMBER_SUFFIXED.exec(name);
+    const path = join19(parent, name);
+    if (m && !registered.has(resolve4(path))) out.push({ path, number: m[1] });
+  }
+  return out;
+}
+function orphanedWorktreeDirs(target, tickets, contract) {
+  const deployed = new Set(
+    tickets.filter((t) => t.status === contract.statuses.deployed).map((t) => t.issue_id.replace(/^\D+/, ""))
+  );
+  return siblingWorktreeDirs(target).filter((d) => deployed.has(d.number)).map((d) => d.path);
+}
+function warnOrphanedWorktreeDirs(paths, log, held) {
+  for (const p of paths) {
+    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, 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 && existsSync19(a.path)) {
+    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`,
+          { ticket: a.ticket.issue_id, step: "worktree" }
+        );
+      }
+    }
+    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+/, ""));
@@ -12257,7 +12364,12 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin")
       );
       continue;
     }
-    gitOk(cwd, ["worktree", "remove", "--force", a.path]);
+    try {
+      git(cwd, ["worktree", "remove", "--force", a.path]);
+    } catch (e) {
+      refuse(a, "removal failed", `could not remove it: ${e.message}`);
+      continue;
+    }
     if (!a.keepBranch && a.branch) {
       gitOk(cwd, ["branch", "-D", a.branch]);
       if (remoteConfigured(cwd, remote) && !deleteRemoteBranch(cwd, remote, a.branch)) {
@@ -12270,7 +12382,21 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin")
     );
     removed++;
   }
-  return { removed, keptBranches };
+  if (!dryRun && actions.length) gitOk(cwd, ["worktree", "prune"]);
+  return { removed, keptBranches, refused };
+}
+function isHandBackMerge(path, base) {
+  if (gitOk(path, ["rev-parse", "-q", "--verify", "MERGE_HEAD"]) === null) return false;
+  const msgPath = gitOk(path, ["rev-parse", "--git-path", "MERGE_MSG"]);
+  if (!msgPath) return false;
+  let first;
+  try {
+    first = readFileSync14(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
+  } catch {
+    return false;
+  }
+  const escaped = base.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^Merge (?:remote-tracking )?branch '(?:[^']+/)?${escaped}'`).test(first);
 }
 function remoteBranchTicketNumbers(cwd, remote, base) {
   if (!remoteConfigured(cwd, remote)) return [];
@@ -12297,13 +12423,18 @@ function deployedBranchStems(tickets, contract) {
   const stems = /* @__PURE__ */ new Set();
   for (const t of tickets) {
     if (t.status !== contract.statuses.deployed) continue;
-    const num = t.issue_id.replace(/^\D+/, "");
-    const unpadded = String(Number.parseInt(num, 10));
-    const prefixes = ["issue", t.project_issue_prefix?.toLowerCase()].filter((p) => !!p);
-    for (const p of prefixes) {
-      stems.add(`${p}-${num}`);
-      stems.add(`${p}-${unpadded}`);
-    }
+    for (const st of ticketStems(t)) stems.add(st);
+  }
+  return stems;
+}
+function ticketStems(t) {
+  const stems = /* @__PURE__ */ new Set();
+  const num = t.issue_id.replace(/^\D+/, "");
+  const unpadded = String(Number.parseInt(num, 10));
+  const prefixes = ["issue", t.project_issue_prefix?.toLowerCase()].filter((p) => !!p);
+  for (const p of prefixes) {
+    stems.add(`${p}-${num}`);
+    stems.add(`${p}-${unpadded}`);
   }
   return stems;
 }
@@ -12314,7 +12445,8 @@ function isTicketBranch(name, base, stems) {
 }
 function sweepCandidatesExist(cwd, base) {
   const linked = worktrees(cwd).slice(1);
-  if (linked.some((w) => /(?:^|-)\d+$/.test(basename8(w.path)))) return true;
+  if (linked.some((w) => DIR_NUMBER_SUFFIXED.test(basename8(w.path)) || w.branch && BRANCH_STEM.test(w.branch))) return true;
+  if (siblingWorktreeDirs({ name: "", dir: cwd }).length) return true;
   return localBranches(cwd).some((b) => b !== base && /-\d+(?:-.*)?$/.test(b));
 }
 function localBranchTicketNumbers(cwd, base) {
@@ -12364,14 +12496,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync20, readdirSync as readdirSync5, rmSync as rmSync8, statSync as statSync7 } from "fs";
-import { join as join19 } from "path";
+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 = join19(stateDir, "streams");
-  if (!existsSync20(dir)) return [];
+  const dir = join20(stateDir, "streams");
+  if (!existsSync21(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync5(dir).map((name) => join19(dir, name)).filter((path) => {
+  return readdirSync6(dir).map((name) => join20(dir, name)).filter((path) => {
     try {
       return statSync7(path).mtimeMs < cutoff;
     } catch {
@@ -12397,9 +12529,9 @@ 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 readdirSync5(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join19(stateDir, name)).filter((path) => {
+  return readdirSync6(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join20(stateDir, name)).filter((path) => {
     try {
       return statSync7(path).mtimeMs < cutoff;
     } catch {
@@ -12409,24 +12541,24 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync19, 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 readFileSync14, chmodSync } from "fs";
-import { dirname as dirname11, join as join20 } from "path";
+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 {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join20(stateDir, "ssh", "id_ed25519");
+  return join21(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync21(privateKeyPath)) {
-    mkdirSync9(dirname11(privateKeyPath), { recursive: true });
+  if (!existsSync22(privateKeyPath)) {
+    mkdirSync9(dirname12(privateKeyPath), { recursive: true });
     try {
       execFileSync3("ssh-keygen", [
         "-t",
@@ -12446,10 +12578,10 @@ 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 = readFileSync14(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync15(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -12665,9 +12797,9 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync22, mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync11, unlinkSync as unlinkSync3, readdirSync as readdirSync6 } 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 join21 } from "path";
+import { join as join22 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn3(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -12734,20 +12866,20 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join21(stateDir, "passengers", `${workspaceId}.json`);
+  return join22(stateDir, "passengers", `${workspaceId}.json`);
 }
 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(readFileSync15(path, "utf8"));
+    return JSON.parse(readFileSync16(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync10(join21(stateDir, "passengers"), { recursive: true });
+  mkdirSync10(join22(stateDir, "passengers"), { recursive: true });
   writeFileSync11(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -12845,9 +12977,9 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join21(stateDir, "passengers");
-  if (!existsSync22(dir)) return [];
-  return readdirSync6(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
+  const dir = join22(stateDir, "passengers");
+  if (!existsSync23(dir)) return [];
+  return readdirSync7(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
 // src/mcp-endpoint-registry.ts
@@ -12967,8 +13099,8 @@ 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 readFileSync16, writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, readdirSync as readdirSync7 } from "fs";
-import { join as join22 } from "path";
+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
 import { timingSafeEqual } from "crypto";
@@ -13057,20 +13189,20 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join22(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join23(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 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(readFileSync16(path, "utf8"));
+    return JSON.parse(readFileSync17(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync11(join22(stateDir, "passengers"), { recursive: true });
+  mkdirSync11(join23(stateDir, "passengers"), { recursive: true });
   writeFileSync12(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -13091,10 +13223,10 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join22(stateDir, "passengers");
-  if (!existsSync23(dir)) return [];
+  const dir = join23(stateDir, "passengers");
+  if (!existsSync24(dir)) return [];
   const suffix = "-sync.json";
-  return readdirSync7(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
+  return readdirSync8(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
 function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
   const alive = deps.isPidAlive ?? isPidAlive;
@@ -13149,12 +13281,12 @@ function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync12, readFileSync as readFileSync18, readdirSync as readdirSync9, rmSync as rmSync9, statSync as statSync8, writeFileSync as writeFileSync13 } from "fs";
-import { join as join24 } from "path";
+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 readdirSync8, readFileSync as readFileSync17 } from "fs";
-import { join as join23 } from "path";
+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) {
   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.";
@@ -13172,21 +13304,21 @@ 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(readFileSync17(path, "utf8")).running !== true;
+    return JSON.parse(readFileSync18(path, "utf8")).running !== true;
   } catch {
     return true;
   }
 }
 function orphanedStreams(o) {
-  const dir = join23(o.stateDir, "streams");
-  if (!existsSync24(dir)) return [];
+  const dir = join24(o.stateDir, "streams");
+  if (!existsSync25(dir)) return [];
   const ownerAlive = o.isOwnerAlive ?? pidAlive;
   const out = [];
-  for (const name of readdirSync8(dir)) {
+  for (const name of readdirSync9(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join23(dir, name);
+    const streamPath = join24(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || sidecar.route !== o.routeLabel) continue;
@@ -13239,7 +13371,7 @@ async function reconcileRuns(o) {
 // src/daemon.ts
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
-var defaultSleep = (ms2) => new Promise((resolve5) => setTimeout(resolve5, ms2));
+var defaultSleep = (ms2) => new Promise((resolve6) => setTimeout(resolve6, ms2));
 async function runDaemonLoop(o) {
   const floor = o.floorMs ?? DEFAULT_FLOOR_MS;
   const ceiling = o.ceilingMs ?? DEFAULT_CEILING_MS;
@@ -13285,8 +13417,8 @@ function latestMtime(path) {
   if (stat.isFile()) return stat.mtimeMs;
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
-  for (const entry of readdirSync9(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join24(path, entry.name)));
+  for (const entry of readdirSync10(path, { withFileTypes: true })) {
+    latest = Math.max(latest, latestMtime(join25(path, entry.name)));
   }
   return latest;
 }
@@ -13295,13 +13427,13 @@ 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 join24(stateDir, "reload-requested");
+  return join25(stateDir, "reload-requested");
 }
 function daemonStampFor(stateDir) {
-  return join24(stateDir, "daemon.started");
+  return join25(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
   mkdirSync12(stateDir, { recursive: true });
@@ -13311,7 +13443,7 @@ function noteDaemonStarted(stateDir, now = Date.now()) {
 }
 function readDaemonStarted(stateDir) {
   try {
-    const v = JSON.parse(readFileSync18(daemonStampFor(stateDir), "utf8")).startedAt;
+    const v = JSON.parse(readFileSync19(daemonStampFor(stateDir), "utf8")).startedAt;
     return typeof v === "number" ? v : null;
   } catch {
     return null;
@@ -13667,7 +13799,7 @@ async function buildEnvironment(route, ship, ticket) {
 }
 
 // src/cli.ts
-var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname12(process.execPath) : resolve4(dirname12(fileURLToPath(import.meta.url)), "..");
+var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname13(process.execPath) : resolve5(dirname13(fileURLToPath(import.meta.url)), "..");
 var RELEASE_LOCK_TTL_MS = 20 * 60 * 1e3;
 var CYCLE_SECONDS2 = 120;
 var STALE_CYCLES = 3;
@@ -14185,8 +14317,8 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join25(homedir8(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync26(staleTimer)) {
+      const staleTimer = join26(homedir8(), ".config", "systemd", "user", `${label}.timer`);
+      if (existsSync27(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -14212,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}`));
     }
@@ -14230,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 });
@@ -14247,7 +14379,7 @@ if (command === "passenger-sync-daemon") {
       for (const a of plan.actions) {
         if (a.kind === "enable") {
           if (prompter && !await prompter.confirm(`Route ${a.route} passes every check \u2014 set enabled: true in ${cfg.configFile}?`, false)) continue;
-          writeFileSync14(cfg.configFile, planEnable(readFileSync19(cfg.configFile, "utf8"), a.route));
+          writeFileSync14(cfg.configFile, planEnable(readFileSync20(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -14327,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([
@@ -14336,11 +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);
+      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);
+        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);
@@ -15223,7 +15359,7 @@ ${changed2.map((c) => `  - ${c}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join25(CREW_HOME, "src"), join25(CREW_HOME, "dist"), join25(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join26(CREW_HOME, "src"), join26(CREW_HOME, "dist"), join26(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -15398,7 +15534,7 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync26(resolvedPath) ? JSON.parse(readFileSync19(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;
@@ -15468,7 +15604,7 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync26(resolvedPath) ? JSON.parse(readFileSync19(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)}
@@ -15484,14 +15620,14 @@ ${changed2.map((c) => `  - ${c}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list") usage2();
-      const configText = readFileSync19(cfg.configFile, "utf8");
+      const configText = readFileSync20(cfg.configFile, "utf8");
       let routeName = positional[2];
       let addPath = ".";
       let addName;
       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;
@@ -15506,15 +15642,15 @@ ${changed2.map((c) => `  - ${c}
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       let resolvedRemotes;
-      if (existsSync26(resolvedFile)) {
+      if (existsSync27(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync19(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync20(resolvedFile, "utf8"));
         } catch {
         }
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text = configText;
-      const base = dirname12(cfg.configFile);
+      const base = dirname13(cfg.configFile);
       try {
         if (sub === "list") {
           const repos = configuredRepos(text, routeName, base);
@@ -15523,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({
@@ -15579,8 +15715,8 @@ ${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)) {
-            const raw = JSON.parse(readFileSync19(resolvedFile, "utf8"));
+          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) };
             writeFileSync14(resolvedFile, `${JSON.stringify(raw, null, 2)}
@@ -15834,10 +15970,10 @@ 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(readFileSync19(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync20(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -15900,7 +16036,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.stderr.write(`(dry run) would write resolved ids to ${resolvedPath}
 `);
         } else {
-          mkdirSync13(dirname12(resolvedPath), { recursive: true });
+          mkdirSync13(dirname13(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
           writeFileSync14(tmpPath, `${JSON.stringify(resolved, null, 2)}
@@ -15928,7 +16064,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             process.stderr.write(`(dry run) would write the minted API key to ${apiKeyFile}
 `);
           } else {
-            mkdirSync13(dirname12(apiKeyFile), { recursive: true });
+            mkdirSync13(dirname13(apiKeyFile), { recursive: true });
             writeFileSync14(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
@@ -15938,7 +16074,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 ? join25(DEFAULT_REPOS_BASE_PATH, found.workspaceSlug) : void 0);
+        const routeDir = value("dir") ?? (writeFirstRun ? join26(DEFAULT_REPOS_BASE_PATH, found.workspaceSlug) : void 0);
         const routeBlock = renderConnection(
           found,
           route2,
@@ -16130,14 +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);
+        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);
+        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" }
@@ -16530,7 +16672,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
     }
     case "log": {
       try {
-        const text = readFileSync19(cfg.ship.logFile, "utf8").split("\n");
+        const text = readFileSync20(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -16641,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
@@ -16740,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"
@@ -16751,7 +16901,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
         const unitPlan = planInstall(cfg.ship, CREW_HOME, host, detectSystemd(), "run");
         const abandons = unitAbandonsAgents(unitPlan, (p) => {
           try {
-            return readFileSync19(p, "utf8");
+            return readFileSync20(p, "utf8");
           } catch {
             return null;
           }

package/package.json

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