@tablation/crew 0.53.2 → 0.53.3

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";
@@ -8767,7 +8767,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 +8826,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" });
@@ -12182,17 +12182,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 existsSync19, 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,18 +12204,80 @@ 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) {
+  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" });
+  }
+}
+async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin", base) {
   let removed = 0;
   let keptBranches = 0;
   for (const a of actions) {
+    if (!dryRun && base && !a.keepBranch && existsSync19(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 && existsSync19(a.path)) {
       let dirty = false;
       try {
@@ -12257,7 +12317,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) {
+      log.warn(`could not remove worktree ${a.path} for ${a.ticket.issue_id}: ${e.message}`, { ticket: a.ticket.issue_id, step: "worktree" });
+      continue;
+    }
     if (!a.keepBranch && a.branch) {
       gitOk(cwd, ["branch", "-D", a.branch]);
       if (remoteConfigured(cwd, remote) && !deleteRemoteBranch(cwd, remote, a.branch)) {
@@ -12270,8 +12335,22 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin")
     );
     removed++;
   }
+  if (!dryRun && actions.length) gitOk(cwd, ["worktree", "prune"]);
   return { removed, keptBranches };
 }
+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 [];
   const prefix = `refs/remotes/${remote}/`;
@@ -12297,13 +12376,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 +12398,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 +12449,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 existsSync20, 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");
+  const dir = join20(stateDir, "streams");
   if (!existsSync20(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 {
@@ -12399,7 +12484,7 @@ function applyStreamSweep(paths, dryRun, log) {
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
   if (!existsSync20(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 +12494,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 existsSync26, 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 existsSync21, 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 });
+    mkdirSync9(dirname12(privateKeyPath), { recursive: true });
     try {
       execFileSync3("ssh-keygen", [
         "-t",
@@ -12449,7 +12534,7 @@ function ensureShipSshKeypair(stateDir) {
   if (!existsSync21(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 +12750,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 existsSync22, 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 +12819,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;
   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 +12930,9 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join21(stateDir, "passengers");
+  const dir = join22(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));
+  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 +13052,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 existsSync23, 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 +13142,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;
   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 +13176,10 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join22(stateDir, "passengers");
+  const dir = join23(stateDir, "passengers");
   if (!existsSync23(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 +13234,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 existsSync25, 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 existsSync24, 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.";
@@ -13174,19 +13259,19 @@ function runFinished(streamPath) {
   const path = `${streamPath}.meta.json`;
   if (!existsSync24(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");
+  const dir = join24(o.stateDir, "streams");
   if (!existsSync24(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 +13324,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 +13370,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;
 }
@@ -13298,10 +13383,10 @@ function makeStaleChecker(paths, opts = {}) {
   return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync25(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 +13396,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 +13752,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,7 +14270,7 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join25(homedir8(), ".config", "systemd", "user", `${label}.timer`);
+      const staleTimer = join26(homedir8(), ".config", "systemd", "user", `${label}.timer`);
       if (existsSync26(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
@@ -14247,7 +14332,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 {
@@ -14336,9 +14421,10 @@ ${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);
       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);
         remit.emit(`swept ${r.removed} worktree(s), kept ${r.keptBranches} branch(es)`, { step: "worktree" });
       }
       const orphaned = planLocalBranchCleanup(target.dir, branch.base, scoped, tracker.contract);
@@ -15223,7 +15309,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 +15484,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 = existsSync26(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 +15554,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 = existsSync26(resolvedPath) ? JSON.parse(readFileSync20(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
         mkdirSync13(dirOf(resolvedPath), { recursive: true });
         writeFileSync14(resolvedPath, `${JSON.stringify(raw, null, 2)}
@@ -15484,7 +15570,7 @@ ${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;
@@ -15508,13 +15594,13 @@ ${changed2.map((c) => `  - ${c}
       let resolvedRemotes;
       if (existsSync26(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);
@@ -15580,7 +15666,7 @@ ${changed2.map((c) => `  - ${c}
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
           if (existsSync26(resolvedFile)) {
-            const raw = JSON.parse(readFileSync19(resolvedFile, "utf8"));
+            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)}
@@ -15837,7 +15923,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         const hadPreviousFile = existsSync26(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync19(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync20(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -15900,7 +15986,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 +16014,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 +16024,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,6 +16216,7 @@ 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 stale = planRemoteBranchCleanup(r.dir, r.config.branch.remote, r.config.branch.base, brTickets, tracker.contract);
         if (stale.length) {
           anything = true;
@@ -16137,7 +16224,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
         if (!actions.length) 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);
         emit.emit(
           `swept ${res.removed} worktree(s) for ${r.name}, kept ${res.keptBranches} branch(es)`,
           { step: "worktree" }
@@ -16530,7 +16617,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 {
@@ -16751,7 +16838,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.3",
   "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",