@tablation/crew 0.47.1 → 0.47.3

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve4, dirname as dirname12, join as join23, basename as basename9 } from "path";
+import { resolve as resolve4, dirname as dirname12, join as join24, basename as basename9 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir8 } from "os";
 import { spawnSync as spawnSync5 } from "child_process";
@@ -4030,9 +4030,11 @@ import {
   statSync as statSync4,
   unlinkSync as unlinkSync2,
   readFileSync as readFileSync9,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync6,
+  readdirSync as readdirSync3,
+  rmSync as rmSync6
 } from "fs";
-import { dirname as dirname5, basename as basename4 } from "path";
+import { dirname as dirname5, basename as basename4, join as join10 } from "path";
 var GitError = class extends Error {
 };
 function streamText(x) {
@@ -4115,15 +4117,36 @@ function remoteBranchForIssue(cwd, remote, issueKey, templates = { name: "issue-
   }
   return null;
 }
-function materializeRemoteBranch(cwd, remote, branch) {
-  if (!remoteBranchExists(cwd, remote, branch)) {
-    return gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]) !== null;
+function levelRemoteBranch(cwd, remote, branch) {
+  const local = gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]);
+  if (!remoteBranchExists(cwd, remote, branch)) return { exists: local !== null };
+  if (local === null) {
+    return { exists: gitOk(cwd, ["branch", "--track", branch, `${remote}/${branch}`]) !== null };
+  }
+  const remoteTip2 = gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/remotes/${remote}/${branch}`]);
+  if (!remoteTip2 || remoteTip2 === local) return { exists: true };
+  if (!isAncestor(cwd, local, remoteTip2)) return { exists: true };
+  const holder = worktrees(cwd).find((w) => w.branch === branch && !w.prunable);
+  if (holder) {
+    if (gitOk(holder.path, ["status", "--porcelain"])) {
+      return {
+        exists: true,
+        problem: `${branch} is behind ${remote}/${branch} and the worktree ${holder.path} that holds it has uncommitted or mid-merge changes`
+      };
+    }
+    try {
+      git(holder.path, ["merge", "--ff-only", "--quiet", `${remote}/${branch}`]);
+    } catch (e) {
+      return { exists: true, problem: `could not fast-forward ${branch} in ${holder.path}: ${e.message}` };
+    }
+    return { exists: true };
   }
-  if (gitOk(cwd, ["rev-parse", "-q", "--verify", `refs/heads/${branch}`]) === null) {
-    return gitOk(cwd, ["branch", "--track", branch, `${remote}/${branch}`]) !== null;
+  try {
+    git(cwd, ["fetch", "--quiet", remote, `${branch}:${branch}`]);
+  } catch (e) {
+    return { exists: true, problem: `could not move ${branch} to ${remote}/${branch}: ${e.message}` };
   }
-  gitOk(cwd, ["fetch", "--quiet", remote, `${branch}:${branch}`]);
-  return true;
+  return { exists: true };
 }
 function deleteRemoteBranch(cwd, remote, branch) {
   if (!remoteBranchExists(cwd, remote, branch)) return true;
@@ -4367,12 +4390,36 @@ function recoverStrandedReleaseCheckouts(cwd) {
     if (line.startsWith("worktree ")) path = line.slice("worktree ".length);
     else if (line.startsWith("branch refs/heads/crew/release-") && path) {
       gitOk(cwd, ["worktree", "remove", "--force", path]);
+      const root = dirname5(path);
+      if (basename4(root).startsWith("crew-release-")) rmSync6(root, { recursive: true, force: true });
     }
   }
   const stranded = (gitOk(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/heads/crew/release-*"]) ?? "").split("\n").filter(Boolean);
   for (const b of stranded) gitOk(cwd, ["branch", "-q", "-D", b]);
   return stranded;
 }
+function sweepStaleReleaseRoots(tmp, now = Date.now(), maxAgeMs = 60 * 60 * 1e3) {
+  const removed = [];
+  let names;
+  try {
+    names = readdirSync3(tmp);
+  } catch {
+    return removed;
+  }
+  for (const name of names) {
+    if (!name.startsWith("crew-release-")) continue;
+    const root = join10(tmp, name);
+    try {
+      const st = statSync4(root);
+      if (!st.isDirectory() || now - st.mtimeMs < maxAgeMs) continue;
+      if (existsSync9(join10(root, "checkout"))) continue;
+      rmSync6(root, { recursive: true, force: true });
+      removed.push(name);
+    } catch {
+    }
+  }
+  return removed;
+}
 function pushBranch(cwd, remote, branch, dst = branch) {
   git(cwd, ["push", remote, `${branch}:${dst}`]);
 }
@@ -6259,16 +6306,17 @@ function locateBranchForTicket(dir, cfg, t, role, fetchedDirs) {
   const found = remoteBranchForIssue(dir, remote, t.issue_id, branchTemplates(cfg, t), branchRenderer(t, role));
   return found ? { branch: found, where: "remote" } : null;
 }
-function materializeBranchForTicket(dir, cfg, t, role) {
+function materializeBranchForTicket(dir, cfg, t, role, onProblem) {
   const loc = locateBranchForTicket(dir, cfg, t, role);
   if (!loc) return null;
-  materializeRemoteBranch(dir, cfg.branch.remote, loc.branch);
+  const r = levelRemoteBranch(dir, cfg.branch.remote, loc.branch);
+  if (r.problem) onProblem?.(r.problem);
   return loc.branch;
 }
 
 // src/poll.ts
 import { writeFileSync as writeFileSync7 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 
 // src/stalled.ts
 var STALLED_AFTER_CYCLES = 30;
@@ -6545,7 +6593,7 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route, role) => join10(stateDir, `digest-${route}-${role}.md`);
+var digestPath = (stateDir, route, role) => join11(stateDir, `digest-${route}-${role}.md`);
 function writeDigest(o, d, role, stateDir) {
   const me = o.route.resolved?.seats[role];
   if (!me) return false;
@@ -6720,6 +6768,11 @@ function planConflictBounce(cwd, ticket, branch, base, paths, events) {
 function refreshBranch(worktree, base) {
   const dirty = gitOk(worktree, ["status", "--porcelain"]);
   if (dirty) return { clean: false, paths: [], why: "the worktree has uncommitted changes" };
+  const upstream = gitOk(worktree, ["rev-parse", "-q", "--verify", "@{upstream}"]);
+  const head = gitOk(worktree, ["rev-parse", "HEAD"]);
+  if (upstream && head && upstream !== head && isAncestor(worktree, head, upstream)) {
+    return { clean: false, paths: [], behind: true, why: "the branch is behind its remote; fast-forward it before merging the base in" };
+  }
   try {
     git(worktree, ["merge", "--no-edit", base]);
     return { clean: true, paths: [] };
@@ -6787,6 +6840,10 @@ async function applyConflictBounce(writer, b, contract, memberId, log, dryRun) {
       log.emit(`merged ${b.base} into ${b.branch} cleanly \u2014 it was stale, not conflicting`, t);
       return { kind: "refreshed" };
     }
+    if (r.behind) {
+      log.warn(`not handing ${b.ticket.issue_id} back: ${r.why}`, t);
+      return { kind: "failed", why: r.why ?? "branch behind its remote" };
+    }
     merged = r.paths.length > 0;
     if (r.why) log.warn(`could not merge ${b.base} into ${b.branch}: ${r.why}`, t);
     if (r.paths.length) b.paths = r.paths;
@@ -6993,7 +7050,7 @@ var alreadyReported = (ticket, g, events) => events.some((e) => e.record_id ===
 import { spawn as spawn2 } from "child_process";
 import { readFileSync as readFileSync12, existsSync as existsSync12, statSync as statSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync8, createWriteStream } from "fs";
 import { finished } from "stream/promises";
-import { join as join13, dirname as dirname6 } from "path";
+import { join as join14, dirname as dirname6 } from "path";
 import { createHash as createHash2 } from "crypto";
 
 // src/environment.ts
@@ -7408,14 +7465,14 @@ function expandSkillMarkers(text, lookup, opts = {}) {
 }
 
 // src/skills.ts
-import { readFileSync as readFileSync11, readdirSync as readdirSync3, existsSync as existsSync11 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync11, readdirSync as readdirSync4, existsSync as existsSync11 } 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";
 
 // src/agents.ts
 import { readFileSync as readFileSync10, existsSync as existsSync10 } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { TablationClient as TablationClient2, StaleWriteError as StaleWriteError7, TablationApiError } from "@tablation/client";
 var PERSONA_NAME = {
   dev: "Developer",
@@ -7429,10 +7486,10 @@ var CREW_AGENT_COLUMN = "agent_id";
 var AgentsSyncError = class extends Error {
 };
 function personaDefaultPrompt(promptsDir, role) {
-  const briefPath = join11(promptsDir, "personas", `lane-${role}.md`);
+  const briefPath = join12(promptsDir, "personas", `lane-${role}.md`);
   if (!existsSync10(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
   if (SELF_CONTAINED_ROLES.has(role)) return readFileSync10(briefPath, "utf8");
-  const commonPath = join11(promptsDir, "personas", "common.md");
+  const commonPath = join12(promptsDir, "personas", "common.md");
   if (!existsSync10(commonPath)) return readFileSync10(briefPath, "utf8");
   return `${readFileSync10(commonPath, "utf8")}${readFileSync10(briefPath, "utf8")}`;
 }
@@ -7812,9 +7869,9 @@ function parseSkillFile(path) {
   return { name: meta.name, description: meta.description, prompt: body, file: path };
 }
 function listLocalSkills(promptsDir) {
-  const dir = join12(promptsDir, "skills");
+  const dir = join13(promptsDir, "skills");
   if (!existsSync11(dir)) return [];
-  return readdirSync3(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join12(dir, f)));
+  return readdirSync4(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join13(dir, f)));
 }
 async function syncSkills(route, opts) {
   if (!route.resolved) {
@@ -8047,15 +8104,15 @@ var AgentError = class extends Error {
 var AgentSpawnError = class extends AgentError {
 };
 function planAgentRun(o) {
-  const briefPath = join13(o.route.promptsDir, "personas", `lane-${o.role}.md`);
+  const briefPath = join14(o.route.promptsDir, "personas", `lane-${o.role}.md`);
   if (!existsSync12(briefPath)) {
     throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
   }
-  const commonPath = join13(o.route.promptsDir, "personas", "common.md");
+  const commonPath = join14(o.route.promptsDir, "personas", "common.md");
   const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync12(commonPath);
   const now = o.now ?? (() => Date.now());
   const routeLabel = routeSlug(o.route.route);
-  const digestPath2 = join13(o.stateDir, `digest-${routeLabel}-${o.role}.md`);
+  const digestPath2 = join14(o.stateDir, `digest-${routeLabel}-${o.role}.md`);
   let digest;
   let ageSeconds;
   if (existsSync12(digestPath2)) {
@@ -8085,7 +8142,7 @@ function planAgentRun(o) {
     digest
   });
   const promptSha = createHash2("sha256").update(expanded.text).digest("hex");
-  const streamsDir = join13(o.stateDir, "streams");
+  const streamsDir = join14(o.stateDir, "streams");
   const base = `${routeLabel}-${o.role}-${o.cycle}`;
   const seat = resolveSeat(o.ship, o.route, o.role, o.agentPersona ?? (o.agentModel ? { model: o.agentModel } : {}), o.repo);
   const { toolchain, model } = seat;
@@ -8141,8 +8198,8 @@ function planAgentRun(o) {
     digestAttached: digest !== void 0,
     digestAgeSeconds: ageSeconds,
     model,
-    streamPath: join13(streamsDir, `${base}.jsonl`),
-    eventsPath: join13(streamsDir, `${base}.events.jsonl`),
+    streamPath: join14(streamsDir, `${base}.jsonl`),
+    eventsPath: join14(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
     agentLog,
     promptVersion: o.route.resolved?.agentPersonas?.[o.role]?.historyId,
@@ -8349,12 +8406,12 @@ function spawnAgent(plan, emit) {
 
 // src/run-worktree.ts
 import { existsSync as existsSync14 } from "fs";
-import { dirname as dirname7, join as join15 } from "path";
+import { dirname as dirname7, join as join16 } from "path";
 
 // src/ports.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { existsSync as existsSync13 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var run = (cmd, args) => {
   try {
     return execFileSync2(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
@@ -8399,7 +8456,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 (existsSync13(join14(parent, name, ".git"))) return true;
+    if (existsSync13(join15(parent, name, ".git"))) return true;
   }
   return false;
 }
@@ -8487,7 +8544,7 @@ function planRunWorktree(dir, cfg, t, role) {
     if (countCommits(existing.path, `${baseRef}..HEAD`) > 0) return { action: "leave-unpushed", path: existing.path, branch };
     return { action: "recut", path: existing.path, branch, base: baseRef };
   }
-  const path = join15(dirname7(dir), worktreeForTicket(dir, cfg, t, role));
+  const path = join16(dirname7(dir), worktreeForTicket(dir, cfg, t, role));
   if (located?.where === "remote" || located && hasRemote && remoteBranchExists(dir, remote, located.branch)) {
     return { action: "cut-remote", path, branch: located.branch };
   }
@@ -8695,7 +8752,7 @@ async function retireRunWorktree(tracker, dir, cfg, t, role, seatId, shipName2,
 }
 
 // src/connect-wizard.ts
-import { delimiter, dirname as dirname8, join as join16 } from "path";
+import { delimiter, dirname as dirname8, join as join17 } from "path";
 import { accessSync as accessSync2, constants as constants2, existsSync as existsSync15, mkdirSync as mkdirSync7, writeFileSync as writeFileSync9 } from "fs";
 import { stringify } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
@@ -8718,7 +8775,7 @@ function defaultIsExecutable(p) {
 function findOnPath2(name, pathEnv, isExecutable = defaultIsExecutable) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join16(dir, name);
+    const candidate = join17(dir, name);
     if (isExecutable(candidate)) return candidate;
   }
   return void 0;
@@ -8813,8 +8870,8 @@ Wrote ${o.configPath}.
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, existsSync as existsSync16, copyFileSync, mkdirSync as mkdirSync8, mkdtempSync, rmSync as rmSync6 } from "fs";
-import { dirname as dirname9, join as join17 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, existsSync as existsSync16, 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";
 
 // src/release.ts
@@ -9472,7 +9529,7 @@ async function bump(o, size) {
     }
     return printed;
   }
-  const files = o.repo.release.versionFiles.map((f) => join17(o.cwd, f));
+  const files = o.repo.release.versionFiles.map((f) => join18(o.cwd, f));
   const first = files[0];
   if (!existsSync16(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
@@ -9504,7 +9561,7 @@ async function bump(o, size) {
 function writeChangelog(o, version, entries) {
   const file = o.repo.release.changelog;
   if (!file || entries.length === 0) return;
-  const path = join17(o.cwd, file);
+  const path = join18(o.cwd, file);
   const section = renderChangelogSection(version, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), entries);
   if (o.dryRun) {
     o.emit.emit(`would prepend ${entries.length} entr(ies) to ${file}`);
@@ -9589,17 +9646,25 @@ async function confirmLastRelease(o, decision) {
   if (!confirmed) o.emit.warn(`${decision.lastTag} is still not confirmed live \u2014 tickets stay verified`);
   return { confirmed, version };
 }
+function closeReleaseCheckout(cwd, root, dir, branch, run2 = gitOk) {
+  try {
+    run2(cwd, ["worktree", "remove", "--force", dir]);
+  } finally {
+    try {
+      rmSync7(root, { recursive: true, force: true });
+    } finally {
+      run2(cwd, ["worktree", "prune"]);
+      run2(cwd, ["branch", "-D", branch]);
+    }
+  }
+}
 function openReleaseCheckout(o) {
   const { remote, base } = o.repo.branch;
   const branch = `crew/release-${Date.now()}`;
-  const root = mkdtempSync(join17(tmpdir2(), "crew-release-"));
-  const dir = join17(root, "checkout");
-  const close = () => {
-    gitOk(o.cwd, ["worktree", "remove", "--force", dir]);
-    rmSync6(root, { recursive: true, force: true });
-    gitOk(o.cwd, ["worktree", "prune"]);
-    gitOk(o.cwd, ["branch", "-D", branch]);
-  };
+  const root = mkdtempSync(join18(tmpdir2(), "crew-release-"));
+  const dir = join18(root, "checkout");
+  o.emit.emit(`release checkout: ${dir}`, { step: "release" });
+  const close = () => closeReleaseCheckout(o.cwd, root, dir, branch);
   try {
     git(o.cwd, ["worktree", "add", "-q", "-b", branch, dir, `${remote}/${base}`]);
   } catch (e) {
@@ -9607,10 +9672,10 @@ function openReleaseCheckout(o) {
     throw e;
   }
   for (const f of o.repo.worktrees.copy) {
-    const src = join17(o.cwd, f);
+    const src = join18(o.cwd, f);
     if (!existsSync16(src)) continue;
-    mkdirSync8(dirname9(join17(dir, f)), { recursive: true });
-    copyFileSync(src, join17(dir, f));
+    mkdirSync8(dirname9(join18(dir, f)), { recursive: true });
+    copyFileSync(src, join18(dir, f));
   }
   return { dir, branch, close };
 }
@@ -9630,7 +9695,19 @@ async function runRelease(o) {
   const tagPattern = o.repo.release.tagPattern ?? "v*";
   o.emit.enter("release");
   const fresh = refreshBase(o);
-  const decision = decideRelease(o.cwd, o.tickets, o.contract, {
+  let releasable = o.tickets;
+  if (!o.dryRun) {
+    const skipped = /* @__PURE__ */ new Set();
+    for (const t of o.tickets) {
+      if (t.status !== o.contract.statuses.verified) continue;
+      materializeBranchForTicket(o.cwd, o.repo, t, void 0, (problem) => {
+        skipped.add(t.id);
+        o.emit.error(`not releasing ${t.issue_id} this cycle: ${problem}`, { ticket: t.issue_id });
+      });
+    }
+    if (skipped.size) releasable = o.tickets.filter((t) => !skipped.has(t.id));
+  }
+  const decision = decideRelease(o.cwd, releasable, o.contract, {
     tagPattern,
     base: o.repo.branch.base,
     blockerInfo: o.blockerInfo,
@@ -9689,6 +9766,8 @@ async function runRelease(o) {
   let checkout;
   const stranded = recoverStrandedReleaseCheckouts(o.cwd);
   if (stranded.length > 0) o.emit.warn(scoped(`dropped release checkout(s) stranded by a crash: ${stranded.join(", ")}`));
+  const swept = sweepStaleReleaseRoots(tmpdir2());
+  if (swept.length > 0) o.emit.emit(scoped(`removed ${swept.length} stale crew-release-* temp dir(s)`), { step: "release" });
   try {
     checkout = openReleaseCheckout(o);
   } catch (e) {
@@ -11451,14 +11530,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync19, readdirSync as readdirSync4, rmSync as rmSync7, statSync as statSync7 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync19, readdirSync as readdirSync5, rmSync as rmSync8, statSync as statSync7 } from "fs";
+import { join as join19 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join18(stateDir, "streams");
+  const dir = join19(stateDir, "streams");
   if (!existsSync19(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync4(dir).map((name) => join18(dir, name)).filter((path) => {
+  return readdirSync5(dir).map((name) => join19(dir, name)).filter((path) => {
     try {
       return statSync7(path).mtimeMs < cutoff;
     } catch {
@@ -11474,7 +11553,7 @@ function applyStreamSweep(paths, dryRun, log) {
       continue;
     }
     try {
-      rmSync7(path, { force: true });
+      rmSync8(path, { force: true });
       removed++;
       log.emit(`removed stream artifact ${path}`, { step: "worktree" });
     } catch (e) {
@@ -11486,7 +11565,7 @@ function applyStreamSweep(paths, dryRun, log) {
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
   if (!existsSync19(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync4(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join18(stateDir, name)).filter((path) => {
+  return readdirSync5(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join19(stateDir, name)).filter((path) => {
     try {
       return statSync7(path).mtimeMs < cutoff;
     } catch {
@@ -11503,11 +11582,11 @@ import { dirname as dirOf, resolve as resolvePath } from "path";
 // src/ssh-keys.ts
 import { execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync20, mkdirSync as mkdirSync9, readFileSync as readFileSync14, chmodSync } from "fs";
-import { dirname as dirname11, join as join19 } from "path";
+import { dirname as dirname11, join as join20 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join19(stateDir, "ssh", "id_ed25519");
+  return join20(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
@@ -11752,9 +11831,9 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync21, mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync11, unlinkSync as unlinkSync3, readdirSync as readdirSync5 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync11, unlinkSync as unlinkSync3, readdirSync as readdirSync6 } from "fs";
 import { randomInt } from "crypto";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn3(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -11821,7 +11900,7 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join20(stateDir, "passengers", `${workspaceId}.json`);
+  return join21(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
@@ -11834,7 +11913,7 @@ function readPersistedTunnel(stateDir, workspaceId) {
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync10(join20(stateDir, "passengers"), { recursive: true });
+  mkdirSync10(join21(stateDir, "passengers"), { recursive: true });
   writeFileSync11(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -11932,9 +12011,9 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join20(stateDir, "passengers");
+  const dir = join21(stateDir, "passengers");
   if (!existsSync21(dir)) return [];
-  return readdirSync5(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
+  return readdirSync6(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
 // src/mcp-endpoint-registry.ts
@@ -12054,8 +12133,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 existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync16, writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, readdirSync as readdirSync6 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync16, writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, readdirSync as readdirSync7 } from "fs";
+import { join as join22 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -12144,7 +12223,7 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join21(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join22(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
@@ -12157,7 +12236,7 @@ function readPersistedSyncDaemon(stateDir, workspaceId) {
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync11(join21(stateDir, "passengers"), { recursive: true });
+  mkdirSync11(join22(stateDir, "passengers"), { recursive: true });
   writeFileSync12(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -12178,10 +12257,10 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join21(stateDir, "passengers");
+  const dir = join22(stateDir, "passengers");
   if (!existsSync22(dir)) return [];
   const suffix = "-sync.json";
-  return readdirSync6(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
+  return readdirSync7(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
 function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
   const alive = deps.isPidAlive ?? isPidAlive;
@@ -12236,8 +12315,8 @@ function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync17, readdirSync as readdirSync7, rmSync as rmSync8, statSync as statSync8, writeFileSync as writeFileSync13 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync17, readdirSync as readdirSync8, rmSync as rmSync9, statSync as statSync8, writeFileSync as writeFileSync13 } from "fs";
+import { join as join23 } from "path";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
 var defaultSleep = (ms2) => new Promise((resolve5) => setTimeout(resolve5, ms2));
@@ -12275,8 +12354,8 @@ function latestMtime(path) {
   if (stat.isFile()) return stat.mtimeMs;
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
-  for (const entry of readdirSync7(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join22(path, entry.name)));
+  for (const entry of readdirSync8(path, { withFileTypes: true })) {
+    latest = Math.max(latest, latestMtime(join23(path, entry.name)));
   }
   return latest;
 }
@@ -12288,14 +12367,14 @@ function makeStaleChecker(paths, opts = {}) {
   return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync23(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join22(stateDir, "reload-requested");
+  return join23(stateDir, "reload-requested");
 }
 function daemonStampFor(stateDir) {
-  return join22(stateDir, "daemon.started");
+  return join23(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
   mkdirSync12(stateDir, { recursive: true });
-  rmSync8(reloadSentinelFor(stateDir), { force: true });
+  rmSync9(reloadSentinelFor(stateDir), { force: true });
   writeFileSync13(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
 `);
 }
@@ -13115,7 +13194,7 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join23(homedir8(), ".config", "systemd", "user", `${label}.timer`);
+      const staleTimer = join24(homedir8(), ".config", "systemd", "user", `${label}.timer`);
       if (existsSync24(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
@@ -14123,7 +14202,7 @@ ${changed2.map((c) => `  - ${c}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join23(CREW_HOME, "src"), join23(CREW_HOME, "dist"), join23(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join24(CREW_HOME, "src"), join24(CREW_HOME, "dist"), join24(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -14803,7 +14882,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 ? join23(DEFAULT_REPOS_BASE_PATH, found.workspaceSlug) : void 0);
+        const routeDir = value("dir") ?? (writeFirstRun ? join24(DEFAULT_REPOS_BASE_PATH, found.workspaceSlug) : void 0);
         const routeBlock = renderConnection(
           found,
           route2,

package/package.json

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