@tablation/crew 0.72.2 → 0.72.3

package/dist/cli.js

@@ -130,21 +130,21 @@ function formatStaleOwnLock(scope, holder) {
 
 // src/selftest.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync19, mkdirSync as mkdirSync9, mkdtempSync, readFileSync as readFileSync15, rmSync as rmSync9, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, mkdtempSync, readFileSync as readFileSync16, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // src/agent.ts
 import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
-import { readFileSync as readFileSync14, existsSync as existsSync18, statSync as statSync5, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
+import { readFileSync as readFileSync15, existsSync as existsSync18, statSync as statSync5, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
 import { StringDecoder } from "string_decoder";
 import { finished } from "stream/promises";
-import { join as join17, dirname as dirname7, basename as basename7 } from "path";
-import { createHash as createHash2 } from "crypto";
+import { join as join18, dirname as dirname7, basename as basename7 } from "path";
+import { createHash as createHash3 } from "crypto";
 
 // src/config.ts
-import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
-import { resolve, dirname as dirname3, isAbsolute, join as join7, basename as basename3 } from "path";
+import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
+import { resolve, dirname as dirname3, isAbsolute, join as join8, basename as basename3 } from "path";
 import { homedir as homedir5, tmpdir } from "os";
 import { parse as parse2 } from "yaml";
 
@@ -294,10 +294,10 @@ var Emitter = class _Emitter {
 var eventFileFor = (stateDir) => join(stateDir, "events.jsonl");
 
 // src/pair-install.ts
-import { existsSync as existsSync5, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync5, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
 import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/stream.ts
 function toolTarget(name, input) {
@@ -349,9 +349,38 @@ function extractResult(line) {
 
 // src/claude-mcp.ts
 import { spawnSync } from "child_process";
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { homedir } from "os";
+import { join as join3 } from "path";
+
+// src/mcp-registrations.ts
+import { createHash } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { join as join2 } from "path";
+var fileFor = (stateDir) => join2(stateDir, "mcp-registrations.json");
+var keyFingerprint = (key) => createHash("sha256").update(key).digest("hex").slice(0, 8);
+function readMcpRegistrations(stateDir) {
+  try {
+    const j = JSON.parse(readFileSync2(fileFor(stateDir), "utf8"));
+    return Array.isArray(j) ? j : [];
+  } catch {
+    return [];
+  }
+}
+function recordMcpRegistration(stateDir, r, now = /* @__PURE__ */ new Date()) {
+  const rest = readMcpRegistrations(stateDir).filter((x) => !(x.harness === r.harness && x.scope === r.scope && x.name === r.name));
+  mkdirSync2(stateDir, { recursive: true });
+  writeFileSync(fileFor(stateDir), `${JSON.stringify([...rest, { ...r, at: now.toISOString() }], null, 2)}
+`, { mode: 384 });
+}
+function findMcpRegistration(stateDir, r) {
+  const fp = keyFingerprint(r.key);
+  return readMcpRegistrations(stateDir).find(
+    (x) => x.harness === r.harness && x.scope === r.scope && x.name === r.name && x.url === r.url && x.keyFingerprint === fp
+  );
+}
+
+// src/claude-mcp.ts
 var MCP_SERVER_NAME = "tablation";
 var redact = (s, key) => key ? s.split(key).join("sk_***") : s;
 function mcpUrlFor(baseUrl) {
@@ -364,7 +393,7 @@ function runClaude(bin, args) {
 }
 function userScopeEntry(home) {
   try {
-    const j = JSON.parse(readFileSync2(join2(home, ".claude.json"), "utf8"));
+    const j = JSON.parse(readFileSync3(join3(home, ".claude.json"), "utf8"));
     return j.mcpServers?.[MCP_SERVER_NAME];
   } catch {
     return void 0;
@@ -380,18 +409,32 @@ function inspectClaudeMcp(o) {
   }
   if (entry.url !== o.url) return { state: "different", detail: `it points at ${entry.url ?? "(no url)"}, not ${o.url}` };
   const auth = Object.entries(entry.headers ?? {}).find(([k]) => k.toLowerCase() === "authorization")?.[1];
-  if (auth !== `Bearer ${o.key}`) return { state: "different", detail: `it is registered with a different key than this route's` };
+  if (auth !== `Bearer ${o.key}`) {
+    const bearer = auth?.startsWith("Bearer ") ? auth.slice("Bearer ".length) : void 0;
+    const mine = o.stateDir && bearer ? findMcpRegistration(o.stateDir, { harness: "claude", scope: "user", name: MCP_SERVER_NAME, url: o.url, key: bearer }) : void 0;
+    if (mine) return { state: "different", detail: `crew registered an earlier key here`, crewWrote: mine.at };
+    return { state: "different", detail: `it points at ${o.url} with a key that is not one crew issued` };
+  }
   return { state: "registered", url: o.url };
 }
 function ensureClaudeMcp(o) {
+  return ensureClaudeMcpResult(o).line;
+}
+function ensureClaudeMcpResult(o) {
+  const r = ensureInner(o);
+  return { ...r, url: o.url };
+}
+function ensureInner(o) {
   const manual = `claude mcp add --transport http ${MCP_SERVER_NAME} ${o.url} --header "Authorization: Bearer <key>" --scope user`;
   const st = inspectClaudeMcp(o);
-  if (st.state === "no-claude") return `mcp: \`${o.bin}\` not found, so Claude Code was not configured. To do it by hand: ${manual}`;
-  if (st.state === "registered") return `mcp: ${MCP_SERVER_NAME} already registered with Claude Code \u2192 ${st.url}`;
-  if (st.state === "different" && !o.replace) {
-    return `mcp: left Claude Code's "${MCP_SERVER_NAME}" server alone \u2014 ${st.detail}. Re-run with --mcp replace to overwrite it.`;
-  }
-  if (o.dryRun) return `(dry run) would register the ${MCP_SERVER_NAME} MCP server with Claude Code \u2192 ${o.url}`;
+  if (st.state === "no-claude") return { line: `mcp: \`${o.bin}\` not found, so Claude Code was not configured. To do it by hand: ${manual}` };
+  if (st.state === "registered") return { line: `mcp: ${MCP_SERVER_NAME} already registered with Claude Code \u2192 ${st.url}`, action: "registered" };
+  const crewWrote = st.state === "different" ? st.crewWrote : void 0;
+  const ours = crewWrote !== void 0;
+  if (st.state === "different" && !o.replace && !ours) {
+    return { line: `mcp: left Claude Code's "${MCP_SERVER_NAME}" server alone \u2014 ${st.detail}. Re-run with --mcp replace to overwrite it.`, action: "kept" };
+  }
+  if (o.dryRun) return { line: `(dry run) would register the ${MCP_SERVER_NAME} MCP server with Claude Code \u2192 ${o.url}` };
   if (st.state === "different") {
     runClaude(o.bin, ["mcp", "remove", MCP_SERVER_NAME, "--scope", "user"]);
   }
@@ -408,9 +451,21 @@ function ensureClaudeMcp(o) {
     "user"
   ]);
   if (add.status !== 0) {
-    return `mcp: \`claude mcp add\` failed (${redact(add.stderr.trim(), o.key) || `exit ${add.status}`}). To do it by hand: ${manual}`;
+    return { line: `mcp: \`claude mcp add\` failed (${redact(add.stderr.trim(), o.key) || `exit ${add.status}`}). To do it by hand: ${manual}` };
+  }
+  if (o.stateDir) {
+    try {
+      recordMcpRegistration(o.stateDir, { harness: "claude", scope: "user", name: MCP_SERVER_NAME, url: o.url, keyFingerprint: keyFingerprint(o.key) });
+    } catch {
+    }
+  }
+  if (crewWrote !== void 0) {
+    return { line: `mcp: updated the key crew registered on ${crewWrote.slice(0, 10)} \u2192 ${o.url}`, action: "replaced" };
   }
-  return `mcp: registered the ${MCP_SERVER_NAME} MCP server with Claude Code \u2192 ${o.url} (user scope, ~/.claude.json)`;
+  return {
+    line: `mcp: ${st.state === "different" ? "replaced" : "registered"} the ${MCP_SERVER_NAME} MCP server with Claude Code \u2192 ${o.url} (user scope, ~/.claude.json)`,
+    action: st.state === "different" ? "replaced" : "registered"
+  };
 }
 function removeClaudeMcp(o) {
   const got = runClaude(o.bin, ["mcp", "get", MCP_SERVER_NAME]);
@@ -422,8 +477,8 @@ function removeClaudeMcp(o) {
 }
 
 // src/launcher.ts
-import { basename, join as join3 } from "path";
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync } from "fs";
+import { basename, join as join4 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync } from "fs";
 import { homedir as homedir2 } from "os";
 function isOriLauncher(spec) {
   return !!spec.launcher && basename(spec.launcher) === "ori";
@@ -432,7 +487,7 @@ function isOmlxLauncher(spec) {
   return !!spec.launcher && basename(spec.launcher) === "omlx";
 }
 function defaultOmlxBin(home = homedir2()) {
-  return join3(home, ".omlx", "bin", "omlx");
+  return join4(home, ".omlx", "bin", "omlx");
 }
 function launcherExecutable(spec, home) {
   if (!spec.launcher) return void 0;
@@ -485,8 +540,8 @@ function omlxModelPresent(model, dirs) {
   });
 }
 function readOmlxSettings(home = homedir2()) {
-  const p = join3(home, ".omlx", "settings.json");
-  return existsSync3(p) ? parseOmlxSettings(readFileSync3(p, "utf8")) : void 0;
+  const p = join4(home, ".omlx", "settings.json");
+  return existsSync3(p) ? parseOmlxSettings(readFileSync4(p, "utf8")) : void 0;
 }
 
 // src/capability.ts
@@ -613,17 +668,18 @@ var claudeAdapter = {
     const s = inspectClaudeMcp(o);
     return s.state === "no-claude" ? { state: "no-binary" } : s;
   },
-  ensureMcp: ensureClaudeMcp
+  ensureMcp: ensureClaudeMcp,
+  ensureMcpResult: ensureClaudeMcpResult
 };
 
 // src/adapters/codex.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
-import { rmSync as rmSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
+import { rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
 
 // src/pair-files.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2, rmSync as rmSync2 } from "fs";
 import { dirname as dirname2 } from "path";
 var PAIR_BLOCK_START = "<!-- crew:pair start -->";
 var PAIR_BLOCK_END = "<!-- crew:pair end -->";
@@ -664,11 +720,11 @@ function removePairBlock(text) {
   return text.replace(new RegExp(`\\n*${BLOCK_RE.source}`), "\n").replace(/^\n+/, "").replace(/\n{3,}/g, "\n\n");
 }
 function readIfExists(path) {
-  return existsSync4(path) ? readFileSync4(path, "utf8") : void 0;
+  return existsSync4(path) ? readFileSync5(path, "utf8") : void 0;
 }
 function writeFileMkdir(path, text) {
-  mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync(path, text);
+  mkdirSync3(dirname2(path), { recursive: true });
+  writeFileSync2(path, text);
 }
 function installBlockFile(path, harness, dryRun) {
   const before = readIfExists(path) ?? "";
@@ -684,7 +740,7 @@ function removeBlockFile(path, dryRun) {
   if (dryRun) return true;
   const after = removePairBlock(before);
   if (after.trim() === "") rmSync2(path);
-  else writeFileSync(path, after);
+  else writeFileSync2(path, after);
   return true;
 }
 function blockVerdict(path, harness) {
@@ -811,8 +867,8 @@ function codexTable(url) {
   return [`[mcp_servers.${SERVER}]`, `url = ${tomlString(url)}`, `bearer_token_env_var = ${tomlString(PAIR_KEY_VAR)}`];
 }
 var codexPaths = (home) => ({
-  instructions: join4(home, ".codex", "AGENTS.md"),
-  config: join4(home, ".codex", "config.toml")
+  instructions: join5(home, ".codex", "AGENTS.md"),
+  config: join5(home, ".codex", "config.toml")
 });
 function codexMcpState(config, url) {
   const lines = config.split("\n");
@@ -863,7 +919,7 @@ var codexPair = {
     if (hadMcp && !o.dryRun) {
       const after = removeTomlTable(config, `mcp_servers.${SERVER}`);
       if (after === "") rmSync3(p.config);
-      else writeFileSync2(p.config, after);
+      else writeFileSync3(p.config, after);
     }
     const what = hadBlock && hadMcp ? `the Pair block and ${SERVER} server` : hadBlock ? "the Pair block" : `the ${SERVER} server`;
     return hadBlock || hadMcp ? `pair(codex): ${o.dryRun ? "(dry run) would remove" : "removed"} ${what}${kept}` : `pair(codex): nothing to remove${kept}`;
@@ -959,8 +1015,8 @@ var codexAdapter = {
 
 // src/pair-install.ts
 var geminiPaths = (home) => ({
-  instructions: join5(home, ".gemini", "GEMINI.md"),
-  config: join5(home, ".gemini", "settings.json")
+  instructions: join6(home, ".gemini", "GEMINI.md"),
+  config: join6(home, ".gemini", "settings.json")
 });
 function readGeminiSettings(path) {
   const text = readIfExists(path);
@@ -1048,7 +1104,7 @@ var geminiPair = {
       if (Object.keys(rest).length > 0) next.mcpServers = rest;
       else delete next.mcpServers;
       if (Object.keys(next).length === 0) rmSync4(p.config);
-      else writeFileSync3(p.config, `${JSON.stringify(next, null, 2)}
+      else writeFileSync4(p.config, `${JSON.stringify(next, null, 2)}
 `);
     }
     const what = hadBlock && hadMcp ? `the Pair block and ${SERVER} server` : hadBlock ? "the Pair block" : `the ${SERVER} server`;
@@ -1059,8 +1115,8 @@ var VSCODE_FLAVOURS = ["Code", "Code - Insiders"];
 function vscodeUserDirs(o) {
   const home = o.home ?? homedir4();
   const platform2 = o.platform ?? process.platform;
-  const root = platform2 === "darwin" ? join5(home, "Library", "Application Support") : platform2 === "win32" ? process.env.APPDATA ?? join5(home, "AppData", "Roaming") : join5(home, ".config");
-  const all = VSCODE_FLAVOURS.map((f) => join5(root, f, "User"));
+  const root = platform2 === "darwin" ? join6(home, "Library", "Application Support") : platform2 === "win32" ? process.env.APPDATA ?? join6(home, "AppData", "Roaming") : join6(home, ".config");
+  const all = VSCODE_FLAVOURS.map((f) => join6(root, f, "User"));
   const present = all.filter((d) => existsSync5(d));
   return present.length > 0 ? present : [all[0]];
 }
@@ -1099,7 +1155,7 @@ function removeCopilotInstructions(path, dryRun) {
   if (dryRun) return true;
   const after = removePairBlock(before);
   if (after.trim() === "" || after.trim() === COPILOT_FRONTMATTER.trim()) rmSync4(path);
-  else writeFileSync3(path, after);
+  else writeFileSync4(path, after);
   return true;
 }
 var copilotPair = {
@@ -1108,8 +1164,8 @@ var copilotPair = {
   installPair(o) {
     const lines = [];
     for (const dir of vscodeUserDirs(o)) {
-      const mcpPath = join5(dir, "mcp.json");
-      const instrPath = join5(dir, "prompts", "crew-pair.instructions.md");
+      const mcpPath = join6(dir, "mcp.json");
+      const instrPath = join6(dir, "prompts", "crew-pair.instructions.md");
       const settings = readVscodeMcp(mcpPath);
       if (!settings) {
         lines.push(`pair(copilot): ${mcpPath} is not a plain JSON object (comments are not supported) \u2014 fix it by hand; nothing was written there`);
@@ -1137,8 +1193,8 @@ var copilotPair = {
   },
   verifyPair(o) {
     const verdicts = vscodeUserDirs(o).map((dir) => {
-      const instrPath = join5(dir, "prompts", "crew-pair.instructions.md");
-      const mcpPath = join5(dir, "mcp.json");
+      const instrPath = join6(dir, "prompts", "crew-pair.instructions.md");
+      const mcpPath = join6(dir, "mcp.json");
       const b = blockVerdict(instrPath, "copilot");
       if (!b.ok) return b;
       const settings = readVscodeMcp(mcpPath);
@@ -1153,8 +1209,8 @@ var copilotPair = {
   removePair(o) {
     const lines = [];
     for (const dir of vscodeUserDirs(o)) {
-      const mcpPath = join5(dir, "mcp.json");
-      const hadBlock = removeCopilotInstructions(join5(dir, "prompts", "crew-pair.instructions.md"), o.dryRun);
+      const mcpPath = join6(dir, "mcp.json");
+      const hadBlock = removeCopilotInstructions(join6(dir, "prompts", "crew-pair.instructions.md"), o.dryRun);
       const settings = readVscodeMcp(mcpPath);
       const st = settings ? copilotMcpState(settings, o.url) : { state: "missing" };
       const hadMcp = st.state === "registered";
@@ -1165,7 +1221,7 @@ var copilotPair = {
         if (Object.keys(rest).length > 0) next.servers = rest;
         else delete next.servers;
         if (Object.keys(next).length === 0) rmSync4(mcpPath);
-        else writeFileSync3(mcpPath, `${JSON.stringify(next, null, 2)}
+        else writeFileSync4(mcpPath, `${JSON.stringify(next, null, 2)}
 `);
       }
       const what = hadBlock && hadMcp ? `the Pair instructions and ${SERVER} server` : hadBlock ? "the Pair instructions" : `the ${SERVER} server`;
@@ -1453,8 +1509,8 @@ function explain(ship, required) {
 }
 
 // src/repo-config.ts
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
-import { join as join6, basename as basename2 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
+import { join as join7, basename as basename2 } from "path";
 import { parse } from "yaml";
 var SPEC_VERSION = 1;
 var REPO_CONFIG_FILENAMES = [".crew.yaml", ".crew.yml", ".crew.json"];
@@ -1537,7 +1593,7 @@ var MODES = ["local", "integrate", "ci_manual", "ci_auto", "external"];
 var PROVIDERS = ["github", "buildkite", "other", "none"];
 function findRepoConfig(dir) {
   for (const name of REPO_CONFIG_FILENAMES) {
-    const p = join6(dir, name);
+    const p = join7(dir, name);
     if (existsSync6(p)) return p;
   }
   return null;
@@ -1776,7 +1832,7 @@ function parseRepoConfig(text, file) {
 function loadRepoConfig(dir) {
   const file = findRepoConfig(dir);
   if (!file) return null;
-  return parseRepoConfig(readFileSync5(file, "utf8"), file);
+  return parseRepoConfig(readFileSync6(file, "utf8"), file);
 }
 function hookLabel(cfg, hook2) {
   return cfg.labels[hook2] ?? cfg.hooks[hook2] ?? hook2;
@@ -2230,11 +2286,11 @@ function expand(p, base) {
   return isAbsolute(out) ? out : resolve(base, out);
 }
 function resolvePromptsDir(promptSet, crewHome, base) {
-  if (!promptSet) return join7(crewHome, "prompts", "default");
+  if (!promptSet) return join8(crewHome, "prompts", "default");
   if (promptSet.includes("/") || promptSet.startsWith(".") || promptSet.startsWith("~")) {
     return expand(promptSet, base);
   }
-  return join7(crewHome, "prompts", promptSet);
+  return join8(crewHome, "prompts", promptSet);
 }
 var Missing = class {
   paths = [];
@@ -2258,7 +2314,7 @@ var Missing = class {
 };
 function crewVersion(crewHome) {
   try {
-    const pkg = JSON.parse(readFileSync6(join7(crewHome, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync7(join8(crewHome, "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -2268,8 +2324,8 @@ function configSearchPath(crewHome) {
   if (process.env.CREW_CONFIG) return [resolve(process.env.CREW_CONFIG)];
   const xdg = process.env.XDG_CONFIG_HOME;
   return [
-    ...xdg ? [join7(xdg, "crew", "crew.yaml")] : [],
-    join7(homedir5(), ".config", "crew", "crew.yaml"),
+    ...xdg ? [join8(xdg, "crew", "crew.yaml")] : [],
+    join8(homedir5(), ".config", "crew", "crew.yaml"),
     resolve(crewHome, "crew.yaml")
   ];
 }
@@ -2277,17 +2333,17 @@ function findConfigFile(crewHome) {
   const candidates = configSearchPath(crewHome);
   return candidates.find((c) => existsSync7(c)) ?? candidates[candidates.length - 1];
 }
-var defaultConfigPath = () => join7(process.env.XDG_CONFIG_HOME ?? join7(homedir5(), ".config"), "crew", "crew.yaml");
+var defaultConfigPath = () => join8(process.env.XDG_CONFIG_HOME ?? join8(homedir5(), ".config"), "crew", "crew.yaml");
 function routeSlug(route) {
   return route.replace(/\//g, "-");
 }
 function resolvedPathFor(stateDir, route) {
   const [workspace, project] = splitRoute(route);
-  return join7(stateDir, "resolved", workspace, `${project}.json`);
+  return join8(stateDir, "resolved", workspace, `${project}.json`);
 }
 function apiKeyPathFor(stateDir, route) {
   const [workspace, project] = splitRoute(route);
-  return join7(stateDir, "keys", workspace, `${project}.env`);
+  return join8(stateDir, "keys", workspace, `${project}.env`);
 }
 function splitRoute(route) {
   const parts = route.split("/");
@@ -2300,7 +2356,7 @@ function readResolvedFile(stateDir, route) {
   const path = resolvedPathFor(stateDir, route);
   if (!existsSync7(path)) return void 0;
   try {
-    return JSON.parse(readFileSync6(path, "utf8"));
+    return JSON.parse(readFileSync7(path, "utf8"));
   } catch (e) {
     throw new ConfigError(`${path}: not valid JSON \u2014 ${e.message}`);
   }
@@ -2365,12 +2421,12 @@ function loadConfig(crewHome, configFile, opts = {}) {
 ` + configSearchPath(crewHome).map((c) => `  - ${c}`).join("\n") + `
 
 Create the first of those:
-  mkdir -p ${dirname3(defaultConfigPath())} && cp ${join7(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
+  mkdir -p ${dirname3(defaultConfigPath())} && cp ${join8(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
     );
   }
   let raw;
   try {
-    raw = parse2(opts.text ?? readFileSync6(file, "utf8"));
+    raw = parse2(opts.text ?? readFileSync7(file, "utf8"));
   } catch (e) {
     throw new ConfigError(`${file}: not valid YAML \u2014 ${e.message}`);
   }
@@ -2448,7 +2504,7 @@ Create the first of those:
       useNvm: shipRaw.useNvm !== false,
       nvmSh: shipRaw.nvmSh,
       stateDir,
-      logFile: expand(shipRaw.logFile ?? join7(tmpdir(), "crew.log"), base),
+      logFile: expand(shipRaw.logFile ?? join8(tmpdir(), "crew.log"), base),
       userAgent: shipRaw.userAgent ?? `Mozilla/5.0 CrewAgent/${crewVersion(crewHome)}`,
       maxConcurrentAgents,
       streamRetentionDays,
@@ -2589,7 +2645,7 @@ function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, t
   const hasRepos = Object.keys(repoDirs).length > 0;
   const reposBasePath = expand(String(c?.reposBasePath ?? raw.ship?.reposBasePath ?? DEFAULT_REPOS_BASE_PATH), base);
   const dirIsCloneBase = !c?.dir && !hasRepos && c?.repos && typeof c.repos === "object" && !Array.isArray(c.repos);
-  const dir = c?.dir ? expand(String(c.dir), base) : hasRepos ? Object.values(repoDirs)[0] : dirIsCloneBase ? join7(reposBasePath, splitRoute(route)[0]) : missing.req(void 0, `${where}.dir (or ${where}.repos)`) ?? "";
+  const dir = c?.dir ? expand(String(c.dir), base) : hasRepos ? Object.values(repoDirs)[0] : dirIsCloneBase ? join8(reposBasePath, splitRoute(route)[0]) : missing.req(void 0, `${where}.dir (or ${where}.repos)`) ?? "";
   const weight = c?.weight === void 0 ? void 0 : Number(c.weight);
   if (weight !== void 0 && !(Number.isFinite(weight) && weight > 0)) {
     missing.add(`${where}.weight must be a positive number (got "${c?.weight}")`);
@@ -2673,7 +2729,7 @@ function repoIdForName(r, name) {
 function resolveApiKey(r) {
   if (r.apiKey) return r.apiKey;
   if (r.apiKeyFile && r.apiKeyVar && existsSync7(r.apiKeyFile)) {
-    for (const line of readFileSync6(r.apiKeyFile, "utf8").split("\n")) {
+    for (const line of readFileSync7(r.apiKeyFile, "utf8").split("\n")) {
       const m = line.match(new RegExp(`^${r.apiKeyVar}=(.*)$`));
       if (m) return (m[1] ?? "").trim().replace(/^["']|["']$/g, "");
     }
@@ -2688,7 +2744,7 @@ function credentialSource(r) {
   if (r.apiKey) return KEYCHAIN_ELIGIBLE_ROUTES.has(r) ? "keychain" : "inline";
   if (r.apiKeyFile && r.apiKeyVar && existsSync7(r.apiKeyFile)) {
     const re = new RegExp(`^${r.apiKeyVar}=`);
-    if (readFileSync6(r.apiKeyFile, "utf8").split("\n").some((l) => re.test(l))) return "apiKeyFile";
+    if (readFileSync7(r.apiKeyFile, "utf8").split("\n").some((l) => re.test(l))) return "apiKeyFile";
   }
   return process.env.CREW_API_KEY?.trim() ? "CREW_API_KEY" : "none";
 }
@@ -2744,7 +2800,7 @@ function configuredMembers(rt) {
   return out;
 }
 function defaultRepoDir(basePath, workspace, repoName) {
-  return join7(basePath, workspace, repoName);
+  return join8(basePath, workspace, repoName);
 }
 function reposOf(r) {
   const named = Object.entries(r.repos);
@@ -2777,7 +2833,7 @@ function passengerRepoTargets(r) {
   return reposOf(r).filter((t) => r.repoOverrides[t.name]?.hostPassengers !== false);
 }
 function passengerCheckoutDir(basePath, workspace, repoName) {
-  return join7(basePath, workspace, ".passenger-checkouts", repoName);
+  return join8(basePath, workspace, ".passenger-checkouts", repoName);
 }
 function passengerCheckoutTargets(r) {
   if (!r.hostPassengers) return [];
@@ -3125,8 +3181,8 @@ function renderEnvironment(i) {
 }
 
 // src/agent-log.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync8, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join9 } from "path";
 
 // src/pending-backoff.ts
 var sleepBackoff = (attempts) => Math.min(6e4 * 2 ** Math.max(0, attempts - 1), 30 * 6e4);
@@ -3193,20 +3249,20 @@ async function reportAgentRun(target, run2) {
   }
   return { agentLogId: entry.id };
 }
-var queueDir = (stateDir) => join8(stateDir, "pending-agent-logs");
+var queueDir = (stateDir) => join9(stateDir, "pending-agent-logs");
 function queueAgentRun(stateDir, name, q) {
-  mkdirSync3(queueDir(stateDir), { recursive: true });
-  writeFileSync4(join8(queueDir(stateDir), `${name}.json`), JSON.stringify(q));
+  mkdirSync4(queueDir(stateDir), { recursive: true });
+  writeFileSync5(join9(queueDir(stateDir), `${name}.json`), JSON.stringify(q));
 }
 async function replayQueuedAgentRuns(stateDir, route, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = queueDir(stateDir);
   if (!existsSync8(dir)) return 0;
   let sent = 0;
   for (const f of readdirSync2(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join8(dir, f);
+    const path = join9(dir, f);
     let q;
     try {
-      q = JSON.parse(readFileSync7(path, "utf8"));
+      q = JSON.parse(readFileSync8(path, "utf8"));
     } catch {
       continue;
     }
@@ -3225,7 +3281,7 @@ async function replayQueuedAgentRuns(stateDir, route, keyFor, log, now = /* @__P
         continue;
       }
       const attempts = q.attempts + 1;
-      writeFileSync4(path, JSON.stringify({
+      writeFileSync5(path, JSON.stringify({
         ...q,
         attempts,
         warned: true,
@@ -3406,25 +3462,25 @@ var HandoffTranscriptTracker = class {
 };
 
 // src/pending-handoff.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync11, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readdirSync as readdirSync5, readFileSync as readFileSync12, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
+import { join as join15 } from "path";
 
 // src/git.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import {
   existsSync as existsSync9,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   openSync as openSync2,
   closeSync as closeSync2,
   writeSync,
   statSync as statSync2,
   unlinkSync,
-  readFileSync as readFileSync8,
-  writeFileSync as writeFileSync5,
+  readFileSync as readFileSync9,
+  writeFileSync as writeFileSync6,
   readdirSync as readdirSync3,
   rmSync as rmSync6
 } from "fs";
-import { dirname as dirname4, basename as basename5, join as join9 } from "path";
+import { dirname as dirname4, basename as basename5, join as join10 } from "path";
 var GitError = class extends Error {
 };
 function streamText(x) {
@@ -3808,11 +3864,11 @@ function sweepStaleReleaseRoots(tmp, now = Date.now(), maxAgeMs = 60 * 60 * 1e3)
   }
   for (const name of names) {
     if (!name.startsWith("crew-release-")) continue;
-    const root = join9(tmp, name);
+    const root = join10(tmp, name);
     try {
       const st = statSync2(root);
       if (!st.isDirectory() || now - st.mtimeMs < maxAgeMs) continue;
-      if (existsSync9(join9(root, "checkout"))) continue;
+      if (existsSync9(join10(root, "checkout"))) continue;
       rmSync6(root, { recursive: true, force: true });
       removed.push(name);
     } catch {
@@ -3861,7 +3917,7 @@ function ensureRepoCheckout(dir, remote, opts = {}) {
       `${dir} does not exist and this repo has no discovered remote to clone from \u2014 re-run \`crew connect\`, or check out the repository yourself and point \`repos:\` at it`
     );
   }
-  mkdirSync4(dirname4(dir), { recursive: true });
+  mkdirSync5(dirname4(dir), { recursive: true });
   const url = cloneUrlFor(remote, opts);
   try {
     execFileSync2("git", ["clone", url, dir], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
@@ -3886,7 +3942,7 @@ function sleepSync(ms2) {
 }
 function acquireCheckoutLock(dir, timeoutMs = 3e4) {
   const lockPath = checkoutLockPath(dir);
-  mkdirSync4(dirname4(lockPath), { recursive: true });
+  mkdirSync5(dirname4(lockPath), { recursive: true });
   const deadline = Date.now() + timeoutMs;
   for (; ; ) {
     try {
@@ -3926,14 +3982,14 @@ function syncPassengerCheckout(dir, githubRemote, gitRemoteName, base, clone = {
     if (!existsSync9(`${dir}/.git`) && githubRemote) {
       const url = cloneUrlFor(githubRemote, clone);
       const marker = cloneFailureMarker(dir);
-      if (existsSync9(marker) && readFileSync8(marker, "utf8").split("\n")[0] === url) {
-        return { action: "clone-failed", detail: readFileSync8(marker, "utf8").split("\n").slice(1).join("\n"), repeat: true };
+      if (existsSync9(marker) && readFileSync9(marker, "utf8").split("\n")[0] === url) {
+        return { action: "clone-failed", detail: readFileSync9(marker, "utf8").split("\n").slice(1).join("\n"), repeat: true };
       }
       try {
         ensureRepoCheckout(dir, githubRemote, clone);
       } catch (e) {
         if (!(e instanceof GitError)) throw e;
-        writeFileSync5(marker, `${url}
+        writeFileSync6(marker, `${url}
 ${e.message}`);
         return { action: "clone-failed", detail: e.message, repeat: false };
       }
@@ -4354,11 +4410,11 @@ function recoveredFailureHeadlines(o, route) {
 }
 
 // src/install.ts
-import { dirname as dirname5, join as join10, extname } from "path";
+import { dirname as dirname5, join as join11, extname } from "path";
 import { homedir as homedir6 } from "os";
-import { accessSync, constants, existsSync as existsSync10, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync3, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, realpathSync } from "fs";
+import { accessSync, constants, existsSync as existsSync10, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync3, writeFileSync as writeFileSync7, unlinkSync as unlinkSync2, realpathSync } from "fs";
 import { spawnSync as spawnSync4 } from "child_process";
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 
 // src/runtime-info.ts
 function isCompiledBinary(moduleUrl) {
@@ -4368,7 +4424,7 @@ function isCompiledBinary(moduleUrl) {
 // src/install.ts
 function crewInvocation(crewHome) {
   if (isCompiledBinary(import.meta.url)) return [process.execPath];
-  return [process.execPath, join10(crewHome, "bin", "crew")];
+  return [process.execPath, join11(crewHome, "bin", "crew")];
 }
 var INTERVAL_SECONDS = 120;
 function labelFor(crewHome, job) {
@@ -4379,7 +4435,7 @@ function labelFor(crewHome, job) {
       return crewHome;
     }
   })();
-  const hash = createHash("sha1").update(real).digest("hex").slice(0, 8);
+  const hash = createHash2("sha1").update(real).digest("hex").slice(0, 8);
   const stem = job === "release" ? "com.tablation.crew-release" : job === "passengers" ? "com.tablation.crew-passengers" : "com.tablation.crew";
   return `${stem}.${hash}`;
 }
@@ -4406,7 +4462,7 @@ function pathFor(ship) {
   return parts.join(":");
 }
 function findOnPath(bin, searchPath) {
-  const candidates = bin.includes("/") ? [bin] : searchPath.split(":").filter(Boolean).map((dir) => join10(dir, bin));
+  const candidates = bin.includes("/") ? [bin] : searchPath.split(":").filter(Boolean).map((dir) => join11(dir, bin));
   for (const candidate of candidates) {
     try {
       accessSync(candidate, constants.X_OK);
@@ -4416,7 +4472,7 @@ function findOnPath(bin, searchPath) {
   }
   return void 0;
 }
-var COMMON_DOCKER_DIRS = ["/usr/local/bin", "/opt/homebrew/bin", join10(homedir6(), ".docker", "bin")].join(":");
+var COMMON_DOCKER_DIRS = ["/usr/local/bin", "/opt/homebrew/bin", join11(homedir6(), ".docker", "bin")].join(":");
 function dockerPathProblem(ship, shellPath = process.env.PATH ?? "") {
   const schedulerPath = pathFor(ship);
   if (findOnPath("docker", schedulerPath)) return void 0;
@@ -4428,7 +4484,7 @@ function xmlEscape(s) {
 }
 function planLaunchd(ship, crewHome, job) {
   const label = labelFor(crewHome, job);
-  const unitPath = join10(homedir6(), "Library", "LaunchAgents", `${label}.plist`);
+  const unitPath = join11(homedir6(), "Library", "LaunchAgents", `${label}.plist`);
   const crewLog = ship.logFile;
   const schedulerLog = schedulerLogFor(crewLog, job);
   const persistent = job === "run";
@@ -4482,8 +4538,8 @@ ${scheduleKeys}
 }
 function planSystemd(ship, crewHome, job) {
   const label = labelFor(crewHome, job);
-  const unitDir = join10(homedir6(), ".config", "systemd", "user");
-  const servicePath = join10(unitDir, `${label}.service`);
+  const unitDir = join11(homedir6(), ".config", "systemd", "user");
+  const servicePath = join11(unitDir, `${label}.service`);
   const crewLog = ship.logFile;
   const schedulerLog = schedulerLogFor(crewLog, job);
   const description = job === "release" ? "Tablation crew \u2014 release" : job === "passengers" ? "Tablation crew \u2014 Host Passengers sync" : "Tablation crew \u2014 persistent supervisor loop";
@@ -4523,7 +4579,7 @@ WantedBy=default.target
       schedulerLog
     };
   }
-  const timerPath = join10(unitDir, `${label}.timer`);
+  const timerPath = join11(unitDir, `${label}.timer`);
   const service = `# Written by \`crew install\` \u2014 re-run it rather than hand-editing this file.
 [Unit]
 Description=${description}
@@ -4597,7 +4653,7 @@ function planInstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
 function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
   const label = labelFor(crewHome, job);
   if (hostShip === "macos") {
-    const unitPath = join10(homedir6(), "Library", "LaunchAgents", `${label}.plist`);
+    const unitPath = join11(homedir6(), "Library", "LaunchAgents", `${label}.plist`);
     return {
       mechanism: "launchd",
       unitPaths: [unitPath],
@@ -4607,18 +4663,18 @@ function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
     };
   }
   if (hostShip === "linux" && hasSystemd) {
-    const unitDir = join10(homedir6(), ".config", "systemd", "user");
+    const unitDir = join11(homedir6(), ".config", "systemd", "user");
     if (job === "run") {
       return {
         mechanism: "systemd",
-        unitPaths: [join10(unitDir, `${label}.service`)],
+        unitPaths: [join11(unitDir, `${label}.service`)],
         crontabLine: null,
         unloadCommands: [["systemctl", "--user", "disable", "--now", `${label}.service`]]
       };
     }
     return {
       mechanism: "systemd",
-      unitPaths: [join10(unitDir, `${label}.service`), join10(unitDir, `${label}.timer`)],
+      unitPaths: [join11(unitDir, `${label}.service`), join11(unitDir, `${label}.timer`)],
       crontabLine: null,
       unloadCommands: [["systemctl", "--user", "disable", "--now", `${label}.timer`]]
     };
@@ -4636,7 +4692,7 @@ function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
 function planDaemonControl(crewHome, hostShip, hasSystemd) {
   const label = labelFor(crewHome, "run");
   if (hostShip === "macos") {
-    const unitPath = join10(homedir6(), "Library", "LaunchAgents", `${label}.plist`);
+    const unitPath = join11(homedir6(), "Library", "LaunchAgents", `${label}.plist`);
     return {
       mechanism: "launchd",
       startCommand: ["launchctl", "load", unitPath],
@@ -4676,8 +4732,8 @@ async function applyInstall(plan, crewHome, dryRun, log) {
       log.emit(`would write ${path}`);
       continue;
     }
-    mkdirSync5(dirname5(path), { recursive: true });
-    writeFileSync6(path, plan.unitContent[path]);
+    mkdirSync6(dirname5(path), { recursive: true });
+    writeFileSync7(path, plan.unitContent[path]);
     log.emit(`wrote ${path}`);
   }
   if (plan.crontabLine) {
@@ -4750,7 +4806,7 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
 }
 var CREW_LAUNCHD_PREFIX = "com.tablation.crew";
 function launchAgentsDir() {
-  return join10(homedir6(), "Library", "LaunchAgents");
+  return join11(homedir6(), "Library", "LaunchAgents");
 }
 function xmlUnescape(s) {
   return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
@@ -4769,10 +4825,10 @@ function loadedCrewLabels() {
 function listLaunchdUnits(dir = launchAgentsDir(), loaded = []) {
   const files = existsSync10(dir) ? readdirSync4(dir) : [];
   const units = files.filter((f) => f.startsWith(CREW_LAUNCHD_PREFIX) && f.endsWith(".plist")).sort().map((f) => {
-    const plistPath = join10(dir, f);
+    const plistPath = join11(dir, f);
     let program = null;
     try {
-      program = programFromPlist(readFileSync9(plistPath, "utf8"));
+      program = programFromPlist(readFileSync10(plistPath, "utf8"));
     } catch {
     }
     return {
@@ -4785,7 +4841,7 @@ function listLaunchdUnits(dir = launchAgentsDir(), loaded = []) {
   const seen = new Set(units.map((u) => u.label));
   for (const label of [...loaded].sort()) {
     if (!label.startsWith(CREW_LAUNCHD_PREFIX) || seen.has(label)) continue;
-    units.push({ label, plistPath: join10(dir, `${label}.plist`), program: null, programExists: false, orphan: true });
+    units.push({ label, plistPath: join11(dir, `${label}.plist`), program: null, programExists: false, orphan: true });
   }
   return units;
 }
@@ -5131,17 +5187,17 @@ var SHELL_WORDS = /* @__PURE__ */ new Set([
 ]);
 
 // src/state.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, existsSync as existsSync12, mkdirSync as mkdirSync6, rmSync as rmSync7, statSync as statSync4 } from "fs";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync7, rmSync as rmSync7, statSync as statSync4 } from "fs";
+import { join as join12 } from "path";
 var EPOCH = "1970-01-01T00:00:00.000Z";
 var State = class _State {
   dir;
   constructor(dir) {
     this.dir = dir;
-    mkdirSync6(dir, { recursive: true });
+    mkdirSync7(dir, { recursive: true });
   }
   path(...parts) {
-    return join11(this.dir, ...parts);
+    return join12(this.dir, ...parts);
   }
   /**
    * The timestamp every "new since last poll" check is measured against.
@@ -5152,14 +5208,14 @@ var State = class _State {
    */
   watermark() {
     try {
-      const v = readFileSync10(this.path(".poll-watermark"), "utf8").trim();
+      const v = readFileSync11(this.path(".poll-watermark"), "utf8").trim();
       return v || EPOCH;
     } catch {
       return EPOCH;
     }
   }
   setWatermark(at) {
-    writeFileSync7(this.path(".poll-watermark"), `${at}
+    writeFileSync8(this.path(".poll-watermark"), `${at}
 `);
   }
   /**
@@ -5186,7 +5242,7 @@ var State = class _State {
     return new Set(roles.filter((r) => this.isRolePaused(r)));
   }
   pause(role) {
-    writeFileSync7(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
+    writeFileSync8(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
   }
   resume(role) {
     rmSync7(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
@@ -5200,7 +5256,7 @@ var State = class _State {
     return existsSync12(this.path(".release-paused"));
   }
   setReleasePaused(paused) {
-    if (paused) writeFileSync7(this.path(".release-paused"), "");
+    if (paused) writeFileSync8(this.path(".release-paused"), "");
     else rmSync7(this.path(".release-paused"), { force: true });
   }
   /**
@@ -5238,7 +5294,7 @@ var State = class _State {
     const name = _State.safe(rawName);
     const file = this.path(`.${name}.lock`);
     try {
-      const existing = Number.parseInt(readFileSync10(file, "utf8").trim(), 10);
+      const existing = Number.parseInt(readFileSync11(file, "utf8").trim(), 10);
       if (Number.isFinite(existing) && existing > 0) {
         try {
           process.kill(existing, 0);
@@ -5248,7 +5304,7 @@ var State = class _State {
       }
     } catch {
     }
-    writeFileSync7(file, `${process.pid}
+    writeFileSync8(file, `${process.pid}
 `);
     return {
       ok: true,
@@ -5332,7 +5388,7 @@ var State = class _State {
     const heldReported = `.release-held-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync10(this.path(f), "utf8").trim() || null;
+        return readFileSync11(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -5341,7 +5397,7 @@ var State = class _State {
       blockedCount: () => Number.parseInt(read(blocked) ?? "", 10) || 0,
       noteBlocked: () => {
         const n = (Number.parseInt(read(blocked) ?? "", 10) || 0) + 1;
-        writeFileSync7(this.path(blocked), `${n}
+        writeFileSync8(this.path(blocked), `${n}
 `);
         return n;
       },
@@ -5358,7 +5414,7 @@ var State = class _State {
        */
       deployFailedSha: () => read(failed),
       noteDeployFailed: (sha) => {
-        writeFileSync7(this.path(failed), `${sha}
+        writeFileSync8(this.path(failed), `${sha}
 `);
       },
       clearDeployFailed: () => {
@@ -5372,7 +5428,7 @@ var State = class _State {
       noteTestGateFailed: (sha) => {
         const [prev, n] = (read(gateFailed) ?? "").split(" ");
         const next = prev === sha ? (Number.parseInt(n ?? "", 10) || 0) + 1 : 1;
-        writeFileSync7(this.path(gateFailed), `${sha} ${next}
+        writeFileSync8(this.path(gateFailed), `${sha} ${next}
 `);
         return next;
       },
@@ -5382,13 +5438,13 @@ var State = class _State {
       /** Whether the board was already told about this head's red gate. */
       heldReported: () => {
         try {
-          return readFileSync10(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
+          return readFileSync11(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
         } catch {
           return null;
         }
       },
       noteHeldReported: (signature) => {
-        writeFileSync7(this.path(heldReported), `${signature}
+        writeFileSync8(this.path(heldReported), `${signature}
 `);
       },
       clearHeldReported: () => {
@@ -5396,7 +5452,7 @@ var State = class _State {
       },
       testGateReported: (sha) => read(gateReported) === sha,
       noteTestGateReported: (sha) => {
-        writeFileSync7(this.path(gateReported), `${sha}
+        writeFileSync8(this.path(gateReported), `${sha}
 `);
       }
     };
@@ -5419,7 +5475,7 @@ var State = class _State {
     const ticketStreakFile = `.fairness-ticket-streak-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync10(this.path(f), "utf8").trim() || null;
+        return readFileSync11(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -5452,18 +5508,18 @@ var State = class _State {
           clear2();
           return;
         }
-        writeFileSync7(this.path(streakFile), `${this.readInt(streakFile) + 1}
+        writeFileSync8(this.path(streakFile), `${this.readInt(streakFile) + 1}
 `);
         const prior = read(ticketFile);
         if (topTicket && topTicket === prior) {
-          writeFileSync7(this.path(ticketStreakFile), `${this.readInt(ticketStreakFile) + 1}
+          writeFileSync8(this.path(ticketStreakFile), `${this.readInt(ticketStreakFile) + 1}
 `);
         } else if (topTicket) {
-          writeFileSync7(this.path(ticketFile), `${topTicket}
+          writeFileSync8(this.path(ticketFile), `${topTicket}
 `);
-          writeFileSync7(this.path(sinceFile), `${(/* @__PURE__ */ new Date()).toISOString()}
+          writeFileSync8(this.path(sinceFile), `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
-          writeFileSync7(this.path(ticketStreakFile), "1\n");
+          writeFileSync8(this.path(ticketStreakFile), "1\n");
         }
       }
     };
@@ -5484,14 +5540,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync10(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync11(this.path(file), "utf8"));
           return parsed && typeof parsed === "object" ? parsed : {};
         } catch {
           return {};
         }
       },
       persist: (next) => {
-        writeFileSync7(this.path(file), JSON.stringify(next));
+        writeFileSync8(this.path(file), JSON.stringify(next));
       }
     };
   }
@@ -5505,14 +5561,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync10(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync11(this.path(file), "utf8"));
           return Array.isArray(parsed) ? parsed : [];
         } catch {
           return [];
         }
       },
       persist: (next) => {
-        writeFileSync7(this.path(file), JSON.stringify(next));
+        writeFileSync8(this.path(file), JSON.stringify(next));
       }
     };
   }
@@ -5525,7 +5581,7 @@ var State = class _State {
     const file = ".release-last-run";
     return {
       touch: () => {
-        writeFileSync7(this.path(file), (/* @__PURE__ */ new Date()).toISOString());
+        writeFileSync8(this.path(file), (/* @__PURE__ */ new Date()).toISOString());
       },
       at: () => {
         try {
@@ -5538,7 +5594,7 @@ var State = class _State {
   }
   readInt(file) {
     try {
-      return Number.parseInt(readFileSync10(this.path(file), "utf8").trim(), 10) || 0;
+      return Number.parseInt(readFileSync11(this.path(file), "utf8").trim(), 10) || 0;
     } catch {
       return 0;
     }
@@ -6540,12 +6596,12 @@ function holdWarnings(tickets, ships, contract, humanHolds, now = Date.now()) {
 
 // src/run-worktree.ts
 import { existsSync as existsSync14 } from "fs";
-import { dirname as dirname6, join as join13 } from "path";
+import { dirname as dirname6, join as join14 } from "path";
 
 // src/ports.ts
 import { execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync13 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var run = (cmd, args) => {
   try {
     return execFileSync3(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
@@ -6590,7 +6646,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(join12(parent, name, ".git"))) return true;
+    if (existsSync13(join13(parent, name, ".git"))) return true;
   }
   return false;
 }
@@ -6682,7 +6738,7 @@ function planRunWorktree(dir, cfg, t, role, opts = {}) {
     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 = join13(dirname6(dir), worktreeForTicket(dir, cfg, t, role));
+  const path = join14(dirname6(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 };
   }
@@ -7026,12 +7082,12 @@ async function guardRunStrays(route, ship, tracker, role, workingId, since2, log
 
 // src/pending-handoff.ts
 var PENDING_MAX_AGE_MS = 48 * 36e5;
-var pendingDirFor = (stateDir) => join14(stateDir, "pending-handoffs");
-var stateDirOfStream = (streamPath) => join14(streamPath, "..", "..");
+var pendingDirFor = (stateDir) => join15(stateDir, "pending-handoffs");
+var stateDirOfStream = (streamPath) => join15(streamPath, "..", "..");
 function writePendingHandoff(stateDir, rec) {
   const dir = pendingDirFor(stateDir);
-  mkdirSync7(dir, { recursive: true });
-  writeFileSync8(join14(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
+  mkdirSync8(dir, { recursive: true });
+  writeFileSync9(join15(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
 }
 function listPendingHandoffs(stateDir, route) {
   const dir = pendingDirFor(stateDir);
@@ -7039,7 +7095,7 @@ function listPendingHandoffs(stateDir, route) {
   const out = [];
   for (const f of readdirSync5(dir).filter((n) => n.endsWith(".json")).sort()) {
     try {
-      const rec = JSON.parse(readFileSync11(join14(dir, f), "utf8"));
+      const rec = JSON.parse(readFileSync12(join15(dir, f), "utf8"));
       if (rec.version === 1 && rec.ticketRecordId && (!route || rec.route === route)) out.push(rec);
     } catch {
     }
@@ -7047,7 +7103,7 @@ function listPendingHandoffs(stateDir, route) {
   return out;
 }
 function removePendingHandoff(stateDir, ticketRecordId) {
-  rmSync8(join14(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
+  rmSync8(join15(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
 }
 function pendingHandoffFor(stateDir, ticketRecordId) {
   return listPendingHandoffs(stateDir).find((r) => r.ticketRecordId === ticketRecordId);
@@ -7157,8 +7213,8 @@ function expandSkillMarkers(text, lookup, opts = {}) {
 }
 
 // src/skills.ts
-import { readFileSync as readFileSync13, readdirSync as readdirSync6, existsSync as existsSync17 } from "fs";
-import { join as join16 } from "path";
+import { readFileSync as readFileSync14, readdirSync as readdirSync6, existsSync as existsSync17 } from "fs";
+import { join as join17 } from "path";
 import { parse as parseYaml } from "yaml";
 import { TablationClient as TablationClient3, StaleWriteError as StaleWriteError3, TablationApiError as TablationApiError2 } from "@tablation/client";
 
@@ -7174,8 +7230,8 @@ ${additions}`;
 }
 
 // src/agents.ts
-import { readFileSync as readFileSync12, existsSync as existsSync16 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync16 } from "fs";
+import { join as join16 } from "path";
 import { TablationClient as TablationClient2, StaleWriteError as StaleWriteError2, TablationApiError } from "@tablation/client";
 var PERSONA_NAME = {
   dev: "Developer",
@@ -7189,12 +7245,12 @@ var CREW_AGENT_COLUMN = "agent_id";
 var AgentsSyncError = class extends Error {
 };
 function personaDefaultPrompt(promptsDir, role) {
-  const briefPath = join15(promptsDir, "personas", `lane-${role}.md`);
+  const briefPath = join16(promptsDir, "personas", `lane-${role}.md`);
   if (!existsSync16(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
-  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync12(briefPath, "utf8");
-  const commonPath = join15(promptsDir, "personas", "common.md");
-  if (!existsSync16(commonPath)) return readFileSync12(briefPath, "utf8");
-  return `${readFileSync12(commonPath, "utf8")}${readFileSync12(briefPath, "utf8")}`;
+  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync13(briefPath, "utf8");
+  const commonPath = join16(promptsDir, "personas", "common.md");
+  if (!existsSync16(commonPath)) return readFileSync13(briefPath, "utf8");
+  return `${readFileSync13(commonPath, "utf8")}${readFileSync13(briefPath, "utf8")}`;
 }
 async function resolveAgentId(route, role, opts) {
   const cached = route.resolved?.agentPersonas?.[role]?.agentId;
@@ -7641,7 +7697,7 @@ function describeCrewLink(o) {
 var SkillSyncError = class extends Error {
 };
 function parseSkillFile(path) {
-  const text = readFileSync13(path, "utf8");
+  const text = readFileSync14(path, "utf8");
   const match = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/.exec(text);
   if (!match) throw new SkillSyncError(`${path}: missing YAML frontmatter (expected a leading --- block)`);
   const frontmatter = match[1];
@@ -7654,9 +7710,9 @@ function parseSkillFile(path) {
   return { name: meta.name, description: meta.description, prompt: body, file: path };
 }
 function listLocalSkills(promptsDir) {
-  const dir = join16(promptsDir, "skills");
+  const dir = join17(promptsDir, "skills");
   if (!existsSync17(dir)) return [];
-  return readdirSync6(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join16(dir, f)));
+  return readdirSync6(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join17(dir, f)));
 }
 async function syncSkills(route, opts) {
   if (!route.resolved) {
@@ -7859,23 +7915,23 @@ var AgentError = class extends Error {
 var AgentSpawnError = class extends AgentError {
 };
 function planAgentRun(o) {
-  const briefPath = join17(o.route.promptsDir, "personas", `lane-${o.role}.md`);
+  const briefPath = join18(o.route.promptsDir, "personas", `lane-${o.role}.md`);
   if (!existsSync18(briefPath)) {
     throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
   }
-  const commonPath = join17(o.route.promptsDir, "personas", "common.md");
+  const commonPath = join18(o.route.promptsDir, "personas", "common.md");
   const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync18(commonPath);
   const now = o.now ?? (() => Date.now());
   const routeLabel = routeSlug(o.route.route);
-  const digestPath2 = join17(o.stateDir, `digest-${routeLabel}-${o.role}.md`);
+  const digestPath2 = join18(o.stateDir, `digest-${routeLabel}-${o.role}.md`);
   let digest;
   let ageSeconds;
   if (existsSync18(digestPath2)) {
     ageSeconds = Math.floor((now() - statSync5(digestPath2).mtimeMs) / 1e3);
-    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync14(digestPath2, "utf8");
+    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync15(digestPath2, "utf8");
   }
-  const common = usesCommon ? readFileSync14(commonPath, "utf8") : "";
-  const brief = readFileSync14(briefPath, "utf8");
+  const common = usesCommon ? readFileSync15(commonPath, "utf8") : "";
+  const brief = readFileSync15(briefPath, "utf8");
   const effectiveCommon = o.divergedPrompt ? "" : common;
   const effectiveBrief = appendAdditions(o.divergedPrompt ?? brief, o.personaAdditions);
   const localSkills = new Map(listLocalSkills(o.route.promptsDir).map((s) => [s.name, s.prompt]));
@@ -7896,8 +7952,8 @@ function planAgentRun(o) {
     brief: expanded.text,
     digest
   });
-  const promptSha = createHash2("sha256").update(expanded.text).digest("hex");
-  const streamsDir = join17(o.stateDir, "streams");
+  const promptSha = createHash3("sha256").update(expanded.text).digest("hex");
+  const streamsDir = join18(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;
@@ -7953,8 +8009,8 @@ function planAgentRun(o) {
     digestAttached: digest !== void 0,
     digestAgeSeconds: ageSeconds,
     model,
-    streamPath: join17(streamsDir, `${base}.jsonl`),
-    eventsPath: join17(streamsDir, `${base}.events.jsonl`),
+    streamPath: join18(streamsDir, `${base}.jsonl`),
+    eventsPath: join18(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
     ticketRecordId: o.ticketRecordId ?? null,
     agentLog,
@@ -7983,7 +8039,7 @@ function describePlan(p) {
 var pidPathFor = (streamPath) => `${streamPath}.pid`;
 function readRunSidecar(streamPath) {
   try {
-    const sc = JSON.parse(readFileSync14(pidPathFor(streamPath), "utf8"));
+    const sc = JSON.parse(readFileSync15(pidPathFor(streamPath), "utf8"));
     return typeof sc.pid === "number" && typeof sc.spawnedAt === "string" && typeof sc.role === "string" ? sc : null;
   } catch {
     return null;
@@ -8019,7 +8075,7 @@ function identityOf(plan, adapterHarness) {
 var withoutKey = ({ apiKey: _apiKey, ...rest }) => rest;
 function openSink(path) {
   try {
-    mkdirSync8(dirname7(path), { recursive: true });
+    mkdirSync9(dirname7(path), { recursive: true });
     return createWriteStream(path, { flags: "a" });
   } catch {
     return void 0;
@@ -8198,7 +8254,7 @@ var RunObserver = class {
 };
 function writeRunMeta(id, startedAt, liveTicket, extra) {
   try {
-    writeFileSync9(`${id.streamPath}.meta.json`, JSON.stringify({
+    writeFileSync10(`${id.streamPath}.meta.json`, JSON.stringify({
       route: id.route,
       role: id.role,
       hint: id.ticket,
@@ -8317,7 +8373,7 @@ function spawnAgent(plan, emit) {
   return new Promise((resolve6, reject) => {
     let streamFd;
     try {
-      mkdirSync8(dirname7(plan.streamPath), { recursive: true });
+      mkdirSync9(dirname7(plan.streamPath), { recursive: true });
       streamFd = openSync3(plan.streamPath, "a");
     } catch (e) {
       void endSink(eventsSink);
@@ -8350,7 +8406,7 @@ function spawnAgent(plan, emit) {
         promptSha: plan.promptSha
       };
       try {
-        writeFileSync9(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
+        writeFileSync10(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
       } catch {
       }
     }
@@ -8567,7 +8623,7 @@ async function runSelftest(i, deps = realDeps) {
     ...adapter.runEnv(spec),
     [KEY_VAR]: i.apiKey
   };
-  const cwd = mkdtempSync(join18(tmpdir2(), "crew-selftest-"));
+  const cwd = mkdtempSync(join19(tmpdir2(), "crew-selftest-"));
   try {
     const run2 = await deps.run({
       bin: invocation.bin,
@@ -8599,11 +8655,11 @@ function formatResult(r) {
   const secs = `${(r.ms / 1e3).toFixed(1)}s`;
   return r.ok ? `${r.toolchain}: PASS ${r.detail} (${secs}${tok})` : `${r.toolchain}: FAIL ${r.failure} \u2014 ${r.detail} (${secs})`;
 }
-var fileFor = (stateDir) => join18(stateDir, "selftest.json");
+var fileFor2 = (stateDir) => join19(stateDir, "selftest.json");
 function readSelftest(stateDir) {
   try {
-    const p = fileFor(stateDir);
-    return existsSync19(p) ? JSON.parse(readFileSync15(p, "utf8")) : {};
+    const p = fileFor2(stateDir);
+    return existsSync19(p) ? JSON.parse(readFileSync16(p, "utf8")) : {};
   } catch {
     return {};
   }
@@ -8611,8 +8667,8 @@ function readSelftest(stateDir) {
 function recordSelftest(stateDir, results) {
   const all = readSelftest(stateDir);
   for (const r of results) all[r.toolchain] = r;
-  mkdirSync9(stateDir, { recursive: true });
-  writeFileSync10(fileFor(stateDir), `${JSON.stringify(all, null, 2)}
+  mkdirSync10(stateDir, { recursive: true });
+  writeFileSync11(fileFor2(stateDir), `${JSON.stringify(all, null, 2)}
 `);
 }
 function doctorSelftestLines(stored, toolchains) {
@@ -8624,7 +8680,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve5, dirname as dirname20, join as join35, basename as basename11 } from "path";
+import { resolve as resolve5, dirname as dirname20, join as join36, basename as basename11 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir9 } from "os";
 import { spawnSync as spawnSync6 } from "child_process";
@@ -8803,14 +8859,14 @@ function rosterMarkdown(roster, meId) {
 }
 
 // src/connect-resume.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync16, rmSync as rmSync10, writeFileSync as writeFileSync11 } from "fs";
-import { dirname as dirname8, join as join19 } from "path";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync17, rmSync as rmSync10, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname8, join as join20 } from "path";
 function lastSessionFile(stateDir) {
-  return join19(stateDir, "connect-session.json");
+  return join20(stateDir, "connect-session.json");
 }
 function readPointers(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync16(lastSessionFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync17(lastSessionFile(stateDir), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     const out = {};
     for (const [host, v] of Object.entries(parsed)) {
@@ -8824,8 +8880,8 @@ function readPointers(stateDir) {
 }
 function writePointers(stateDir, pointers) {
   const file = lastSessionFile(stateDir);
-  mkdirSync10(dirname8(file), { recursive: true });
-  writeFileSync11(file, `${JSON.stringify(pointers, null, 2)}
+  mkdirSync11(dirname8(file), { recursive: true });
+  writeFileSync12(file, `${JSON.stringify(pointers, null, 2)}
 `, { mode: 384 });
 }
 function rememberSession(stateDir, host, workspaceSlug) {
@@ -8881,15 +8937,15 @@ async function signOutSessions(o) {
 }
 
 // src/reset.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync17, readdirSync as readdirSync7, rmSync as rmSync11, statSync as statSync6, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname9, join as join20 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync18, readdirSync as readdirSync7, rmSync as rmSync11, statSync as statSync6, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname9, join as join21 } from "path";
 import { hostFromUrl as hostFromUrl2 } from "@tablation/client";
 function clonedCheckoutsFile(stateDir) {
-  return join20(stateDir, "cloned-checkouts.json");
+  return join21(stateDir, "cloned-checkouts.json");
 }
 function readClonedCheckouts(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync17(clonedCheckoutsFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync18(clonedCheckoutsFile(stateDir), "utf8"));
     return Array.isArray(parsed) ? parsed.filter((d) => typeof d === "string") : [];
   } catch {
     return [];
@@ -8899,8 +8955,8 @@ function recordClonedCheckout(stateDir, dir) {
   const known = readClonedCheckouts(stateDir);
   if (known.includes(dir)) return;
   const file = clonedCheckoutsFile(stateDir);
-  mkdirSync11(dirname9(file), { recursive: true });
-  writeFileSync12(file, `${JSON.stringify([...known, dir], null, 2)}
+  mkdirSync12(dirname9(file), { recursive: true });
+  writeFileSync13(file, `${JSON.stringify([...known, dir], null, 2)}
 `);
 }
 var mark = (dryRun) => dryRun ? "would-remove" : "removed";
@@ -8974,10 +9030,10 @@ function removeCheckout(dir, dryRun, fx) {
 }
 function removeState(stateDir, dryRun) {
   const out = [];
-  const targets = [join20(stateDir, "resolved"), join20(stateDir, "keys"), clonedCheckoutsFile(stateDir), join20(stateDir, "connect-session.json"), join20(stateDir, "reload-requested"), join20(stateDir, "daemon.started")];
+  const targets = [join21(stateDir, "resolved"), join21(stateDir, "keys"), clonedCheckoutsFile(stateDir), join21(stateDir, "connect-session.json"), join21(stateDir, "reload-requested"), join21(stateDir, "daemon.started")];
   try {
     for (const name of readdirSync7(stateDir)) {
-      if (name.startsWith(".") && statSync6(join20(stateDir, name)).isFile()) targets.push(join20(stateDir, name));
+      if (name.startsWith(".") && statSync6(join21(stateDir, name)).isFile()) targets.push(join21(stateDir, name));
     }
   } catch {
   }
@@ -9762,8 +9818,8 @@ ${waiting.map((t) => `| ${displayKey2(t)} | ${t.status} | ${blockers(t, i)} |`).
 }
 
 // src/poll.ts
-import { writeFileSync as writeFileSync13 } from "fs";
-import { join as join21 } from "path";
+import { writeFileSync as writeFileSync14 } from "fs";
+import { join as join22 } from "path";
 
 // src/stalled.ts
 var STALLED_AFTER_CYCLES = 30;
@@ -10054,7 +10110,7 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route, role) => join21(stateDir, `digest-${route}-${role}.md`);
+var digestPath = (stateDir, route, role) => join22(stateDir, `digest-${route}-${role}.md`);
 function writeDigest(o, d, role, stateDir) {
   const me = o.route.resolved?.seats[role];
   if (!me) return false;
@@ -10122,7 +10178,7 @@ function writeDigest(o, d, role, stateDir) {
     };
     const text = role === "qa" ? qaDigest(input) : buildingDigest(input);
     const path = digestPath(stateDir, routeSlug(o.route.route), role);
-    writeFileSync13(path, text);
+    writeFileSync14(path, text);
     o.emit.emit(`queue digest written for ${role} (${Buffer.byteLength(text)} bytes)`, {
       data: { role, bytes: Buffer.byteLength(text) }
     });
@@ -10528,8 +10584,8 @@ async function applyStrandedVerified(writer, s, contract, operatorId, memberId,
 }
 
 // src/connect-wizard.ts
-import { delimiter, dirname as dirname10, join as join22 } from "path";
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync21, mkdirSync as mkdirSync12, writeFileSync as writeFileSync14 } from "fs";
+import { delimiter, dirname as dirname10, join as join23 } from "path";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync21, mkdirSync as mkdirSync13, writeFileSync as writeFileSync15 } from "fs";
 import { stringify } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
 function shouldRunWizard(opts) {
@@ -10551,7 +10607,7 @@ function defaultIsExecutable(p) {
 function findOnPath2(name, pathEnv, isExecutable = defaultIsExecutable) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join22(dir, name);
+    const candidate = join23(dir, name);
     if (isExecutable(candidate)) return candidate;
   }
   return void 0;
@@ -10612,9 +10668,9 @@ routes:
 ${routeBlock}`;
 }
 function writeNewConfig(path, text) {
-  mkdirSync12(dirname10(path), { recursive: true });
+  mkdirSync13(dirname10(path), { recursive: true });
   try {
-    writeFileSync14(path, text, { mode: 384, flag: "wx" });
+    writeFileSync15(path, text, { mode: 384, flag: "wx" });
     return true;
   } catch (e) {
     if (e.code === "EEXIST") return false;
@@ -10648,7 +10704,7 @@ Wrote ${o.configPath}.
 // src/connect-json.ts
 import { accessSync as accessSync3, constants as constants3 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname11, join as join23 } from "path";
+import { dirname as dirname11, join as join24 } from "path";
 import { delimiter as delimiter2 } from "path";
 var CHOICE_EXIT_CODE = 3;
 function createEmitter(json, write) {
@@ -10687,12 +10743,12 @@ function agentBinSearchDirs(home, pathEnv, extraPath) {
   const dirs = [
     ...pathEnv.split(delimiter2),
     ...(extraPath ?? "").split(delimiter2),
-    join23(home, ".local/bin"),
-    join23(home, ".claude/local"),
+    join24(home, ".local/bin"),
+    join24(home, ".claude/local"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
-    join23(home, ".npm-global/bin"),
-    join23(home, ".volta/bin")
+    join24(home, ".npm-global/bin"),
+    join24(home, ".volta/bin")
   ];
   return [...new Set(dirs.filter(Boolean))];
 }
@@ -10728,8 +10784,8 @@ function flagWizardAnswers(f, env) {
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync15, existsSync as existsSync22, copyFileSync, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync2, rmSync as rmSync12 } from "fs";
-import { dirname as dirname12, join as join24 } from "path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync16, existsSync as existsSync22, copyFileSync, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync2, rmSync as rmSync12 } from "fs";
+import { dirname as dirname12, join as join25 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 
 // src/release.ts
@@ -11447,13 +11503,13 @@ async function bump(o, size) {
     }
     return printed;
   }
-  const files = o.repo.release.versionFiles.map((f) => join24(o.cwd, f));
+  const files = o.repo.release.versionFiles.map((f) => join25(o.cwd, f));
   const first = files[0];
   if (!existsSync22(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
     return null;
   }
-  const current = JSON.parse(readFileSync18(first, "utf8")).version;
+  const current = JSON.parse(readFileSync19(first, "utf8")).version;
   if (!current) {
     o.emit.error(`no version field in ${o.repo.release.versionFiles[0]}`);
     return null;
@@ -11466,27 +11522,27 @@ async function bump(o, size) {
     return version;
   }
   for (const f of files) {
-    const src = readFileSync18(f, "utf8");
+    const src = readFileSync19(f, "utf8");
     const out = src.replace(/("version"\s*:\s*")[^"]*(")/, `$1${version}$2`);
     if (out === src) {
       o.emit.error(`no version field in ${f}`);
       return null;
     }
-    writeFileSync15(f, out);
+    writeFileSync16(f, out);
   }
   return version;
 }
 function writeChangelog(o, version, entries) {
   const file = o.repo.release.changelog;
   if (!file || entries.length === 0) return;
-  const path = join24(o.cwd, file);
+  const path = join25(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}`);
     return;
   }
-  const existing = existsSync22(path) ? readFileSync18(path, "utf8") : "# Changelog\n";
-  writeFileSync15(path, insertChangelogSection(existing, section));
+  const existing = existsSync22(path) ? readFileSync19(path, "utf8") : "# Changelog\n";
+  writeFileSync16(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
   if (!o.repo.hooks.released) return void 0;
@@ -11579,8 +11635,8 @@ function closeReleaseCheckout(cwd, root, dir, branch, run2 = gitOk) {
 function openReleaseCheckout(o) {
   const { remote, base } = o.repo.branch;
   const branch = `crew/release-${Date.now()}`;
-  const root = mkdtempSync2(join24(tmpdir3(), "crew-release-"));
-  const dir = join24(root, "checkout");
+  const root = mkdtempSync2(join25(tmpdir3(), "crew-release-"));
+  const dir = join25(root, "checkout");
   o.emit.emit(`release checkout: ${dir}`, { step: "release" });
   const close = () => closeReleaseCheckout(o.cwd, root, dir, branch);
   try {
@@ -11590,10 +11646,10 @@ function openReleaseCheckout(o) {
     throw e;
   }
   for (const f of o.repo.worktrees.copy) {
-    const src = join24(o.cwd, f);
+    const src = join25(o.cwd, f);
     if (!existsSync22(src)) continue;
-    mkdirSync13(dirname12(join24(dir, f)), { recursive: true });
-    copyFileSync(src, join24(dir, f));
+    mkdirSync14(dirname12(join25(dir, f)), { recursive: true });
+    copyFileSync(src, join25(dir, f));
   }
   return { dir, branch, close };
 }
@@ -12664,19 +12720,19 @@ function nextRoles(decision, ran) {
 }
 
 // src/ship-name.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync15, readFileSync as readFileSync20, renameSync as renameSync2, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync16, readFileSync as readFileSync21, renameSync as renameSync2, writeFileSync as writeFileSync18 } from "fs";
 import { dirname as dirname14 } from "path";
 import { parseDocument } from "yaml";
 
 // src/machine-id.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync24, mkdirSync as mkdirSync14, readFileSync as readFileSync19, writeFileSync as writeFileSync16 } from "fs";
-import { dirname as dirname13, join as join25 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync24, mkdirSync as mkdirSync15, readFileSync as readFileSync20, writeFileSync as writeFileSync17 } from "fs";
+import { dirname as dirname13, join as join26 } from "path";
 function machineIdPathFor(stateDir) {
-  return join25(stateDir, "machine-id");
+  return join26(stateDir, "machine-id");
 }
-var sha256 = (s) => createHash3("sha256").update(s).digest("hex");
+var sha256 = (s) => createHash4("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
   try {
     if (platform2 === "darwin") {
@@ -12688,7 +12744,7 @@ function readRawMachineId(platform2 = process.platform) {
     }
     for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
       if (existsSync24(p)) {
-        const id = readFileSync19(p, "utf8").trim();
+        const id = readFileSync20(p, "utf8").trim();
         if (id) return id;
       }
     }
@@ -12700,14 +12756,14 @@ function ensureMachineId(stateDir, opts = {}) {
   if (opts.override?.trim()) return sha256(opts.override.trim());
   const path = machineIdPathFor(stateDir);
   if (existsSync24(path)) {
-    const cached = readFileSync19(path, "utf8").trim();
+    const cached = readFileSync20(path, "utf8").trim();
     if (/^[0-9a-f]{64}$/.test(cached)) return cached;
   }
   const raw = (opts.read ?? readRawMachineId)();
   if (!raw) return void 0;
   const hashed = sha256(raw);
-  mkdirSync14(dirname13(path), { recursive: true });
-  writeFileSync16(path, `${hashed}
+  mkdirSync15(dirname13(path), { recursive: true });
+  writeFileSync17(path, `${hashed}
 `, { mode: 384 });
   return hashed;
 }
@@ -12780,7 +12836,7 @@ async function syncRouteName(i) {
 function readSyncedName(resolvedFile) {
   if (!existsSync25(resolvedFile)) return void 0;
   try {
-    const v = JSON.parse(readFileSync20(resolvedFile, "utf8")).shipName;
+    const v = JSON.parse(readFileSync21(resolvedFile, "utf8")).shipName;
     return typeof v === "string" ? v : void 0;
   } catch {
     return void 0;
@@ -12790,22 +12846,22 @@ function writeSyncedName(resolvedFile, name) {
   if (!existsSync25(resolvedFile)) return;
   let raw;
   try {
-    raw = JSON.parse(readFileSync20(resolvedFile, "utf8"));
+    raw = JSON.parse(readFileSync21(resolvedFile, "utf8"));
   } catch {
     return;
   }
   if (raw.shipName === name) return;
   raw.shipName = name;
-  mkdirSync15(dirname14(resolvedFile), { recursive: true });
+  mkdirSync16(dirname14(resolvedFile), { recursive: true });
   const tmp = `${resolvedFile}.tmp${process.pid}`;
-  writeFileSync17(tmp, `${JSON.stringify(raw, null, 2)}
+  writeFileSync18(tmp, `${JSON.stringify(raw, null, 2)}
 `);
   renameSync2(tmp, resolvedFile);
 }
 async function reconcileShipName(i) {
   let local = i.ship.name;
   try {
-    local = shipNameOfYaml(readFileSync20(i.configFile, "utf8")) ?? local;
+    local = shipNameOfYaml(readFileSync21(i.configFile, "utf8")) ?? local;
   } catch {
   }
   const resolvedFile = resolvedPathFor(i.stateDir, i.route);
@@ -12829,8 +12885,8 @@ async function reconcileShipName(i) {
   }
   if (result.status !== "ok") return result;
   if (result.action === "adopt" || result.action === "row-wins") {
-    const text = readFileSync20(i.configFile, "utf8");
-    writeFileSync17(i.configFile, setShipNameInYaml(text, result.name));
+    const text = readFileSync21(i.configFile, "utf8");
+    writeFileSync18(i.configFile, setShipNameInYaml(text, result.name));
     i.ship.name = result.name;
     if (result.action === "row-wins") {
       i.emit?.warn(
@@ -13738,7 +13794,7 @@ function describeCapability(i) {
 }
 
 // src/agents-sync-run.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync16, readFileSync as readFileSync21, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync17, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "fs";
 import { dirname as dirname15 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
@@ -13772,12 +13828,12 @@ async function runAgentsSync(target, o) {
   for (const s of skillResult?.outcomes ?? []) o.say(describeSkillSyncOutcome(s));
   if (!dryRun) {
     const resolvedPath = resolvedPathFor(o.stateDir, target.route);
-    const raw = existsSync26(resolvedPath) ? JSON.parse(readFileSync21(resolvedPath, "utf8")) : {};
+    const raw = existsSync26(resolvedPath) ? JSON.parse(readFileSync22(resolvedPath, "utf8")) : {};
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
-    mkdirSync16(dirname15(resolvedPath), { recursive: true });
-    writeFileSync18(resolvedPath, `${JSON.stringify(raw, null, 2)}
+    mkdirSync17(dirname15(resolvedPath), { recursive: true });
+    writeFileSync19(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
     if (target.resolved) {
       target.resolved.agentPersonas = personaResult.agentPersonas;
@@ -13792,7 +13848,7 @@ async function runAgentsSync(target, o) {
 }
 
 // src/logbook.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import { TablationClient as TablationClient4 } from "@tablation/client";
 var LogbookError = class extends Error {
 };
@@ -13865,7 +13921,7 @@ async function showLogEntry(route, entryId, opts = {}) {
     };
   }
   const prompt = appendAdditions(match.prompt ?? "", match.prompt_additions);
-  const actualSha = createHash4("sha256").update(prompt).digest("hex");
+  const actualSha = createHash5("sha256").update(prompt).digest("hex");
   const exact = !!entry.prompt_sha && actualSha === entry.prompt_sha;
   return {
     entry,
@@ -13884,7 +13940,7 @@ import { isMap as isMap2, parseDocument as parseDocument3, YAMLMap } from "yaml"
 
 // src/repos-cmd.ts
 import { homedir as homedir8 } from "os";
-import { basename as basename8, join as join26, resolve as resolve3 } from "path";
+import { basename as basename8, join as join27, resolve as resolve3 } from "path";
 import { isMap, isSeq, parseDocument as parseDocument2, stringify as stringify2 } from "yaml";
 var ReposError = class extends Error {
 };
@@ -14162,7 +14218,7 @@ function planRepoClone(i) {
   }
   const ship = doc.get("ship", true);
   const basePath = String(m.get("reposBasePath") ?? (isMap(ship) ? ship.get("reposBasePath") : void 0) ?? "~/Crew");
-  const target = i.dir ? expandDir(i.dir, i.base) : join26(expandDir(basePath, i.base), i.route.split("/")[0], name);
+  const target = i.dir ? expandDir(i.dir, i.base) : join27(expandDir(basePath, i.base), i.route.split("/")[0], name);
   const add = planRepoAdd({ text: i.text, base: i.base, route: i.route, path: target, origin: remote, resolved: i.resolved, name, isCheckout: i.isCheckout });
   return { ...add, remote, target };
 }
@@ -14542,7 +14598,7 @@ ${run2.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename9, dirname as dirname17, join as join27 } from "path";
+import { basename as basename9, dirname as dirname17, join as join28 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -14565,8 +14621,8 @@ has something safe to work on: its test and build hooks always pass, it has no
 remote, and \`crew sample-ticket --remove\` deletes it.
 `;
 function sampleDir(existing, reposBase, workspace) {
-  if (existing.length > 0) return join27(dirname17(existing[0]), SAMPLE_REPO);
-  return join27(reposBase, workspace, SAMPLE_REPO);
+  if (existing.length > 0) return join28(dirname17(existing[0]), SAMPLE_REPO);
+  return join28(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
 function sampleDescription() {
@@ -14647,8 +14703,8 @@ function schedulerInstalled(plan, exists, crontab) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync27, readFileSync as readFileSync22, readdirSync as readdirSync8 } from "fs";
-import { basename as basename10, dirname as dirname18, join as join28, resolve as resolve4 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync23, readdirSync as readdirSync8 } from "fs";
+import { basename as basename10, dirname as dirname18, join as join29, 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;
@@ -14715,7 +14771,7 @@ function siblingWorktreeDirs(target) {
   for (const name of names) {
     if (!name.startsWith(stem)) continue;
     const m = DIR_NUMBER_SUFFIXED.exec(name);
-    const path = join28(parent, name);
+    const path = join29(parent, name);
     if (m && !registered.has(resolve4(path))) out.push({ path, number: m[1] });
   }
   return out;
@@ -14818,7 +14874,7 @@ function isHandBackMerge(path, base) {
   if (!msgPath) return false;
   let first;
   try {
-    first = readFileSync22(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
+    first = readFileSync23(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
   } catch {
     return false;
   }
@@ -14924,13 +14980,13 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 
 // src/stream-sweep.ts
 import { existsSync as existsSync28, readdirSync as readdirSync9, rmSync as rmSync13, statSync as statSync8 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join29(stateDir, "streams");
+  const dir = join30(stateDir, "streams");
   if (!existsSync28(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync9(dir).map((name) => join29(dir, name)).filter((path) => {
+  return readdirSync9(dir).map((name) => join30(dir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -14958,7 +15014,7 @@ function applyStreamSweep(paths, dryRun, log) {
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
   if (!existsSync28(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync9(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join29(stateDir, name)).filter((path) => {
+  return readdirSync9(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join30(stateDir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -14968,24 +15024,24 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync28, existsSync as existsSync34, mkdirSync as mkdirSync21, writeFileSync as writeFileSync22, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync14 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync29, existsSync as existsSync34, mkdirSync as mkdirSync22, writeFileSync as writeFileSync23, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync14 } from "fs";
 import { createInterface } from "readline/promises";
 import { dirname as dirOf, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync29, mkdirSync as mkdirSync17, readFileSync as readFileSync23, chmodSync } from "fs";
-import { dirname as dirname19, join as join30 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync18, readFileSync as readFileSync24, chmodSync } from "fs";
+import { dirname as dirname19, join as join31 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join30(stateDir, "ssh", "id_ed25519");
+  return join31(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
   if (!existsSync29(privateKeyPath)) {
-    mkdirSync17(dirname19(privateKeyPath), { recursive: true });
+    mkdirSync18(dirname19(privateKeyPath), { recursive: true });
     try {
       execFileSync6("ssh-keygen", [
         "-t",
@@ -15008,7 +15064,7 @@ function ensureShipSshKeypair(stateDir) {
   if (!existsSync29(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync23(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync24(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -15022,7 +15078,7 @@ function sshKeygenAvailable() {
 
 // src/passenger-containers.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 var realExec = (cmd, args) => {
   try {
     return execFileSync7(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
@@ -15059,12 +15115,12 @@ function containerNameFor(workspaceId) {
   return `crew-passenger-${workspaceId}`;
 }
 function portFor(workspaceId, base = 28765, span = 1e3) {
-  const digest = createHash5("sha256").update(workspaceId).digest();
+  const digest = createHash6("sha256").update(workspaceId).digest();
   return base + digest.readUInt32BE(0) % span;
 }
 function mountsDigest(mounts, image) {
   const sorted2 = [...mounts].sort((a, b) => a.containerPath.localeCompare(b.containerPath));
-  return createHash5("sha256").update(JSON.stringify({ mounts: sorted2, image })).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(JSON.stringify({ mounts: sorted2, image })).digest("hex").slice(0, 16);
 }
 function planContainers(cfg) {
   const byWorkspace = /* @__PURE__ */ new Map();
@@ -15224,9 +15280,9 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync30, mkdirSync as mkdirSync18, readFileSync as readFileSync24, writeFileSync as writeFileSync19, unlinkSync as unlinkSync3, readdirSync as readdirSync10 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync19, readFileSync as readFileSync25, writeFileSync as writeFileSync20, unlinkSync as unlinkSync3, readdirSync as readdirSync10 } from "fs";
 import { randomInt } from "crypto";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn5(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -15293,21 +15349,21 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join31(stateDir, "passengers", `${workspaceId}.json`);
+  return join32(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
   if (!existsSync30(path)) return void 0;
   try {
-    return JSON.parse(readFileSync24(path, "utf8"));
+    return JSON.parse(readFileSync25(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync18(join31(stateDir, "passengers"), { recursive: true });
-  writeFileSync19(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync19(join32(stateDir, "passengers"), { recursive: true });
+  writeFileSync20(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function updatePersistedTunnel(stateDir, workspaceId, patch2) {
@@ -15404,13 +15460,13 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join31(stateDir, "passengers");
+  const dir = join32(stateDir, "passengers");
   if (!existsSync30(dir)) return [];
   return readdirSync10(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
 // src/mcp-endpoint-registry.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 function endpointsUrl(api, workspaceId, id) {
   const base = `${api.baseUrl.replace(/\/+$/, "")}/api/workspaces/${workspaceId}/mcp-endpoints`;
   return id ? `${base}/${id}` : base;
@@ -15478,7 +15534,7 @@ async function probeEndpointAccess(api, workspaceId) {
 }
 var REGISTER_MCP_ENDPOINTS_HINT = "give this key's role the REGISTER_MCP_ENDPOINTS capability, e.g. via the group that holds the Crew project role";
 function registrationKey(url, mcpSecret) {
-  return createHash6("sha256").update(`${url}
+  return createHash7("sha256").update(`${url}
 ${mcpSecret ?? ""}`).digest("hex").slice(0, 16);
 }
 async function reconcileEndpoint(workspaceId, d) {
@@ -15526,8 +15582,8 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn6 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync31, mkdirSync as mkdirSync19, readFileSync as readFileSync25, writeFileSync as writeFileSync20, unlinkSync as unlinkSync4, readdirSync as readdirSync11 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync20, readFileSync as readFileSync26, writeFileSync as writeFileSync21, unlinkSync as unlinkSync4, readdirSync as readdirSync11 } from "fs";
+import { join as join33 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -15616,21 +15672,21 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join32(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join33(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
   if (!existsSync31(path)) return void 0;
   try {
-    return JSON.parse(readFileSync25(path, "utf8"));
+    return JSON.parse(readFileSync26(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync19(join32(stateDir, "passengers"), { recursive: true });
-  writeFileSync20(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync20(join33(stateDir, "passengers"), { recursive: true });
+  writeFileSync21(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function removePersistedSyncDaemon(stateDir, workspaceId) {
@@ -15650,7 +15706,7 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join32(stateDir, "passengers");
+  const dir = join33(stateDir, "passengers");
   if (!existsSync31(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync11(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
@@ -15739,12 +15795,12 @@ function describeCause(err) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync20, readFileSync as readFileSync27, readdirSync as readdirSync13, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync21 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync28, readdirSync as readdirSync13, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync22 } from "fs";
+import { join as join35 } from "path";
 
 // src/interrupted.ts
-import { existsSync as existsSync32, readdirSync as readdirSync12, readFileSync as readFileSync26 } from "fs";
-import { join as join33 } from "path";
+import { existsSync as existsSync32, readdirSync as readdirSync12, readFileSync as readFileSync27 } from "fs";
+import { join as join34 } from "path";
 var INTERRUPTED_MARKER = calloutHeader("NOTE", "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.";
@@ -15765,19 +15821,19 @@ function runFinished(streamPath) {
   const path = `${streamPath}.meta.json`;
   if (!existsSync32(path)) return false;
   try {
-    return JSON.parse(readFileSync26(path, "utf8")).running !== true;
+    return JSON.parse(readFileSync27(path, "utf8")).running !== true;
   } catch {
     return true;
   }
 }
 function orphanedStreams(o) {
-  const dir = join33(o.stateDir, "streams");
+  const dir = join34(o.stateDir, "streams");
   if (!existsSync32(dir)) return [];
   const ownerAlive = o.isOwnerAlive ?? pidAlive;
   const out = [];
   for (const name of readdirSync12(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join33(dir, name);
+    const streamPath = join34(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || sidecar.route !== o.routeLabel) continue;
@@ -15897,7 +15953,7 @@ function latestMtime(path) {
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
   for (const entry of readdirSync13(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join34(path, entry.name)));
+    latest = Math.max(latest, latestMtime(join35(path, entry.name)));
   }
   return latest;
 }
@@ -15909,20 +15965,20 @@ function makeStaleChecker(paths, opts = {}) {
   return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync33(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join34(stateDir, "reload-requested");
+  return join35(stateDir, "reload-requested");
 }
 function daemonStampFor(stateDir) {
-  return join34(stateDir, "daemon.started");
+  return join35(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
-  mkdirSync20(stateDir, { recursive: true });
+  mkdirSync21(stateDir, { recursive: true });
   rmSync14(reloadSentinelFor(stateDir), { force: true });
-  writeFileSync21(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
+  writeFileSync22(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
 `);
 }
 function readDaemonStarted(stateDir) {
   try {
-    const v = JSON.parse(readFileSync27(daemonStampFor(stateDir), "utf8")).startedAt;
+    const v = JSON.parse(readFileSync28(daemonStampFor(stateDir), "utf8")).startedAt;
     return typeof v === "number" ? v : null;
   } catch {
     return null;
@@ -16943,7 +16999,7 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join35(homedir9(), ".config", "systemd", "user", `${label}.timer`);
+      const staleTimer = join36(homedir9(), ".config", "systemd", "user", `${label}.timer`);
       if (existsSync34(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
@@ -17005,7 +17061,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;
-          writeFileSync22(cfg.configFile, planEnable(readFileSync28(cfg.configFile, "utf8"), a.route));
+          writeFileSync23(cfg.configFile, planEnable(readFileSync29(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -18014,7 +18070,7 @@ ${changed2.map((c) => `  - ${c}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join35(CREW_HOME, "src"), join35(CREW_HOME, "dist"), join35(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join36(CREW_HOME, "src"), join36(CREW_HOME, "dist"), join36(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -18233,10 +18289,10 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync34(resolvedPath) ? JSON.parse(readFileSync28(resolvedPath, "utf8")) : {};
+        const raw = existsSync34(resolvedPath) ? JSON.parse(readFileSync29(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
-        mkdirSync21(dirOf(resolvedPath), { recursive: true });
-        writeFileSync22(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        mkdirSync22(dirOf(resolvedPath), { recursive: true });
+        writeFileSync23(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (result.outcomes.some((o) => o.action === "diverged")) process.exitCode = 1;
@@ -18259,7 +18315,7 @@ ${changed2.map((c) => `  - ${c}
         throw e;
       }
       const oldName = cfg.ship.name;
-      writeFileSync22(cfg.configFile, setShipNameInYaml(readFileSync28(cfg.configFile, "utf8"), newName));
+      writeFileSync23(cfg.configFile, setShipNameInYaml(readFileSync29(cfg.configFile, "utf8"), newName));
       cfg.ship.name = newName;
       let renameMachineId;
       try {
@@ -18306,7 +18362,7 @@ ${changed2.map((c) => `  - ${c}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list" && sub !== "clone" && sub !== "hooks") usage2();
-      const configText = readFileSync28(cfg.configFile, "utf8");
+      const configText = readFileSync29(cfg.configFile, "utf8");
       if (sub === "hooks") {
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
@@ -18320,7 +18376,7 @@ ${changed2.map((c) => `  - ${c}
             }
           }, read: (r) => {
             try {
-              return readFileSync28(resolvePath(dir, r), "utf8");
+              return readFileSync29(resolvePath(dir, r), "utf8");
             } catch {
               return void 0;
             }
@@ -18358,13 +18414,13 @@ ${changed2.map((c) => `  - ${c}
           if (write && suggestion.source === null && recipeIds.length === 0 && hookSpecs.length === 0) throw new ReposError(`nothing to write: ${suggestion.notes[0]}`);
           if (write === "route") {
             const plan = planRouteHooks(configText, a.route, a.name, picked.hooks);
-            writeFileSync22(cfg.configFile, plan.text);
+            writeFileSync23(cfg.configFile, plan.text);
             written = { target: "route", file: cfg.configFile, hooks: plan.written, kept: plan.kept };
           } else if (write === "repo") {
             const have = existingRepoConfig(files);
             if (have) throw new ReposError(`${resolvePath(dir, have)} already exists; not overwriting it`);
             const file = resolvePath(dir, ".crew.yaml");
-            writeFileSync22(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
+            writeFileSync23(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
             written = { target: "repo", file, hooks: Object.keys(picked.hooks), kept: [] };
           }
           if (flag("json")) {
@@ -18447,7 +18503,7 @@ ${changed2.map((c) => `  - ${c}
       let resolvedRemotes;
       if (existsSync34(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync28(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync29(resolvedFile, "utf8"));
         } catch {
         }
       }
@@ -18468,7 +18524,7 @@ ${changed2.map((c) => `  - ${c}
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
-                  return Object.keys(parseRepoConfig(readFileSync28(resolvePath(d, f), "utf8"), f).hooks).length > 0;
+                  return Object.keys(parseRepoConfig(readFileSync29(resolvePath(d, f), "utf8"), f).hooks).length > 0;
                 } catch {
                   return false;
                 }
@@ -18517,7 +18573,7 @@ ${changed2.map((c) => `  - ${c}
             throw new ReposError(`${e.message}${authHint}
   crew.yaml was not changed`);
           }
-          writeFileSync22(cfg.configFile, plan2.text);
+          writeFileSync23(cfg.configFile, plan2.text);
           if (plan2.droppedDir) process.stderr.write(`crew repos: dropped dir: ${plan2.droppedDir} from route ${routeName} \u2014 it is not a checkout (the clone base); checkouts now live under repos:
 `);
           say("attached", { route: routeName, name: plan2.name, dir: plan2.target, mode: plan2.mode }, `cloned and attached ${plan2.target} to ${routeName} as ${plan2.mode === "dir" ? "dir" : `repos.${plan2.name}`} in ${cfg.configFile}`);
@@ -18577,14 +18633,14 @@ ${changed2.map((c) => `  - ${c}
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
           if (existsSync34(resolvedFile)) {
-            const raw = JSON.parse(readFileSync28(resolvedFile, "utf8"));
+            const raw = JSON.parse(readFileSync29(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
-            writeFileSync22(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync23(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        writeFileSync22(cfg.configFile, plan.text);
+        writeFileSync23(cfg.configFile, plan.text);
         process.stdout.write(`added ${top} to ${routeName} as ${plan.mode === "dir" ? "dir" : `repos.${plan.name}`} in ${cfg.configFile}
 `);
       } catch (e) {
@@ -18935,7 +18991,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.exit(2);
         }
         if (found.shipNameAdopted && !dryRun) {
-          writeFileSync22(cfg.configFile, setShipNameInYaml(readFileSync28(cfg.configFile, "utf8"), found.shipNameAdopted));
+          writeFileSync23(cfg.configFile, setShipNameInYaml(readFileSync29(cfg.configFile, "utf8"), found.shipNameAdopted));
           cfg.ship.name = found.shipNameAdopted;
         }
         if (found.shipRow) {
@@ -18981,7 +19037,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         const hadPreviousFile = existsSync34(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync28(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync29(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -19101,10 +19157,10 @@ 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 {
-          mkdirSync21(dirname20(resolvedPath), { recursive: true });
+          mkdirSync22(dirname20(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
-          writeFileSync22(tmpPath, `${JSON.stringify(resolved, null, 2)}
+          writeFileSync23(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
           renameSync3(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
@@ -19146,8 +19202,8 @@ 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 {
-            mkdirSync21(dirname20(apiKeyFile), { recursive: true });
-            writeFileSync22(apiKeyFile, `${apiKeyVar}=${apiKey}
+            mkdirSync22(dirname20(apiKeyFile), { recursive: true });
+            writeFileSync23(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
 `);
@@ -19183,8 +19239,11 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             const id = `${tc.harness}\0${tc.bin}`;
             if (seen.has(id)) continue;
             seen.add(id);
-            const line = adapterFor(tc.harness).ensureMcp({ bin: tc.bin, url: mcpUrlFor(baseUrl), key: apiKey, replace, dryRun });
-            connectEvents.emit("mcp_registered", line, { harness: tc.harness, bin: tc.bin });
+            const adapter = adapterFor(tc.harness);
+            const mcpUrl = mcpUrlFor(baseUrl);
+            const mcpOpts = { bin: tc.bin, url: mcpUrl, key: apiKey, replace, dryRun, stateDir: cfg.ship.stateDir };
+            const { line, action } = adapter.ensureMcpResult ? adapter.ensureMcpResult(mcpOpts) : { line: adapter.ensureMcp(mcpOpts), action: void 0 };
+            connectEvents.emit("mcp_registered", line, { harness: tc.harness, bin: tc.bin, url: mcpUrl, ...action ? { action } : {} });
             process.stderr.write(`${line}
 `);
           }
@@ -19835,7 +19894,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       };
       const droppedRoutes = [];
       try {
-        const rawCfg = parseYaml2(readFileSync28(cfg.configFile, "utf8"));
+        const rawCfg = parseYaml2(readFileSync29(cfg.configFile, "utf8"));
         for (const r of rawCfg?.routes ?? []) {
           if (typeof r?.route !== "string" || cfg.routes.some((x) => x.route === r.route)) continue;
           try {
@@ -19877,8 +19936,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         process.stdout.write("crew reload: no daemon unit is running \u2014 nothing to reload (the next run reads crew.yaml fresh)\n");
         break;
       }
-      mkdirSync21(cfg.ship.stateDir, { recursive: true });
-      writeFileSync22(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
+      mkdirSync22(cfg.ship.stateDir, { recursive: true });
+      writeFileSync23(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
       process.stdout.write("crew reload: requested \u2014 the daemon finishes its in-flight pass, then relaunches with the new config\n");
       if (flag("now") && control?.stopCommand && control.startCommand) {
@@ -19929,7 +19988,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
     }
     case "log": {
       try {
-        const text = readFileSync28(cfg.ship.logFile, "utf8").split("\n");
+        const text = readFileSync29(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -19952,7 +20011,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       };
       if (!route.resolved) fail(`route ${route.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route, cfg.ship);
-      const configText = readFileSync28(cfg.configFile, "utf8");
+      const configText = readFileSync29(cfg.configFile, "utf8");
       const cfgBase = dirname20(cfg.configFile);
       const configured = configuredRepos(configText, route.route, cfgBase);
       const dir = configured.find((r) => r.name === SAMPLE_REPO)?.dir ?? sampleDir(configured.map((r) => r.dir), route.reposBasePath, route.route.split("/")[0]);
@@ -19981,7 +20040,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         }
         if (configured.some((r) => r.dir === dir)) {
           try {
-            writeFileSync22(cfg.configFile, planRepoRemove(configText, cfgBase, route.route, dir).text);
+            writeFileSync23(cfg.configFile, planRepoRemove(configText, cfgBase, route.route, dir).text);
           } catch (e) {
             if (e instanceof ReposError) fail(e.message);
             throw e;
@@ -19990,28 +20049,28 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         if (row) {
           await tracker.deleteRepoRow(row.id);
           if (existsSync34(resolvedFile)) {
-            const raw = JSON.parse(readFileSync28(resolvedFile, "utf8"));
+            const raw = JSON.parse(readFileSync29(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
-            writeFileSync22(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync23(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        if (existsSync34(join35(dir, ".git")) && basename11(dir) === SAMPLE_REPO) rmSync15(dir, { recursive: true, force: true });
+        if (existsSync34(join36(dir, ".git")) && basename11(dir) === SAMPLE_REPO) rmSync15(dir, { recursive: true, force: true });
         say("removed", { dir, closed }, `removed the sample repo${closed.length ? `, closed ${closed.join(", ")}` : ""}`);
         break;
       }
       const projectId = route.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
-      const fresh = !existsSync34(join35(dir, ".git"));
+      const fresh = !existsSync34(join36(dir, ".git"));
       if (existsSync34(dir) && fresh && readdirSync14(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
       if (dryRun) {
         say("dry-run", { dir, newCheckout: fresh, repoRow: row?.id ?? null }, `would ${fresh ? "create" : "reuse"} ${dir}${row ? "" : ", create the Repos row"}, and file one ${tracker.contract.statuses.approved} ticket`);
         break;
       }
       if (fresh) {
-        mkdirSync21(dir, { recursive: true });
-        writeFileSync22(join35(dir, "README.md"), SAMPLE_README);
-        writeFileSync22(join35(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        mkdirSync22(dir, { recursive: true });
+        writeFileSync23(join36(dir, "README.md"), SAMPLE_README);
+        writeFileSync23(join36(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync6("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -20030,16 +20089,16 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         });
         repoId = (await tracker.createRepoRow(payload)).id;
         if (existsSync34(resolvedFile)) {
-          const raw = JSON.parse(readFileSync28(resolvedFile, "utf8"));
+          const raw = JSON.parse(readFileSync29(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
-          writeFileSync22(resolvedFile, `${JSON.stringify(raw, null, 2)}
+          writeFileSync23(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
         }
       }
       if (!configured.some((r) => r.dir === dir)) {
         try {
-          writeFileSync22(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route.route, path: dir, name: SAMPLE_REPO }).text);
+          writeFileSync23(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route.route, path: dir, name: SAMPLE_REPO }).text);
         } catch (e) {
           if (e instanceof ReposError) fail(e.message);
           throw e;
@@ -20393,7 +20452,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 readFileSync28(p, "utf8");
+            return readFileSync29(p, "utf8");
           } catch {
             return null;
           }