@tablation/crew 0.86.0 → 0.87.1

package/dist/cli.js

@@ -56,25 +56,107 @@ async function previewHostProblem(cfg, resolve6 = (h) => lookup(h)) {
   }
   return void 0;
 }
+function routePeriscopeProblems(o) {
+  if (!o.hosts) return [];
+  const out = [];
+  for (const r of o.repos) {
+    if (!r.hasPreviewHook) {
+      out.push({
+        severity: "note",
+        kind: "preview_hook_missing",
+        route: o.route,
+        repo: r.name,
+        message: `${o.route}/${r.name}: hostPeriscopes is on but ${r.name} declares no \`preview\` hook, so it cannot be opened as a periscope`
+      });
+    }
+  }
+  if (o.tablePresent === false) {
+    out.push({
+      severity: "blocker",
+      kind: "periscopes_table_missing",
+      route: o.route,
+      message: `${o.route}: hostPeriscopes is on but this workspace has no Periscopes table \u2014 update the Issues template and run \`crew connect\``
+    });
+  }
+  return out;
+}
+function previewHostFinding(message) {
+  return /does not resolve/.test(message) ? { severity: "attention", kind: "preview_host_unresolvable", message } : { severity: "blocker", kind: "preview_host", message };
+}
+
+// src/periscope-state.ts
+import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { connect } from "net";
+import { join } from "path";
+var dirOf = (stateDir) => join(stateDir, "periscopes");
+var fileOf = (stateDir, ticketRecordId) => join(dirOf(stateDir), `${ticketRecordId}.json`);
+function writePeriscopeSidecar(stateDir, sc) {
+  mkdirSync(dirOf(stateDir), { recursive: true });
+  writeFileSync(fileOf(stateDir, sc.ticketRecordId), `${JSON.stringify(sc, null, 2)}
+`);
+}
+function removePeriscopeSidecar(stateDir, ticketRecordId) {
+  rmSync(fileOf(stateDir, ticketRecordId), { force: true });
+}
+function readPeriscopeSidecars(stateDir) {
+  const dir = dirOf(stateDir);
+  if (!existsSync2(dir)) return [];
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      const sc = JSON.parse(readFileSync(join(dir, name), "utf8"));
+      if (sc && typeof sc.ticketRecordId === "string" && typeof sc.url === "string") out.push(sc);
+    } catch {
+    }
+  }
+  return out.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+}
+function urlPort(url) {
+  try {
+    const u = new URL(url);
+    return u.port ? Number(u.port) : u.protocol === "https:" ? 443 : 80;
+  } catch {
+    return void 0;
+  }
+}
+function portListening(port, timeoutMs = 500) {
+  return new Promise((resolve6) => {
+    const s = connect({ port, host: "127.0.0.1" });
+    const done = (ok) => {
+      s.destroy();
+      resolve6(ok);
+    };
+    s.setTimeout(timeoutMs, () => done(false));
+    s.once("connect", () => done(true));
+    s.once("error", () => done(false));
+  });
+}
+async function periscopesForStatus(stateDir, probe = portListening) {
+  return Promise.all(readPeriscopeSidecars(stateDir).map(async (sc) => {
+    const port = urlPort(sc.url);
+    return { ...sc, serving: port === void 0 ? false : await probe(port) };
+  }));
+}
 
 // src/config.ts
-import { readFileSync as readFileSync8, existsSync as existsSync7 } from "fs";
-import { resolve, dirname as dirname3, isAbsolute, join as join9, basename as basename3 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync8 } from "fs";
+import { resolve, dirname as dirname3, isAbsolute, join as join10, basename as basename3 } from "path";
 import { homedir as homedir6, tmpdir } from "os";
 import { parse as parse2 } from "yaml";
 
 // src/events.ts
 import {
   appendFileSync,
-  mkdirSync,
-  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  existsSync as existsSync3,
   statSync,
   renameSync,
   openSync,
   closeSync,
-  rmSync
+  rmSync as rmSync2
 } from "fs";
-import { join, dirname } from "path";
+import { join as join2, dirname } from "path";
 function render(e) {
   const scope = e.role ? `${e.step}[${e.role}]` : e.step;
   const ticket = e.ticket ? ` ${e.ticket}` : "";
@@ -86,7 +168,7 @@ var ROTATED_EVENTS_RE = /^events\.\d{8}T\d{6}Z(?:-\d+)?\.jsonl$/;
 var ROTATE_LOCK_STALE_MS = 6e4;
 function rotateEventsFile(file, maxBytes, now = /* @__PURE__ */ new Date()) {
   try {
-    if (!existsSync2(file) || statSync(file).size <= maxBytes) return void 0;
+    if (!existsSync3(file) || statSync(file).size <= maxBytes) return void 0;
   } catch {
     return void 0;
   }
@@ -97,7 +179,7 @@ function rotateEventsFile(file, maxBytes, now = /* @__PURE__ */ new Date()) {
     } catch {
       try {
         if (Date.now() - statSync(lock).mtimeMs < ROTATE_LOCK_STALE_MS) return void 0;
-        rmSync(lock, { force: true });
+        rmSync2(lock, { force: true });
         closeSync(openSync(lock, "wx"));
       } catch {
         return void 0;
@@ -106,12 +188,12 @@ function rotateEventsFile(file, maxBytes, now = /* @__PURE__ */ new Date()) {
     try {
       if (statSync(file).size <= maxBytes) return void 0;
       const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
-      let dest = join(dirname(file), `events.${stamp}.jsonl`);
-      for (let n = 1; existsSync2(dest); n++) dest = join(dirname(file), `events.${stamp}-${n}.jsonl`);
+      let dest = join2(dirname(file), `events.${stamp}.jsonl`);
+      for (let n = 1; existsSync3(dest); n++) dest = join2(dirname(file), `events.${stamp}-${n}.jsonl`);
       renameSync(file, dest);
       return dest;
     } finally {
-      rmSync(lock, { force: true });
+      rmSync2(lock, { force: true });
     }
   } catch {
     return void 0;
@@ -130,7 +212,7 @@ var Emitter = class _Emitter {
     for (const f of [opts.eventFile, opts.logFile]) {
       if (!f) continue;
       try {
-        mkdirSync(dirname(f), { recursive: true });
+        mkdirSync2(dirname(f), { recursive: true });
       } catch {
       }
     }
@@ -206,18 +288,18 @@ var Emitter = class _Emitter {
     }
   }
 };
-var eventFileFor = (stateDir) => join(stateDir, "events.jsonl");
+var eventFileFor = (stateDir) => join2(stateDir, "events.jsonl");
 
 // src/pair-install.ts
-import { existsSync as existsSync5, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync6, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
 import { homedir as homedir5 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/adapters/claude.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/stream.ts
 function toolTarget(name, input) {
@@ -276,19 +358,19 @@ function extractResult(line) {
 
 // src/claude-mcp.ts
 import { spawnSync } from "child_process";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { homedir } from "os";
-import { join as join3 } from "path";
+import { join as join4 } 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");
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+var fileFor = (stateDir) => join3(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"));
+    const j = JSON.parse(readFileSync3(fileFor(stateDir), "utf8"));
     return Array.isArray(j) ? j : [];
   } catch {
     return [];
@@ -296,8 +378,8 @@ function readMcpRegistrations(stateDir) {
 }
 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)}
+  mkdirSync3(stateDir, { recursive: true });
+  writeFileSync2(fileFor(stateDir), `${JSON.stringify([...rest, { ...r, at: now.toISOString() }], null, 2)}
 `, { mode: 384 });
 }
 function findMcpRegistration(stateDir, r) {
@@ -320,7 +402,7 @@ function runClaude(bin, args) {
 }
 function userScopeEntry(home) {
   try {
-    const j = JSON.parse(readFileSync3(join3(home, ".claude.json"), "utf8"));
+    const j = JSON.parse(readFileSync4(join4(home, ".claude.json"), "utf8"));
     return j.mcpServers?.[MCP_SERVER_NAME];
   } catch {
     return void 0;
@@ -404,8 +486,8 @@ function removeClaudeMcp(o) {
 }
 
 // src/launcher.ts
-import { basename, join as join4 } from "path";
-import { existsSync as existsSync3, readFileSync as readFileSync4, readdirSync } from "fs";
+import { basename, join as join5 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 function isOriLauncher(spec) {
   return !!spec.launcher && basename(spec.launcher) === "ori";
@@ -414,7 +496,7 @@ function isOmlxLauncher(spec) {
   return !!spec.launcher && basename(spec.launcher) === "omlx";
 }
 function defaultOmlxBin(home = homedir2()) {
-  return join4(home, ".omlx", "bin", "omlx");
+  return join5(home, ".omlx", "bin", "omlx");
 }
 function launcherExecutable(spec, home) {
   if (!spec.launcher) return void 0;
@@ -460,15 +542,15 @@ function interpretOmlxProbe(status2) {
 function omlxModelPresent(model, dirs) {
   return dirs.some((d) => {
     try {
-      return readdirSync(d).includes(model);
+      return readdirSync2(d).includes(model);
     } catch {
       return false;
     }
   });
 }
 function readOmlxSettings(home = homedir2()) {
-  const p = join4(home, ".omlx", "settings.json");
-  return existsSync3(p) ? parseOmlxSettings(readFileSync4(p, "utf8")) : void 0;
+  const p = join5(home, ".omlx", "settings.json");
+  return existsSync4(p) ? parseOmlxSettings(readFileSync5(p, "utf8")) : void 0;
 }
 
 // src/capability.ts
@@ -526,7 +608,7 @@ function describeClaudeAuth(spec, env = process.env, home = homedir3()) {
   if (spec.auth === "subscription") return "subscription (settings override)";
   let fromSettings;
   try {
-    const parsed = JSON.parse(readFileSync5(join5(home, ".claude", "settings.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync6(join6(home, ".claude", "settings.json"), "utf8"));
     const e = parsed.env ?? {};
     const on = (k) => e[k] !== void 0 && e[k] !== "" && e[k] !== "0";
     if (on("CLAUDE_CODE_USE_VERTEX")) fromSettings = "vertex from ~/.claude/settings.json";
@@ -622,11 +704,11 @@ var claudeAdapter = {
 // src/adapters/codex.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { homedir as homedir4 } from "os";
-import { join as join6 } from "path";
-import { rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
+import { rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
 
 // src/pair-files.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync2, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync3, rmSync as rmSync3 } from "fs";
 import { dirname as dirname2 } from "path";
 var PAIR_BLOCK_START = "<!-- crew:pair start -->";
 var PAIR_BLOCK_END = "<!-- crew:pair end -->";
@@ -667,11 +749,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) ? readFileSync6(path, "utf8") : void 0;
+  return existsSync5(path) ? readFileSync7(path, "utf8") : void 0;
 }
 function writeFileMkdir(path, text) {
-  mkdirSync3(dirname2(path), { recursive: true });
-  writeFileSync2(path, text);
+  mkdirSync4(dirname2(path), { recursive: true });
+  writeFileSync3(path, text);
 }
 function installBlockFile(path, harness, dryRun) {
   const before = readIfExists(path) ?? "";
@@ -686,8 +768,8 @@ function removeBlockFile(path, dryRun) {
   if (before === void 0 || !hasPairBlock(before)) return false;
   if (dryRun) return true;
   const after = removePairBlock(before);
-  if (after.trim() === "") rmSync2(path);
-  else writeFileSync2(path, after);
+  if (after.trim() === "") rmSync3(path);
+  else writeFileSync3(path, after);
   return true;
 }
 function blockVerdict(path, harness) {
@@ -814,8 +896,8 @@ function codexTable(url) {
   return [`[mcp_servers.${SERVER}]`, `url = ${tomlString(url)}`, `bearer_token_env_var = ${tomlString(PAIR_KEY_VAR)}`];
 }
 var codexPaths = (home) => ({
-  instructions: join6(home, ".codex", "AGENTS.md"),
-  config: join6(home, ".codex", "config.toml")
+  instructions: join7(home, ".codex", "AGENTS.md"),
+  config: join7(home, ".codex", "config.toml")
 });
 function codexMcpState(config, url) {
   const lines = config.split("\n");
@@ -865,8 +947,8 @@ var codexPair = {
     const kept = st.state === "different" ? `; left the existing ${SERVER} server alone \u2014 ${st.detail}` : "";
     if (hadMcp && !o.dryRun) {
       const after = removeTomlTable(config, `mcp_servers.${SERVER}`);
-      if (after === "") rmSync3(p.config);
-      else writeFileSync3(p.config, after);
+      if (after === "") rmSync4(p.config);
+      else writeFileSync4(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}`;
@@ -962,8 +1044,8 @@ var codexAdapter = {
 
 // src/pair-install.ts
 var geminiPaths = (home) => ({
-  instructions: join7(home, ".gemini", "GEMINI.md"),
-  config: join7(home, ".gemini", "settings.json")
+  instructions: join8(home, ".gemini", "GEMINI.md"),
+  config: join8(home, ".gemini", "settings.json")
 });
 function readGeminiSettings(path) {
   const text = readIfExists(path);
@@ -1050,8 +1132,8 @@ var geminiPair = {
       const next = { ...settings };
       if (Object.keys(rest).length > 0) next.mcpServers = rest;
       else delete next.mcpServers;
-      if (Object.keys(next).length === 0) rmSync4(p.config);
-      else writeFileSync4(p.config, `${JSON.stringify(next, null, 2)}
+      if (Object.keys(next).length === 0) rmSync5(p.config);
+      else writeFileSync5(p.config, `${JSON.stringify(next, null, 2)}
 `);
     }
     const what = hadBlock && hadMcp ? `the Pair block and ${SERVER} server` : hadBlock ? "the Pair block" : `the ${SERVER} server`;
@@ -1062,9 +1144,9 @@ var VSCODE_FLAVOURS = ["Code", "Code - Insiders"];
 function vscodeUserDirs(o) {
   const home = o.home ?? homedir5();
   const platform2 = o.platform ?? process.platform;
-  const root = platform2 === "darwin" ? join7(home, "Library", "Application Support") : platform2 === "win32" ? process.env.APPDATA ?? join7(home, "AppData", "Roaming") : join7(home, ".config");
-  const all = VSCODE_FLAVOURS.map((f) => join7(root, f, "User"));
-  const present = all.filter((d) => existsSync5(d));
+  const root = platform2 === "darwin" ? join8(home, "Library", "Application Support") : platform2 === "win32" ? process.env.APPDATA ?? join8(home, "AppData", "Roaming") : join8(home, ".config");
+  const all = VSCODE_FLAVOURS.map((f) => join8(root, f, "User"));
+  const present = all.filter((d) => existsSync6(d));
   return present.length > 0 ? present : [all[0]];
 }
 var COPILOT_FRONTMATTER = '---\napplyTo: "**"\n---\n\n';
@@ -1101,8 +1183,8 @@ function removeCopilotInstructions(path, dryRun) {
   if (before === void 0 || !hasPairBlock(before)) return false;
   if (dryRun) return true;
   const after = removePairBlock(before);
-  if (after.trim() === "" || after.trim() === COPILOT_FRONTMATTER.trim()) rmSync4(path);
-  else writeFileSync4(path, after);
+  if (after.trim() === "" || after.trim() === COPILOT_FRONTMATTER.trim()) rmSync5(path);
+  else writeFileSync5(path, after);
   return true;
 }
 var copilotPair = {
@@ -1111,8 +1193,8 @@ var copilotPair = {
   installPair(o) {
     const lines = [];
     for (const dir of vscodeUserDirs(o)) {
-      const mcpPath = join7(dir, "mcp.json");
-      const instrPath = join7(dir, "prompts", "crew-pair.instructions.md");
+      const mcpPath = join8(dir, "mcp.json");
+      const instrPath = join8(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`);
@@ -1140,8 +1222,8 @@ var copilotPair = {
   },
   verifyPair(o) {
     const verdicts = vscodeUserDirs(o).map((dir) => {
-      const instrPath = join7(dir, "prompts", "crew-pair.instructions.md");
-      const mcpPath = join7(dir, "mcp.json");
+      const instrPath = join8(dir, "prompts", "crew-pair.instructions.md");
+      const mcpPath = join8(dir, "mcp.json");
       const b = blockVerdict(instrPath, "copilot");
       if (!b.ok) return b;
       const settings = readVscodeMcp(mcpPath);
@@ -1156,8 +1238,8 @@ var copilotPair = {
   removePair(o) {
     const lines = [];
     for (const dir of vscodeUserDirs(o)) {
-      const mcpPath = join7(dir, "mcp.json");
-      const hadBlock = removeCopilotInstructions(join7(dir, "prompts", "crew-pair.instructions.md"), o.dryRun);
+      const mcpPath = join8(dir, "mcp.json");
+      const hadBlock = removeCopilotInstructions(join8(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";
@@ -1167,8 +1249,8 @@ var copilotPair = {
         const next = { ...settings };
         if (Object.keys(rest).length > 0) next.servers = rest;
         else delete next.servers;
-        if (Object.keys(next).length === 0) rmSync4(mcpPath);
-        else writeFileSync4(mcpPath, `${JSON.stringify(next, null, 2)}
+        if (Object.keys(next).length === 0) rmSync5(mcpPath);
+        else writeFileSync5(mcpPath, `${JSON.stringify(next, null, 2)}
 `);
       }
       const what = hadBlock && hadMcp ? `the Pair instructions and ${SERVER} server` : hadBlock ? "the Pair instructions" : `the ${SERVER} server`;
@@ -1456,8 +1538,8 @@ function explain(ship, required) {
 }
 
 // src/repo-config.ts
-import { readFileSync as readFileSync7, existsSync as existsSync6 } from "fs";
-import { join as join8, basename as basename2 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync7 } from "fs";
+import { join as join9, basename as basename2 } from "path";
 import { parse } from "yaml";
 var SPEC_VERSION = 1;
 var REPO_CONFIG_FILENAMES = [".crew.yaml", ".crew.yml", ".crew.json"];
@@ -1541,8 +1623,8 @@ 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 = join8(dir, name);
-    if (existsSync6(p)) return p;
+    const p = join9(dir, name);
+    if (existsSync7(p)) return p;
   }
   return null;
 }
@@ -1780,7 +1862,7 @@ function parseRepoConfig(text, file) {
 function loadRepoConfig(dir) {
   const file = findRepoConfig(dir);
   if (!file) return null;
-  return parseRepoConfig(readFileSync7(file, "utf8"), file);
+  return parseRepoConfig(readFileSync8(file, "utf8"), file);
 }
 function hookLabel(cfg, hook2) {
   return cfg.labels[hook2] ?? cfg.hooks[hook2] ?? hook2;
@@ -2241,11 +2323,11 @@ function expand(p, base) {
   return isAbsolute(out) ? out : resolve(base, out);
 }
 function resolvePromptsDir(promptSet, crewHome, base) {
-  if (!promptSet) return join9(crewHome, "prompts", "default");
+  if (!promptSet) return join10(crewHome, "prompts", "default");
   if (promptSet.includes("/") || promptSet.startsWith(".") || promptSet.startsWith("~")) {
     return expand(promptSet, base);
   }
-  return join9(crewHome, "prompts", promptSet);
+  return join10(crewHome, "prompts", promptSet);
 }
 var Missing = class {
   paths = [];
@@ -2269,7 +2351,7 @@ var Missing = class {
 };
 function crewVersion(crewHome) {
   try {
-    const pkg = JSON.parse(readFileSync8(join9(crewHome, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync9(join10(crewHome, "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -2279,26 +2361,26 @@ function configSearchPath(crewHome) {
   if (process.env.CREW_CONFIG) return [resolve(process.env.CREW_CONFIG)];
   const xdg = process.env.XDG_CONFIG_HOME;
   return [
-    ...xdg ? [join9(xdg, "crew", "crew.yaml")] : [],
-    join9(homedir6(), ".config", "crew", "crew.yaml"),
+    ...xdg ? [join10(xdg, "crew", "crew.yaml")] : [],
+    join10(homedir6(), ".config", "crew", "crew.yaml"),
     resolve(crewHome, "crew.yaml")
   ];
 }
 function findConfigFile(crewHome) {
   const candidates = configSearchPath(crewHome);
-  return candidates.find((c) => existsSync7(c)) ?? candidates[candidates.length - 1];
+  return candidates.find((c) => existsSync8(c)) ?? candidates[candidates.length - 1];
 }
-var defaultConfigPath = () => join9(process.env.XDG_CONFIG_HOME ?? join9(homedir6(), ".config"), "crew", "crew.yaml");
+var defaultConfigPath = () => join10(process.env.XDG_CONFIG_HOME ?? join10(homedir6(), ".config"), "crew", "crew.yaml");
 function routeSlug(route) {
   return route.replace(/\//g, "-");
 }
 function resolvedPathFor(stateDir, route) {
   const [workspace, project] = splitRoute(route);
-  return join9(stateDir, "resolved", workspace, `${project}.json`);
+  return join10(stateDir, "resolved", workspace, `${project}.json`);
 }
 function apiKeyPathFor(stateDir, route) {
   const [workspace, project] = splitRoute(route);
-  return join9(stateDir, "keys", workspace, `${project}.env`);
+  return join10(stateDir, "keys", workspace, `${project}.env`);
 }
 function splitRoute(route) {
   const parts = route.split("/");
@@ -2309,9 +2391,9 @@ function splitRoute(route) {
 }
 function readResolvedFile(stateDir, route) {
   const path = resolvedPathFor(stateDir, route);
-  if (!existsSync7(path)) return void 0;
+  if (!existsSync8(path)) return void 0;
   try {
-    return JSON.parse(readFileSync8(path, "utf8"));
+    return JSON.parse(readFileSync9(path, "utf8"));
   } catch (e) {
     throw new ConfigError(`${path}: not valid JSON \u2014 ${e.message}`);
   }
@@ -2371,18 +2453,18 @@ function parseResolved(raw, m, where) {
 }
 function loadConfig(crewHome, configFile, opts = {}) {
   const file = configFile ?? findConfigFile(crewHome);
-  if (opts.text === void 0 && !existsSync7(file)) {
+  if (opts.text === void 0 && !existsSync8(file)) {
     throw new ConfigError(
       `no config found. Looked in:
 ` + configSearchPath(crewHome).map((c) => `  - ${c}`).join("\n") + `
 
 Create the first of those:
-  mkdir -p ${dirname3(defaultConfigPath())} && cp ${join9(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
+  mkdir -p ${dirname3(defaultConfigPath())} && cp ${join10(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
     );
   }
   let raw;
   try {
-    raw = parse2(opts.text ?? readFileSync8(file, "utf8"));
+    raw = parse2(opts.text ?? readFileSync9(file, "utf8"));
   } catch (e) {
     throw new ConfigError(`${file}: not valid YAML \u2014 ${e.message}`);
   }
@@ -2492,7 +2574,7 @@ Create the first of those:
       useNvm: shipRaw.useNvm !== false,
       nvmSh: shipRaw.nvmSh,
       stateDir,
-      logFile: expand(shipRaw.logFile ?? join9(tmpdir(), "crew.log"), base),
+      logFile: expand(shipRaw.logFile ?? join10(tmpdir(), "crew.log"), base),
       userAgent: shipRaw.userAgent ?? `Mozilla/5.0 CrewAgent/${crewVersion(crewHome)}`,
       maxConcurrentAgents,
       maxConcurrentAgentsSet,
@@ -2652,7 +2734,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 && !Array.isArray(c?.repos);
-  const dir = c?.dir ? expand(String(c.dir), base) : hasRepos ? Object.values(repoDirs)[0] : dirIsCloneBase ? join9(reposBasePath, splitRoute(route)[0]) : "";
+  const dir = c?.dir ? expand(String(c.dir), base) : hasRepos ? Object.values(repoDirs)[0] : dirIsCloneBase ? join10(reposBasePath, splitRoute(route)[0]) : "";
   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}")`);
@@ -2736,8 +2818,8 @@ 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 readFileSync8(r.apiKeyFile, "utf8").split("\n")) {
+  if (r.apiKeyFile && r.apiKeyVar && existsSync8(r.apiKeyFile)) {
+    for (const line of readFileSync9(r.apiKeyFile, "utf8").split("\n")) {
       const m = line.match(new RegExp(`^${r.apiKeyVar}=(.*)$`));
       if (m) return (m[1] ?? "").trim().replace(/^["']|["']$/g, "");
     }
@@ -2750,9 +2832,9 @@ function resolveApiKey(r) {
 }
 function credentialSource(r) {
   if (r.apiKey) return KEYCHAIN_ELIGIBLE_ROUTES.has(r) ? "keychain" : "inline";
-  if (r.apiKeyFile && r.apiKeyVar && existsSync7(r.apiKeyFile)) {
+  if (r.apiKeyFile && r.apiKeyVar && existsSync8(r.apiKeyFile)) {
     const re = new RegExp(`^${r.apiKeyVar}=`);
-    if (readFileSync8(r.apiKeyFile, "utf8").split("\n").some((l) => re.test(l))) return "apiKeyFile";
+    if (readFileSync9(r.apiKeyFile, "utf8").split("\n").some((l) => re.test(l))) return "apiKeyFile";
   }
   return process.env.CREW_API_KEY?.trim() ? "CREW_API_KEY" : "none";
 }
@@ -2808,7 +2890,7 @@ function configuredMembers(rt) {
   return out;
 }
 function defaultRepoDir(basePath, workspace, repoName) {
-  return join9(basePath, workspace, repoName);
+  return join10(basePath, workspace, repoName);
 }
 function reposOf(r) {
   const named = Object.entries(r.repos);
@@ -2841,7 +2923,7 @@ function passengerRepoTargets(r) {
   return reposOf(r).filter((t) => r.repoOverrides[t.name]?.hostPassengers !== false);
 }
 function passengerCheckoutDir(basePath, workspace, repoName) {
-  return join9(basePath, workspace, ".passenger-checkouts", repoName);
+  return join10(basePath, workspace, ".passenger-checkouts", repoName);
 }
 function passengerCheckoutTargets(r) {
   if (!r.hostPassengers) return [];
@@ -3128,9 +3210,9 @@ function recoveredFailureHeadlines(o, route) {
 }
 
 // src/install.ts
-import { dirname as dirname4, join as join10, extname } from "path";
+import { dirname as dirname4, join as join11, extname } from "path";
 import { homedir as homedir7 } from "os";
-import { accessSync, constants, existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync2, writeFileSync as writeFileSync5, unlinkSync, realpathSync } from "fs";
+import { accessSync, constants, existsSync as existsSync9, mkdirSync as mkdirSync5, readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync6, unlinkSync, realpathSync } from "fs";
 import { spawnSync as spawnSync4 } from "child_process";
 import { createHash as createHash2 } from "crypto";
 
@@ -3142,7 +3224,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) {
@@ -3180,7 +3262,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);
@@ -3190,7 +3272,7 @@ function findOnPath(bin, searchPath) {
   }
   return void 0;
 }
-var COMMON_DOCKER_DIRS = ["/usr/local/bin", "/opt/homebrew/bin", join10(homedir7(), ".docker", "bin")].join(":");
+var COMMON_DOCKER_DIRS = ["/usr/local/bin", "/opt/homebrew/bin", join11(homedir7(), ".docker", "bin")].join(":");
 function dockerPathProblem(ship, shellPath = process.env.PATH ?? "") {
   const schedulerPath = pathFor(ship);
   if (findOnPath("docker", schedulerPath)) return void 0;
@@ -3202,7 +3284,7 @@ function xmlEscape(s) {
 }
 function planLaunchd(ship, crewHome, job) {
   const label = labelFor(crewHome, job);
-  const unitPath = join10(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
+  const unitPath = join11(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
   const crewLog = ship.logFile;
   const schedulerLog = schedulerLogFor(crewLog, job);
   const persistent = job === "run";
@@ -3256,8 +3338,8 @@ ${scheduleKeys}
 }
 function planSystemd(ship, crewHome, job) {
   const label = labelFor(crewHome, job);
-  const unitDir = join10(homedir7(), ".config", "systemd", "user");
-  const servicePath = join10(unitDir, `${label}.service`);
+  const unitDir = join11(homedir7(), ".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";
@@ -3297,7 +3379,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}
@@ -3371,7 +3453,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(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
+    const unitPath = join11(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
     return {
       mechanism: "launchd",
       unitPaths: [unitPath],
@@ -3381,18 +3463,18 @@ function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
     };
   }
   if (hostShip === "linux" && hasSystemd) {
-    const unitDir = join10(homedir7(), ".config", "systemd", "user");
+    const unitDir = join11(homedir7(), ".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`]]
     };
@@ -3410,7 +3492,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(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
+    const unitPath = join11(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
     return {
       mechanism: "launchd",
       startCommand: ["launchctl", "load", unitPath],
@@ -3450,8 +3532,8 @@ async function applyInstall(plan, crewHome, dryRun, log) {
       log.emit(`would write ${path}`);
       continue;
     }
-    mkdirSync4(dirname4(path), { recursive: true });
-    writeFileSync5(path, plan.unitContent[path]);
+    mkdirSync5(dirname4(path), { recursive: true });
+    writeFileSync6(path, plan.unitContent[path]);
     log.emit(`wrote ${path}`);
   }
   if (plan.crontabLine) {
@@ -3505,7 +3587,7 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
     }
   }
   for (const path of plan.unitPaths) {
-    if (!existsSync8(path)) continue;
+    if (!existsSync9(path)) continue;
     if (dryRun) {
       log.emit(`would remove ${path}`);
       continue;
@@ -3524,7 +3606,7 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
 }
 var CREW_LAUNCHD_PREFIX = "com.tablation.crew";
 function launchAgentsDir() {
-  return join10(homedir7(), "Library", "LaunchAgents");
+  return join11(homedir7(), "Library", "LaunchAgents");
 }
 function xmlUnescape(s) {
   return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
@@ -3541,25 +3623,25 @@ function loadedCrewLabels() {
   return [...parseLaunchctlList(list.stdout ?? "").keys()].filter((l) => l.startsWith(CREW_LAUNCHD_PREFIX));
 }
 function listLaunchdUnits(dir = launchAgentsDir(), loaded = []) {
-  const files = existsSync8(dir) ? readdirSync2(dir) : [];
+  const files = existsSync9(dir) ? readdirSync3(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 {
       label: f.slice(0, -".plist".length),
       plistPath,
       program,
-      programExists: program !== null && existsSync8(program)
+      programExists: program !== null && existsSync9(program)
     };
   });
   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;
 }
@@ -3572,9 +3654,9 @@ function removeLaunchdUnit(unit, dryRun, log) {
     log.emit(`would unload and remove ${unit.label}`);
     return;
   }
-  if (existsSync8(unit.plistPath)) spawnSync4("launchctl", ["unload", unit.plistPath], { encoding: "utf8" });
+  if (existsSync9(unit.plistPath)) spawnSync4("launchctl", ["unload", unit.plistPath], { encoding: "utf8" });
   spawnSync4("launchctl", ["remove", unit.label], { encoding: "utf8" });
-  if (existsSync8(unit.plistPath)) unlinkSync(unit.plistPath);
+  if (existsSync9(unit.plistPath)) unlinkSync(unit.plistPath);
   log.emit(`removed ${unit.label} (${unit.plistPath})`);
 }
 function clearForeignLaunchdUnits(crewHome, replace, dryRun, log, dir, loaded) {
@@ -3652,24 +3734,24 @@ function detectSystemd() {
 }
 
 // src/ship-attention.ts
-import { existsSync as existsSync10, statfsSync } from "fs";
+import { existsSync as existsSync11, statfsSync } from "fs";
 
 // src/git.ts
 import { execFileSync } from "child_process";
 import {
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync5,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync6,
   openSync as openSync2,
   closeSync as closeSync2,
   writeSync,
   statSync as statSync3,
   unlinkSync as unlinkSync2,
-  readFileSync as readFileSync10,
-  writeFileSync as writeFileSync6,
-  readdirSync as readdirSync3,
-  rmSync as rmSync5
+  readFileSync as readFileSync11,
+  writeFileSync as writeFileSync7,
+  readdirSync as readdirSync4,
+  rmSync as rmSync6
 } from "fs";
-import { dirname as dirname5, basename as basename4, join as join11 } from "path";
+import { dirname as dirname5, basename as basename4, join as join12 } from "path";
 var GitError = class extends Error {
 };
 function streamText(x) {
@@ -4050,7 +4132,7 @@ function recoverStrandedReleaseCheckouts(cwd) {
     else if (line.startsWith("branch refs/heads/crew/release-") && path) {
       gitOk(cwd, ["worktree", "remove", "--force", path]);
       const root = dirname5(path);
-      if (basename4(root).startsWith("crew-release-")) rmSync5(root, { recursive: true, force: true });
+      if (basename4(root).startsWith("crew-release-")) rmSync6(root, { recursive: true, force: true });
     }
   }
   const stranded = (gitOk(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/heads/crew/release-*"]) ?? "").split("\n").filter(Boolean);
@@ -4061,18 +4143,18 @@ function sweepStaleReleaseRoots(tmp, now = Date.now(), maxAgeMs = 60 * 60 * 1e3)
   const removed = [];
   let names;
   try {
-    names = readdirSync3(tmp);
+    names = readdirSync4(tmp);
   } catch {
     return removed;
   }
   for (const name of names) {
     if (!name.startsWith("crew-release-")) continue;
-    const root = join11(tmp, name);
+    const root = join12(tmp, name);
     try {
       const st = statSync3(root);
       if (!st.isDirectory() || now - st.mtimeMs < maxAgeMs) continue;
-      if (existsSync9(join11(root, "checkout"))) continue;
-      rmSync5(root, { recursive: true, force: true });
+      if (existsSync10(join12(root, "checkout"))) continue;
+      rmSync6(root, { recursive: true, force: true });
       removed.push(name);
     } catch {
     }
@@ -4117,13 +4199,13 @@ function originUrlOf(dir, remoteName) {
   }
 }
 function ensureRepoCheckout(dir, remote, opts = {}) {
-  if (existsSync9(`${dir}/.git`)) return false;
+  if (existsSync10(`${dir}/.git`)) return false;
   if (!remote) {
     throw new GitError(
       `${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`
     );
   }
-  mkdirSync5(dirname5(dir), { recursive: true });
+  mkdirSync6(dirname5(dir), { recursive: true });
   const url = cloneUrlFor(remote, opts);
   try {
     execFileSync("git", ["clone", url, dir], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
@@ -4148,7 +4230,7 @@ function sleepSync(ms2) {
 }
 function acquireCheckoutLock(dir, timeoutMs = 3e4) {
   const lockPath = checkoutLockPath(dir);
-  mkdirSync5(dirname5(lockPath), { recursive: true });
+  mkdirSync6(dirname5(lockPath), { recursive: true });
   const deadline = Date.now() + timeoutMs;
   for (; ; ) {
     try {
@@ -4185,17 +4267,17 @@ function acquireCheckoutLock(dir, timeoutMs = 3e4) {
 function syncPassengerCheckout(dir, githubRemote, gitRemoteName, base, clone = {}) {
   const release = acquireCheckoutLock(dir);
   try {
-    if (!existsSync9(`${dir}/.git`) && githubRemote) {
+    if (!existsSync10(`${dir}/.git`) && githubRemote) {
       const url = cloneUrlFor(githubRemote, clone);
       const marker = cloneFailureMarker(dir);
-      if (existsSync9(marker) && readFileSync10(marker, "utf8").split("\n")[0] === url) {
-        return { action: "clone-failed", detail: readFileSync10(marker, "utf8").split("\n").slice(1).join("\n"), repeat: true };
+      if (existsSync10(marker) && readFileSync11(marker, "utf8").split("\n")[0] === url) {
+        return { action: "clone-failed", detail: readFileSync11(marker, "utf8").split("\n").slice(1).join("\n"), repeat: true };
       }
       try {
         ensureRepoCheckout(dir, githubRemote, clone);
       } catch (e) {
         if (!(e instanceof GitError)) throw e;
-        writeFileSync6(marker, `${url}
+        writeFileSync7(marker, `${url}
 ${e.message}`);
         return { action: "clone-failed", detail: e.message, repeat: false };
       }
@@ -4402,7 +4484,7 @@ function noteHeldWorktree(state, h, nowMs = Date.now()) {
 function reconcileHeldWorktrees(state, repo, log, stillRefused) {
   for (const i of state.shipAttention().previous()) {
     if (i.kind !== "worktree_held" || !i.held || i.held.repo !== repo) continue;
-    const gone = !existsSync10(i.held.path);
+    const gone = !existsSync11(i.held.path);
     if (!gone && !(stillRefused && !stillRefused.has(i.held.path))) continue;
     clearShipAttention(state, i.key);
     log.emit(
@@ -4630,30 +4712,30 @@ function roleCapWarnings(ship) {
 
 // src/selftest.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync19, mkdirSync as mkdirSync10, mkdtempSync, readFileSync as readFileSync17, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, mkdtempSync, readFileSync as readFileSync18, rmSync as rmSync10, writeFileSync as writeFileSync12 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // src/agent.ts
 import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
-import { readFileSync as readFileSync16, existsSync as existsSync18, statSync as statSync5, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
+import { readFileSync as readFileSync17, existsSync as existsSync19, statSync as statSync5, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
 import { StringDecoder } from "string_decoder";
 import { finished } from "stream/promises";
-import { join as join19, dirname as dirname7, basename as basename7 } from "path";
+import { join as join20, dirname as dirname7, basename as basename7 } from "path";
 import { createHash as createHash3 } from "crypto";
 
 // src/state.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, existsSync as existsSync11, mkdirSync as mkdirSync6, rmSync as rmSync6, statSync as statSync4, readdirSync as readdirSync4 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync12, mkdirSync as mkdirSync7, rmSync as rmSync7, statSync as statSync4, readdirSync as readdirSync5 } from "fs";
+import { join as join13 } 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 join12(this.dir, ...parts);
+    return join13(this.dir, ...parts);
   }
   /**
    * The timestamp every "new since last poll" check is measured against.
@@ -4664,14 +4746,14 @@ var State = class _State {
    */
   watermark() {
     try {
-      const v = readFileSync11(this.path(".poll-watermark"), "utf8").trim();
+      const v = readFileSync12(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}
 `);
   }
   /**
@@ -4689,19 +4771,19 @@ var State = class _State {
   }
   /** Whole-crew pause, and the per-role sentinels one level down. */
   isPaused() {
-    return existsSync11(this.path(".crew-paused"));
+    return existsSync12(this.path(".crew-paused"));
   }
   isRolePaused(role) {
-    return existsSync11(this.path(`.role-paused-${role}`));
+    return existsSync12(this.path(`.role-paused-${role}`));
   }
   pausedRoles(roles) {
     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) {
-    rmSync6(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
+    rmSync7(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
   }
   /**
    * The release phase (merge, deploy, release) has its own sentinel, one
@@ -4709,11 +4791,11 @@ var State = class _State {
    * while agents keep working.
    */
   isReleasePaused() {
-    return existsSync11(this.path(".release-paused"));
+    return existsSync12(this.path(".release-paused"));
   }
   setReleasePaused(paused) {
-    if (paused) writeFileSync7(this.path(".release-paused"), "");
-    else rmSync6(this.path(".release-paused"), { force: true });
+    if (paused) writeFileSync8(this.path(".release-paused"), "");
+    else rmSync7(this.path(".release-paused"), { force: true });
   }
   /**
    * Why a release cycle must not run right now, or null when it may. Every
@@ -4750,7 +4832,7 @@ var State = class _State {
     const name = _State.safe(rawName);
     const file = this.path(`.${name}.lock`);
     try {
-      const existing = Number.parseInt(readFileSync11(file, "utf8").trim(), 10);
+      const existing = Number.parseInt(readFileSync12(file, "utf8").trim(), 10);
       if (Number.isFinite(existing) && existing > 0) {
         try {
           process.kill(existing, 0);
@@ -4760,13 +4842,13 @@ var State = class _State {
       }
     } catch {
     }
-    writeFileSync7(file, `${process.pid}
+    writeFileSync8(file, `${process.pid}
 `);
     return {
       ok: true,
       release: () => {
         try {
-          rmSync6(file, { force: true });
+          rmSync7(file, { force: true });
         } catch {
         }
       }
@@ -4780,7 +4862,7 @@ var State = class _State {
   releaseInProgress() {
     let names;
     try {
-      names = readdirSync4(this.dir);
+      names = readdirSync5(this.dir);
     } catch {
       return false;
     }
@@ -4788,7 +4870,7 @@ var State = class _State {
       if (!/^\.release-.+\.lock$/.test(n)) continue;
       let pid = 0;
       try {
-        pid = Number.parseInt(readFileSync11(this.path(n), "utf8").trim(), 10);
+        pid = Number.parseInt(readFileSync12(this.path(n), "utf8").trim(), 10);
       } catch {
         continue;
       }
@@ -4874,7 +4956,7 @@ var State = class _State {
   ticketInFlight(recordId) {
     const file = this.path(`.${_State.safe(`crew-ticket-${recordId}`)}.lock`);
     try {
-      const pid = Number.parseInt(readFileSync11(file, "utf8").trim(), 10);
+      const pid = Number.parseInt(readFileSync12(file, "utf8").trim(), 10);
       if (!Number.isFinite(pid) || pid <= 0) return false;
       process.kill(pid, 0);
       return true;
@@ -4908,7 +4990,7 @@ var State = class _State {
     const heldReported = `.release-held-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync11(this.path(f), "utf8").trim() || null;
+        return readFileSync12(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -4917,12 +4999,12 @@ 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;
       },
       clearBlocked: () => {
-        rmSync6(this.path(blocked), { force: true });
+        rmSync7(this.path(blocked), { force: true });
       },
       /**
        * The commit a deploy last failed on.
@@ -4934,11 +5016,11 @@ var State = class _State {
        */
       deployFailedSha: () => read(failed),
       noteDeployFailed: (sha) => {
-        writeFileSync7(this.path(failed), `${sha}
+        writeFileSync8(this.path(failed), `${sha}
 `);
       },
       clearDeployFailed: () => {
-        rmSync6(this.path(failed), { force: true });
+        rmSync7(this.path(failed), { force: true });
       },
       /**
        * Consecutive test-gate failures on the same head (CREW-1368). A failure
@@ -4948,31 +5030,31 @@ 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;
       },
       clearTestGateFailed: () => {
-        rmSync6(this.path(gateFailed), { force: true });
+        rmSync7(this.path(gateFailed), { force: true });
       },
       /** Whether the board was already told about this head's red gate. */
       heldReported: () => {
         try {
-          return readFileSync11(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
+          return readFileSync12(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
         } catch {
           return null;
         }
       },
       noteHeldReported: (signature) => {
-        writeFileSync7(this.path(heldReported), `${signature}
+        writeFileSync8(this.path(heldReported), `${signature}
 `);
       },
       clearHeldReported: () => {
-        rmSync6(this.path(heldReported), { force: true });
+        rmSync7(this.path(heldReported), { force: true });
       },
       testGateReported: (sha) => read(gateReported) === sha,
       noteTestGateReported: (sha) => {
-        writeFileSync7(this.path(gateReported), `${sha}
+        writeFileSync8(this.path(gateReported), `${sha}
 `);
       }
     };
@@ -4995,13 +5077,13 @@ var State = class _State {
     const ticketStreakFile = `.fairness-ticket-streak-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync11(this.path(f), "utf8").trim() || null;
+        return readFileSync12(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
     };
     const clear2 = () => {
-      for (const f of [streakFile, ticketFile, sinceFile, ticketStreakFile]) rmSync6(this.path(f), { force: true });
+      for (const f of [streakFile, ticketFile, sinceFile, ticketStreakFile]) rmSync7(this.path(f), { force: true });
     };
     return {
       /** Consecutive cycles this route had actionable work and did not win. */
@@ -5028,18 +5110,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");
         }
       }
     };
@@ -5060,14 +5142,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync11(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync12(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));
       }
     };
   }
@@ -5083,14 +5165,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync11(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync12(this.path(file), "utf8"));
           return Array.isArray(parsed) ? parsed.filter((x) => typeof x === "string") : [];
         } catch {
           return [];
         }
       },
       persist: (next) => {
-        writeFileSync7(this.path(file), JSON.stringify(next));
+        writeFileSync8(this.path(file), JSON.stringify(next));
       }
     };
   }
@@ -5104,14 +5186,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync11(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync12(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));
       }
     };
   }
@@ -5124,7 +5206,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 {
@@ -5137,7 +5219,7 @@ var State = class _State {
   }
   readInt(file) {
     try {
-      return Number.parseInt(readFileSync11(this.path(file), "utf8").trim(), 10) || 0;
+      return Number.parseInt(readFileSync12(this.path(file), "utf8").trim(), 10) || 0;
     } catch {
       return 0;
     }
@@ -5620,8 +5702,8 @@ var PERISCOPE_COLUMNS = [
 ];
 
 // src/agent-log.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync12, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readdirSync as readdirSync6, readFileSync as readFileSync13, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
+import { join as join14 } from "path";
 
 // src/pending-backoff.ts
 var sleepBackoff = (attempts) => Math.min(6e4 * 2 ** Math.max(0, attempts - 1), 30 * 6e4);
@@ -5793,20 +5875,20 @@ async function addRunToTicket(target, t, recordId, run2) {
     };
   }
 }
-var queueDir = (stateDir) => join13(stateDir, "pending-agent-logs");
+var queueDir = (stateDir) => join14(stateDir, "pending-agent-logs");
 function queueAgentRun(stateDir, name, q) {
-  mkdirSync7(queueDir(stateDir), { recursive: true });
-  writeFileSync8(join13(queueDir(stateDir), `${name}.json`), JSON.stringify(q));
+  mkdirSync8(queueDir(stateDir), { recursive: true });
+  writeFileSync9(join14(queueDir(stateDir), `${name}.json`), JSON.stringify(q));
 }
 async function replayQueuedAgentRuns(stateDir, route, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = queueDir(stateDir);
-  if (!existsSync12(dir)) return 0;
+  if (!existsSync13(dir)) return 0;
   let sent = 0;
-  for (const f of readdirSync5(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join13(dir, f);
+  for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
+    const path = join14(dir, f);
     let q;
     try {
-      q = JSON.parse(readFileSync12(path, "utf8"));
+      q = JSON.parse(readFileSync13(path, "utf8"));
     } catch {
       continue;
     }
@@ -5825,17 +5907,17 @@ async function replayQueuedAgentRuns(stateDir, route, keyFor, log, now = /* @__P
         attempts: 0,
         nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      rmSync7(path, { force: true });
+      rmSync8(path, { force: true });
       sent += 1;
       log.emit(`sent a queued Agent Log report (${f})`);
     } catch (e) {
       if (!(e instanceof AgentLogUnreachableError)) {
-        rmSync7(path, { force: true });
+        rmSync8(path, { force: true });
         log.warn(`dropped a queued Agent Log report (${f}): ${e.message}`);
         continue;
       }
       const attempts = q.attempts + 1;
-      writeFileSync8(path, JSON.stringify({
+      writeFileSync9(path, JSON.stringify({
         ...q,
         attempts,
         warned: true,
@@ -5846,20 +5928,20 @@ async function replayQueuedAgentRuns(stateDir, route, keyFor, log, now = /* @__P
   }
   return sent;
 }
-var countersDir = (stateDir) => join13(stateDir, "pending-ticket-counters");
+var countersDir = (stateDir) => join14(stateDir, "pending-ticket-counters");
 function queueTicketCounters(stateDir, name, q) {
-  mkdirSync7(countersDir(stateDir), { recursive: true });
-  writeFileSync8(join13(countersDir(stateDir), `${name}.json`), JSON.stringify(q));
+  mkdirSync8(countersDir(stateDir), { recursive: true });
+  writeFileSync9(join14(countersDir(stateDir), `${name}.json`), JSON.stringify(q));
 }
 async function replayQueuedTicketCounters(stateDir, route, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = countersDir(stateDir);
-  if (!existsSync12(dir)) return 0;
+  if (!existsSync13(dir)) return 0;
   let sent = 0;
-  for (const f of readdirSync5(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join13(dir, f);
+  for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
+    const path = join14(dir, f);
     let q;
     try {
-      q = JSON.parse(readFileSync12(path, "utf8"));
+      q = JSON.parse(readFileSync13(path, "utf8"));
     } catch {
       continue;
     }
@@ -5868,17 +5950,17 @@ async function replayQueuedTicketCounters(stateDir, route, keyFor, log, now = /*
       const apiKey = await keyFor(q.role);
       if (!apiKey) continue;
       await writeCounters({ ...q.target, apiKey }, q.write);
-      rmSync7(path, { force: true });
+      rmSync8(path, { force: true });
       sent += 1;
       log.emit(`added a queued run's spend to ${q.write.ticketReference ?? q.write.recordId} (${f})`);
     } catch (e) {
       if (!isRetryable(e)) {
-        rmSync7(path, { force: true });
+        rmSync8(path, { force: true });
         log.warn(`dropped a queued ticket counter update (${f}): ${e.message}`);
         continue;
       }
       const attempts = q.attempts + 1;
-      writeFileSync8(path, JSON.stringify({
+      writeFileSync9(path, JSON.stringify({
         ...q,
         attempts,
         warned: true,
@@ -6081,8 +6163,8 @@ var HandoffTranscriptTracker = class {
 };
 
 // src/pending-handoff.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, readdirSync as readdirSync6, readFileSync as readFileSync13, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, readdirSync as readdirSync7, readFileSync as readFileSync14, rmSync as rmSync9, writeFileSync as writeFileSync10 } from "fs";
+import { join as join17 } from "path";
 
 // src/ticket-branch.ts
 import { basename as basename6 } from "path";
@@ -7152,13 +7234,13 @@ 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 join15 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { dirname as dirname6, join as join16 } from "path";
 
 // src/ports.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync13 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join15 } from "path";
 var run = (cmd, args) => {
   try {
     return execFileSync3(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
@@ -7203,7 +7285,7 @@ function ticketForPort(port, s = DEFAULT_PORTS) {
 }
 function worktreeExists(parent, prefix, n) {
   for (const name of [`${prefix}${n}`, `${prefix}${String(n).padStart(3, "0")}`]) {
-    if (existsSync13(join14(parent, name, ".git"))) return true;
+    if (existsSync14(join15(parent, name, ".git"))) return true;
   }
   return false;
 }
@@ -7286,7 +7368,7 @@ function planRunWorktree(dir, cfg, t, role, opts = {}) {
   const existing = worktreeForNumber(dir, num);
   const located = locateBranchForTicket(dir, cfg, t, role);
   const baseRef = hasRemote ? `${remote}/${base}` : base;
-  if (existing && !existing.prunable && existsSync14(existing.path)) {
+  if (existing && !existing.prunable && existsSync15(existing.path)) {
     const branch = existing.branch;
     if (status(existing.path).length > 0) {
       return { action: opts.resumeInterrupted ? "resume-dirty" : "leave-dirty", path: existing.path, branch };
@@ -7302,7 +7384,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 = join15(dirname6(dir), worktreeForTicket(dir, cfg, t, role));
+  const path = join16(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 };
   }
@@ -7356,7 +7438,7 @@ function dropEmptyRunBranch(dir, cfg, branch) {
   if (remoteConfigured(dir, remote) && remoteBranchExists(dir, remote, branch)) return false;
   if (countCommits(dir, `${baseRef}..${branch}`) !== 0) return false;
   const wt = worktrees(dir).find((w) => w.branch === branch && !w.prunable && w.path !== dir);
-  if (wt && existsSync14(wt.path)) {
+  if (wt && existsSync15(wt.path)) {
     if (status(wt.path).length > 0) return false;
     if (gitOk(dir, ["worktree", "remove", wt.path]) === null) return false;
   }
@@ -7364,7 +7446,7 @@ function dropEmptyRunBranch(dir, cfg, branch) {
 }
 async function finishRunWorktree(dir, cfg, branch) {
   const wt = worktrees(dir).find((w) => w.branch === branch && !w.prunable && w.path !== dir);
-  if (!wt || !existsSync14(wt.path)) return { kind: "none" };
+  if (!wt || !existsSync15(wt.path)) return { kind: "none" };
   if (cfg.hooks.handoff) return { kind: "kept-handoff", path: wt.path };
   if (status(wt.path).length > 0) return { kind: "kept-dirty", path: wt.path };
   if (remoteConfigured(dir, cfg.branch.remote) && worktreeHoldsUnpushed(wt.path, cfg.branch.remote)) {
@@ -7376,7 +7458,7 @@ async function finishRunWorktree(dir, cfg, branch) {
     if (pids.length) await killGently(pids);
   }
   gitOk(dir, ["worktree", "remove", wt.path]);
-  return existsSync14(wt.path) ? { kind: "kept-dirty", path: wt.path } : { kind: "removed", path: wt.path };
+  return existsSync15(wt.path) ? { kind: "kept-dirty", path: wt.path } : { kind: "removed", path: wt.path };
 }
 
 // src/handoff-guard.ts
@@ -7759,20 +7841,20 @@ async function guardRunStrays(route, ship, tracker, role, workingId, since2, log
 
 // src/pending-handoff.ts
 var PENDING_MAX_AGE_MS = 48 * 36e5;
-var pendingDirFor = (stateDir) => join16(stateDir, "pending-handoffs");
-var stateDirOfStream = (streamPath) => join16(streamPath, "..", "..");
+var pendingDirFor = (stateDir) => join17(stateDir, "pending-handoffs");
+var stateDirOfStream = (streamPath) => join17(streamPath, "..", "..");
 function writePendingHandoff(stateDir, rec) {
   const dir = pendingDirFor(stateDir);
-  mkdirSync8(dir, { recursive: true });
-  writeFileSync9(join16(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
+  mkdirSync9(dir, { recursive: true });
+  writeFileSync10(join17(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
 }
 function listPendingHandoffs(stateDir, route) {
   const dir = pendingDirFor(stateDir);
-  if (!existsSync15(dir)) return [];
+  if (!existsSync16(dir)) return [];
   const out = [];
-  for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
+  for (const f of readdirSync7(dir).filter((n) => n.endsWith(".json")).sort()) {
     try {
-      const rec = JSON.parse(readFileSync13(join16(dir, f), "utf8"));
+      const rec = JSON.parse(readFileSync14(join17(dir, f), "utf8"));
       if (rec.version === 1 && rec.ticketRecordId && (!route || rec.route === route)) out.push(rec);
     } catch {
     }
@@ -7780,7 +7862,7 @@ function listPendingHandoffs(stateDir, route) {
   return out;
 }
 function removePendingHandoff(stateDir, ticketRecordId) {
-  rmSync8(join16(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
+  rmSync9(join17(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
 }
 function pendingHandoffFor(stateDir, ticketRecordId) {
   return listPendingHandoffs(stateDir).find((r) => r.ticketRecordId === ticketRecordId);
@@ -7890,8 +7972,8 @@ function expandSkillMarkers(text, lookup2, opts = {}) {
 }
 
 // src/skills.ts
-import { readFileSync as readFileSync15, readdirSync as readdirSync7, existsSync as existsSync17 } from "fs";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync16, readdirSync as readdirSync8, existsSync as existsSync18 } from "fs";
+import { join as join19 } from "path";
 import { parse as parseYaml } from "yaml";
 import { TablationClient as TablationClient3, StaleWriteError as StaleWriteError3, TablationApiError as TablationApiError2 } from "@tablation/client";
 
@@ -7907,8 +7989,8 @@ ${additions}`;
 }
 
 // src/agents.ts
-import { readFileSync as readFileSync14, existsSync as existsSync16 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync17 } from "fs";
+import { join as join18 } from "path";
 import { TablationClient as TablationClient2, StaleWriteError as StaleWriteError2, TablationApiError } from "@tablation/client";
 var PERSONA_NAME = {
   dev: "Developer",
@@ -7922,12 +8004,12 @@ var CREW_AGENT_COLUMN = "agent_id";
 var AgentsSyncError = class extends Error {
 };
 function personaDefaultPrompt(promptsDir, role) {
-  const briefPath = join17(promptsDir, "personas", `lane-${role}.md`);
-  if (!existsSync16(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
-  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync14(briefPath, "utf8");
-  const commonPath = join17(promptsDir, "personas", "common.md");
-  if (!existsSync16(commonPath)) return readFileSync14(briefPath, "utf8");
-  return `${readFileSync14(commonPath, "utf8")}${readFileSync14(briefPath, "utf8")}`;
+  const briefPath = join18(promptsDir, "personas", `lane-${role}.md`);
+  if (!existsSync17(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
+  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync15(briefPath, "utf8");
+  const commonPath = join18(promptsDir, "personas", "common.md");
+  if (!existsSync17(commonPath)) return readFileSync15(briefPath, "utf8");
+  return `${readFileSync15(commonPath, "utf8")}${readFileSync15(briefPath, "utf8")}`;
 }
 async function resolveAgentId(route, role, opts) {
   const cached = route.resolved?.agentPersonas?.[role]?.agentId;
@@ -8374,7 +8456,7 @@ function describeCrewLink(o) {
 var SkillSyncError = class extends Error {
 };
 function parseSkillFile(path) {
-  const text = readFileSync15(path, "utf8");
+  const text = readFileSync16(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];
@@ -8387,9 +8469,9 @@ function parseSkillFile(path) {
   return { name: meta.name, description: meta.description, prompt: body, file: path };
 }
 function listLocalSkills(promptsDir) {
-  const dir = join18(promptsDir, "skills");
-  if (!existsSync17(dir)) return [];
-  return readdirSync7(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join18(dir, f)));
+  const dir = join19(promptsDir, "skills");
+  if (!existsSync18(dir)) return [];
+  return readdirSync8(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join19(dir, f)));
 }
 async function syncSkills(route, opts) {
   if (!route.resolved) {
@@ -8591,26 +8673,26 @@ var AgentError = class extends Error {
 };
 var AgentSpawnError = class extends AgentError {
 };
-var digestPathFor = (stateDir, routeLabel, role, runId) => join19(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPathFor = (stateDir, routeLabel, role, runId) => join20(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
 function planAgentRun(o) {
-  const briefPath = join19(o.route.promptsDir, "personas", `lane-${o.role}.md`);
-  if (!existsSync18(briefPath)) {
+  const briefPath = join20(o.route.promptsDir, "personas", `lane-${o.role}.md`);
+  if (!existsSync19(briefPath)) {
     throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
   }
-  const commonPath = join19(o.route.promptsDir, "personas", "common.md");
-  const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync18(commonPath);
+  const commonPath = join20(o.route.promptsDir, "personas", "common.md");
+  const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync19(commonPath);
   const now = o.now ?? (() => Date.now());
   const routeLabel = routeSlug(o.route.route);
   const ownDigest = o.runId ? digestPathFor(o.stateDir, routeLabel, o.role, o.runId) : void 0;
-  const digestPath2 = ownDigest && existsSync18(ownDigest) ? ownDigest : digestPathFor(o.stateDir, routeLabel, o.role);
+  const digestPath2 = ownDigest && existsSync19(ownDigest) ? ownDigest : digestPathFor(o.stateDir, routeLabel, o.role);
   let digest;
   let ageSeconds;
-  if (existsSync18(digestPath2)) {
+  if (existsSync19(digestPath2)) {
     ageSeconds = Math.floor((now() - statSync5(digestPath2).mtimeMs) / 1e3);
-    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync16(digestPath2, "utf8");
+    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync17(digestPath2, "utf8");
   }
-  const common = usesCommon ? readFileSync16(commonPath, "utf8") : "";
-  const brief = readFileSync16(briefPath, "utf8");
+  const common = usesCommon ? readFileSync17(commonPath, "utf8") : "";
+  const brief = readFileSync17(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]));
@@ -8632,7 +8714,7 @@ function planAgentRun(o) {
     digest
   });
   const promptSha = createHash3("sha256").update(expanded.text).digest("hex");
-  const streamsDir = join19(o.stateDir, "streams");
+  const streamsDir = join20(o.stateDir, "streams");
   const base = `${routeLabel}-${o.role}-${o.cycle}${o.runId ? `-${o.runId}` : ""}`;
   const seat = resolveSeat(o.ship, o.route, o.role, o.agentPersona ?? (o.agentModel ? { model: o.agentModel } : {}), o.repo);
   const { toolchain, model } = seat;
@@ -8702,8 +8784,8 @@ function planAgentRun(o) {
     digestAttached: digest !== void 0,
     digestAgeSeconds: ageSeconds,
     model,
-    streamPath: join19(streamsDir, `${base}.jsonl`),
-    eventsPath: join19(streamsDir, `${base}.events.jsonl`),
+    streamPath: join20(streamsDir, `${base}.jsonl`),
+    eventsPath: join20(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
     ticketRecordId: o.ticketRecordId ?? null,
     repo: o.repo ?? null,
@@ -8734,7 +8816,7 @@ function describePlan(p) {
 var pidPathFor = (streamPath) => `${streamPath}.pid`;
 function readRunSidecar(streamPath) {
   try {
-    const sc = JSON.parse(readFileSync16(pidPathFor(streamPath), "utf8"));
+    const sc = JSON.parse(readFileSync17(pidPathFor(streamPath), "utf8"));
     return typeof sc.pid === "number" && typeof sc.spawnedAt === "string" && typeof sc.role === "string" ? sc : null;
   } catch {
     return null;
@@ -8770,7 +8852,7 @@ function identityOf(plan, adapterHarness) {
 var withoutKey = ({ apiKey: _apiKey, ...rest }) => rest;
 function openSink(path) {
   try {
-    mkdirSync9(dirname7(path), { recursive: true });
+    mkdirSync10(dirname7(path), { recursive: true });
     return createWriteStream(path, { flags: "a" });
   } catch {
     return void 0;
@@ -8952,7 +9034,7 @@ var RunObserver = class {
 };
 function writeRunMeta(id, startedAt, liveTicket, extra) {
   try {
-    writeFileSync10(`${id.streamPath}.meta.json`, JSON.stringify({
+    writeFileSync11(`${id.streamPath}.meta.json`, JSON.stringify({
       route: id.route,
       role: id.role,
       hint: id.ticket,
@@ -9112,7 +9194,7 @@ function spawnAgent(plan, emit, hintMoved) {
   return new Promise((resolve6, reject) => {
     let streamFd;
     try {
-      mkdirSync9(dirname7(plan.streamPath), { recursive: true });
+      mkdirSync10(dirname7(plan.streamPath), { recursive: true });
       streamFd = openSync3(plan.streamPath, "a");
     } catch (e) {
       void endSink(eventsSink);
@@ -9147,7 +9229,7 @@ function spawnAgent(plan, emit, hintMoved) {
         promptSha: plan.promptSha
       };
       try {
-        writeFileSync10(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
+        writeFileSync11(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
       } catch {
       }
     }
@@ -9650,7 +9732,7 @@ async function runSelftest(i, deps = realDeps) {
     ...adapter.runEnv(spec),
     [KEY_VAR]: i.apiKey
   };
-  const cwd = mkdtempSync(join20(tmpdir2(), "crew-selftest-"));
+  const cwd = mkdtempSync(join21(tmpdir2(), "crew-selftest-"));
   try {
     const run2 = await deps.run({
       bin: invocation.bin,
@@ -9672,7 +9754,7 @@ async function runSelftest(i, deps = realDeps) {
     return finish({ ok: false, failure, detail, ...usage2 });
   } finally {
     try {
-      rmSync9(cwd, { recursive: true, force: true });
+      rmSync10(cwd, { recursive: true, force: true });
     } catch {
     }
   }
@@ -9683,11 +9765,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 fileFor2 = (stateDir) => join20(stateDir, "selftest.json");
+var fileFor2 = (stateDir) => join21(stateDir, "selftest.json");
 function readSelftest(stateDir) {
   try {
     const p = fileFor2(stateDir);
-    return existsSync19(p) ? JSON.parse(readFileSync17(p, "utf8")) : {};
+    return existsSync20(p) ? JSON.parse(readFileSync18(p, "utf8")) : {};
   } catch {
     return {};
   }
@@ -9695,8 +9777,8 @@ function readSelftest(stateDir) {
 function recordSelftest(stateDir, results) {
   const all = readSelftest(stateDir);
   for (const r of results) all[r.toolchain] = r;
-  mkdirSync10(stateDir, { recursive: true });
-  writeFileSync11(fileFor2(stateDir), `${JSON.stringify(all, null, 2)}
+  mkdirSync11(stateDir, { recursive: true });
+  writeFileSync12(fileFor2(stateDir), `${JSON.stringify(all, null, 2)}
 `);
 }
 function doctorSelftestLines(stored, toolchains) {
@@ -9708,7 +9790,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve5, dirname as dirname20, join as join38, basename as basename12 } from "path";
+import { resolve as resolve5, dirname as dirname20, join as join39, basename as basename12 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname2, homedir as homedir10 } from "os";
 import { spawnSync as spawnSync7 } from "child_process";
@@ -9890,14 +9972,14 @@ function rosterMarkdown(roster, meId) {
 }
 
 // src/connect-resume.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync18, rmSync as rmSync10, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname8, join as join21 } from "path";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync19, rmSync as rmSync11, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname8, join as join22 } from "path";
 function lastSessionFile(stateDir) {
-  return join21(stateDir, "connect-session.json");
+  return join22(stateDir, "connect-session.json");
 }
 function readPointers(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync18(lastSessionFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync19(lastSessionFile(stateDir), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     const out = {};
     for (const [host, v] of Object.entries(parsed)) {
@@ -9911,8 +9993,8 @@ function readPointers(stateDir) {
 }
 function writePointers(stateDir, pointers) {
   const file = lastSessionFile(stateDir);
-  mkdirSync11(dirname8(file), { recursive: true });
-  writeFileSync12(file, `${JSON.stringify(pointers, null, 2)}
+  mkdirSync12(dirname8(file), { recursive: true });
+  writeFileSync13(file, `${JSON.stringify(pointers, null, 2)}
 `, { mode: 384 });
 }
 function rememberSession(stateDir, host, workspaceSlug) {
@@ -9929,7 +10011,7 @@ function forgetWorkspace(stateDir, host, workspaceSlug) {
     const { [host]: _old, ...rest } = all;
     const next = left.length ? { ...rest, [host]: left } : rest;
     if (Object.keys(next).length) writePointers(stateDir, next);
-    else rmSync10(lastSessionFile(stateDir), { force: true });
+    else rmSync11(lastSessionFile(stateDir), { force: true });
   } catch {
   }
 }
@@ -9969,7 +10051,7 @@ function forgetSession(stateDir, host) {
   try {
     const { [host]: _gone, ...rest } = readPointers(stateDir);
     if (Object.keys(rest).length) writePointers(stateDir, rest);
-    else rmSync10(lastSessionFile(stateDir), { force: true });
+    else rmSync11(lastSessionFile(stateDir), { force: true });
   } catch {
   }
 }
@@ -9997,15 +10079,15 @@ async function signOutSessions(o) {
 }
 
 // src/reset.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync19, readdirSync as readdirSync8, rmSync as rmSync11, statSync as statSync6, writeFileSync as writeFileSync13 } from "fs";
-import { dirname as dirname9, join as join22 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync20, readdirSync as readdirSync9, rmSync as rmSync12, statSync as statSync6, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname9, join as join23 } from "path";
 import { hostFromUrl as hostFromUrl3 } from "@tablation/client";
 function clonedCheckoutsFile(stateDir) {
-  return join22(stateDir, "cloned-checkouts.json");
+  return join23(stateDir, "cloned-checkouts.json");
 }
 function readClonedCheckouts(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync19(clonedCheckoutsFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync20(clonedCheckoutsFile(stateDir), "utf8"));
     return Array.isArray(parsed) ? parsed.filter((d) => typeof d === "string") : [];
   } catch {
     return [];
@@ -10015,8 +10097,8 @@ function recordClonedCheckout(stateDir, dir) {
   const known = readClonedCheckouts(stateDir);
   if (known.includes(dir)) return;
   const file = clonedCheckoutsFile(stateDir);
-  mkdirSync12(dirname9(file), { recursive: true });
-  writeFileSync13(file, `${JSON.stringify([...known, dir], null, 2)}
+  mkdirSync13(dirname9(file), { recursive: true });
+  writeFileSync14(file, `${JSON.stringify([...known, dir], null, 2)}
 `);
 }
 var mark = (dryRun) => dryRun ? "would-remove" : "removed";
@@ -10068,8 +10150,8 @@ async function runReset(o, fx) {
     for (const dir of readClonedCheckouts(o.stateDir)) steps.push(removeCheckout(dir, o.dryRun, fx));
   }
   steps.push(...removeState(o.stateDir, o.dryRun));
-  if (existsSync20(o.configFile)) {
-    if (!o.dryRun) rmSync11(o.configFile, { force: true });
+  if (existsSync21(o.configFile)) {
+    if (!o.dryRun) rmSync12(o.configFile, { force: true });
     steps.push({ step: "config", target: o.configFile, action: mark(o.dryRun) });
   } else {
     steps.push({ step: "config", target: o.configFile, action: "absent" });
@@ -10077,7 +10159,7 @@ async function runReset(o, fx) {
   return steps;
 }
 function removeCheckout(dir, dryRun, fx) {
-  if (!existsSync20(dir)) return { step: "checkout", target: dir, action: "absent", detail: "already gone" };
+  if (!existsSync21(dir)) return { step: "checkout", target: dir, action: "absent", detail: "already gone" };
   const { dirty, linkedWorktrees } = fx.inspectCheckout(dir);
   if (dirty.length) {
     return { step: "checkout", target: dir, action: "kept", detail: `has uncommitted changes (${dirty.length} path${dirty.length === 1 ? "" : "s"}: ${dirty.slice(0, 5).join(", ")}${dirty.length > 5 ? ", \u2026" : ""})` };
@@ -10085,21 +10167,21 @@ function removeCheckout(dir, dryRun, fx) {
   if (linkedWorktrees.length) {
     return { step: "checkout", target: dir, action: "kept", detail: `has linked worktrees (${linkedWorktrees.join(", ")}); remove them first` };
   }
-  if (!dryRun) rmSync11(dir, { recursive: true, force: true });
+  if (!dryRun) rmSync12(dir, { recursive: true, force: true });
   return { step: "checkout", target: dir, action: mark(dryRun) };
 }
 function removeState(stateDir, dryRun) {
   const out = [];
-  const targets = [join22(stateDir, "resolved"), join22(stateDir, "keys"), clonedCheckoutsFile(stateDir), join22(stateDir, "connect-session.json"), join22(stateDir, "reload-requested"), join22(stateDir, "daemon.started")];
+  const targets = [join23(stateDir, "resolved"), join23(stateDir, "keys"), clonedCheckoutsFile(stateDir), join23(stateDir, "connect-session.json"), join23(stateDir, "reload-requested"), join23(stateDir, "daemon.started")];
   try {
-    for (const name of readdirSync8(stateDir)) {
-      if (name.startsWith(".") && statSync6(join22(stateDir, name)).isFile()) targets.push(join22(stateDir, name));
+    for (const name of readdirSync9(stateDir)) {
+      if (name.startsWith(".") && statSync6(join23(stateDir, name)).isFile()) targets.push(join23(stateDir, name));
     }
   } catch {
   }
   for (const t of targets) {
-    if (!existsSync20(t)) continue;
-    if (!dryRun) rmSync11(t, { recursive: true, force: true });
+    if (!existsSync21(t)) continue;
+    if (!dryRun) rmSync12(t, { recursive: true, force: true });
     out.push({ step: "state", target: t, action: mark(dryRun) });
   }
   if (!out.length) out.push({ step: "state", target: stateDir, action: "absent", detail: "nothing to remove" });
@@ -10886,8 +10968,8 @@ ${waiting.map((t) => `| ${displayKey2(t)} | ${t.status} | ${blockers(t, i)} |`).
 }
 
 // src/poll.ts
-import { writeFileSync as writeFileSync14 } from "fs";
-import { join as join23 } from "path";
+import { writeFileSync as writeFileSync15 } from "fs";
+import { join as join24 } from "path";
 
 // src/stalled.ts
 var STALLED_AFTER_CYCLES = 30;
@@ -11194,7 +11276,7 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route, role, runId) => join23(stateDir, `digest-${route}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPath = (stateDir, route, role, runId) => join24(stateDir, `digest-${route}-${role}${runId ? `-${runId}` : ""}.md`);
 function otherRunsRemoved(tickets, own) {
   if (!own) return tickets;
   return tickets.filter((t) => t.id === own.ticket.id || !own.inFlight(t.id));
@@ -11272,7 +11354,7 @@ function writeDigest(o, d, role, stateDir, runId, own) {
 
 ${body}` : body;
     const path = digestPath(stateDir, routeSlug(o.route.route), role, runId);
-    writeFileSync14(path, text);
+    writeFileSync15(path, text);
     o.emit.emit(`queue digest written for ${role} (${Buffer.byteLength(text)} bytes)`, {
       data: { role, bytes: Buffer.byteLength(text) }
     });
@@ -11755,13 +11837,13 @@ Ship ${shipName2} found: ${problem}. The release refuses to squash a ref nobody
 var localRefSkipReported = (ticket, problem, events) => events.some((e) => e.record_id === ticket.id && e.event_type === "local_ref_skip" && (e.message ?? "").includes(problem));
 
 // src/connect-wizard.ts
-import { delimiter, dirname as dirname10, join as join24 } from "path";
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync21, mkdirSync as mkdirSync13, writeFileSync as writeFileSync15 } from "fs";
+import { delimiter, dirname as dirname10, join as join25 } from "path";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync22, mkdirSync as mkdirSync14, writeFileSync as writeFileSync16 } from "fs";
 import { stringify } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
 function shouldRunWizard(opts) {
   if (!opts.isTTY) return false;
-  const exists = opts.configExists ?? existsSync21;
+  const exists = opts.configExists ?? existsSync22;
   return !configSearchPath(opts.crewHome).some((p) => exists(p));
 }
 function firstRunConfigPath() {
@@ -11778,7 +11860,7 @@ function defaultIsExecutable(p) {
 function findOnPath2(name, pathEnv, isExecutable = defaultIsExecutable) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join24(dir, name);
+    const candidate = join25(dir, name);
     if (isExecutable(candidate)) return candidate;
   }
   return void 0;
@@ -11839,9 +11921,9 @@ routes:
 ${routeBlock}`;
 }
 function writeNewConfig(path, text) {
-  mkdirSync13(dirname10(path), { recursive: true });
+  mkdirSync14(dirname10(path), { recursive: true });
   try {
-    writeFileSync15(path, text, { mode: 384, flag: "wx" });
+    writeFileSync16(path, text, { mode: 384, flag: "wx" });
     return true;
   } catch (e) {
     if (e.code === "EEXIST") return false;
@@ -11875,7 +11957,7 @@ Wrote ${o.configPath}.
 // src/connect-json.ts
 import { accessSync as accessSync3, constants as constants3 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname11, join as join25 } from "path";
+import { dirname as dirname11, join as join26 } from "path";
 import { delimiter as delimiter2 } from "path";
 var CHOICE_EXIT_CODE = 3;
 function createEmitter(json, write) {
@@ -11914,12 +11996,12 @@ function agentBinSearchDirs(home, pathEnv, extraPath) {
   const dirs = [
     ...pathEnv.split(delimiter2),
     ...(extraPath ?? "").split(delimiter2),
-    join25(home, ".local/bin"),
-    join25(home, ".claude/local"),
+    join26(home, ".local/bin"),
+    join26(home, ".claude/local"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
-    join25(home, ".npm-global/bin"),
-    join25(home, ".volta/bin")
+    join26(home, ".npm-global/bin"),
+    join26(home, ".volta/bin")
   ];
   return [...new Set(dirs.filter(Boolean))];
 }
@@ -11955,8 +12037,8 @@ function flagWizardAnswers(f, env) {
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync16, existsSync as existsSync22, copyFileSync, mkdirSync as mkdirSync14, mkdtempSync as mkdtempSync2, rmSync as rmSync12 } from "fs";
-import { dirname as dirname12, join as join26 } from "path";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync17, existsSync as existsSync23, copyFileSync, mkdirSync as mkdirSync15, mkdtempSync as mkdtempSync2, rmSync as rmSync13 } from "fs";
+import { dirname as dirname12, join as join27 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 
 // src/release.ts
@@ -12697,13 +12779,13 @@ async function bump(o, size) {
     }
     return printed;
   }
-  const files = o.repo.release.versionFiles.map((f) => join26(o.cwd, f));
+  const files = o.repo.release.versionFiles.map((f) => join27(o.cwd, f));
   const first = files[0];
-  if (!existsSync22(first)) {
+  if (!existsSync23(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
     return null;
   }
-  const current = JSON.parse(readFileSync20(first, "utf8")).version;
+  const current = JSON.parse(readFileSync21(first, "utf8")).version;
   if (!current) {
     o.emit.error(`no version field in ${o.repo.release.versionFiles[0]}`);
     return null;
@@ -12716,27 +12798,27 @@ async function bump(o, size) {
     return version;
   }
   for (const f of files) {
-    const src = readFileSync20(f, "utf8");
+    const src = readFileSync21(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;
     }
-    writeFileSync16(f, out);
+    writeFileSync17(f, out);
   }
   return version;
 }
 function writeChangelog(o, version, entries) {
   const file = o.repo.release.changelog;
   if (!file || entries.length === 0) return;
-  const path = join26(o.cwd, file);
+  const path = join27(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) ? readFileSync20(path, "utf8") : "# Changelog\n";
-  writeFileSync16(path, insertChangelogSection(existing, section));
+  const existing = existsSync23(path) ? readFileSync21(path, "utf8") : "# Changelog\n";
+  writeFileSync17(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
   if (!o.repo.hooks.released) return void 0;
@@ -12819,7 +12901,7 @@ function closeReleaseCheckout(cwd, root, dir, branch, run2 = gitOk) {
     run2(cwd, ["worktree", "remove", "--force", dir]);
   } finally {
     try {
-      rmSync12(root, { recursive: true, force: true });
+      rmSync13(root, { recursive: true, force: true });
     } finally {
       run2(cwd, ["worktree", "prune"]);
       run2(cwd, ["branch", "-D", branch]);
@@ -12829,8 +12911,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(join26(tmpdir3(), "crew-release-"));
-  const dir = join26(root, "checkout");
+  const root = mkdtempSync2(join27(tmpdir3(), "crew-release-"));
+  const dir = join27(root, "checkout");
   o.emit.emit(`release checkout: ${dir}`, { step: "release" });
   const close = () => closeReleaseCheckout(o.cwd, root, dir, branch);
   try {
@@ -12840,10 +12922,10 @@ function openReleaseCheckout(o) {
     throw e;
   }
   for (const f of o.repo.worktrees.copy) {
-    const src = join26(o.cwd, f);
-    if (!existsSync22(src)) continue;
-    mkdirSync14(dirname12(join26(dir, f)), { recursive: true });
-    copyFileSync(src, join26(dir, f));
+    const src = join27(o.cwd, f);
+    if (!existsSync23(src)) continue;
+    mkdirSync15(dirname12(join27(dir, f)), { recursive: true });
+    copyFileSync(src, join27(dir, f));
   }
   return { dir, branch, close };
 }
@@ -13544,12 +13626,12 @@ Passed: ${passed}.${willClose ? " Closing this alert." : ""}`,
 }
 
 // src/live-runs.ts
-import { existsSync as existsSync24, readdirSync as readdirSync10 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync11 } from "fs";
+import { join as join29 } from "path";
 
 // src/interrupted.ts
-import { existsSync as existsSync23, readdirSync as readdirSync9, readFileSync as readFileSync21 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync24, readdirSync as readdirSync10, readFileSync as readFileSync22 } from "fs";
+import { join as join28 } 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.";
@@ -13568,21 +13650,21 @@ var pidAlive = (pid) => {
 };
 function runFinished(streamPath) {
   const path = `${streamPath}.meta.json`;
-  if (!existsSync23(path)) return false;
+  if (!existsSync24(path)) return false;
   try {
-    return JSON.parse(readFileSync21(path, "utf8")).running !== true;
+    return JSON.parse(readFileSync22(path, "utf8")).running !== true;
   } catch {
     return true;
   }
 }
 function orphanedStreams(o) {
-  const dir = join27(o.stateDir, "streams");
-  if (!existsSync23(dir)) return [];
+  const dir = join28(o.stateDir, "streams");
+  if (!existsSync24(dir)) return [];
   const ownerAlive = o.isOwnerAlive ?? pidAlive;
   const out = [];
-  for (const name of readdirSync9(dir)) {
+  for (const name of readdirSync10(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join27(dir, name);
+    const streamPath = join28(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || sidecar.route !== o.routeLabel) continue;
@@ -13636,12 +13718,12 @@ async function reconcileRuns(o) {
 
 // src/live-runs.ts
 function liveRuns(stateDir, isAlive = runIsAlive) {
-  const dir = join28(stateDir, "streams");
-  if (!existsSync24(dir)) return [];
+  const dir = join29(stateDir, "streams");
+  if (!existsSync25(dir)) return [];
   const out = [];
-  for (const name of readdirSync10(dir)) {
+  for (const name of readdirSync11(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join28(dir, name);
+    const streamPath = join29(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || !isAlive(sidecar)) continue;
@@ -13911,7 +13993,7 @@ function missingReleaserWarning(repo, release, ships, now = Date.now()) {
 }
 
 // src/watch.ts
-import { watch as watchFile, existsSync as existsSync25, statSync as statSync7, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
+import { watch as watchFile, existsSync as existsSync26, statSync as statSync7, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
 var E = "\x1B[";
 var dim = (s) => `${E}2m${s}${E}0m`;
 var bold = (s) => `${E}1m${s}${E}0m`;
@@ -14012,7 +14094,7 @@ function renderHeaders(states, now = Date.now()) {
   return states.map((s) => renderHeader(s, now)).join("");
 }
 function readFrom(file, from) {
-  if (!existsSync25(file)) return { events: [], offset: from };
+  if (!existsSync26(file)) return { events: [], offset: from };
   const size = statSync7(file).size;
   if (size < from) return readFrom(file, 0);
   if (size === from) return { events: [], offset: from };
@@ -14255,17 +14337,17 @@ function nextRoles(decision, ran) {
 }
 
 // src/ship-name.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync23, renameSync as renameSync2, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync24, renameSync as renameSync2, writeFileSync as writeFileSync19 } 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 createHash4 } from "crypto";
-import { existsSync as existsSync26, mkdirSync as mkdirSync15, readFileSync as readFileSync22, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname13, join as join29 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync23, writeFileSync as writeFileSync18 } from "fs";
+import { dirname as dirname13, join as join30 } from "path";
 function machineIdPathFor(stateDir) {
-  return join29(stateDir, "machine-id");
+  return join30(stateDir, "machine-id");
 }
 var sha256 = (s) => createHash4("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
@@ -14278,8 +14360,8 @@ function readRawMachineId(platform2 = process.platform) {
       return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(out)?.[1];
     }
     for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
-      if (existsSync26(p)) {
-        const id = readFileSync22(p, "utf8").trim();
+      if (existsSync27(p)) {
+        const id = readFileSync23(p, "utf8").trim();
         if (id) return id;
       }
     }
@@ -14290,15 +14372,15 @@ function readRawMachineId(platform2 = process.platform) {
 function ensureMachineId(stateDir, opts = {}) {
   if (opts.override?.trim()) return sha256(opts.override.trim());
   const path = machineIdPathFor(stateDir);
-  if (existsSync26(path)) {
-    const cached = readFileSync22(path, "utf8").trim();
+  if (existsSync27(path)) {
+    const cached = readFileSync23(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);
-  mkdirSync15(dirname13(path), { recursive: true });
-  writeFileSync17(path, `${hashed}
+  mkdirSync16(dirname13(path), { recursive: true });
+  writeFileSync18(path, `${hashed}
 `, { mode: 384 });
   return hashed;
 }
@@ -14369,34 +14451,34 @@ async function syncRouteName(i) {
   return { status: "ok", ...base, action, name: i.local };
 }
 function readSyncedName(resolvedFile) {
-  if (!existsSync27(resolvedFile)) return void 0;
+  if (!existsSync28(resolvedFile)) return void 0;
   try {
-    const v = JSON.parse(readFileSync23(resolvedFile, "utf8")).shipName;
+    const v = JSON.parse(readFileSync24(resolvedFile, "utf8")).shipName;
     return typeof v === "string" ? v : void 0;
   } catch {
     return void 0;
   }
 }
 function writeSyncedName(resolvedFile, name) {
-  if (!existsSync27(resolvedFile)) return;
+  if (!existsSync28(resolvedFile)) return;
   let raw;
   try {
-    raw = JSON.parse(readFileSync23(resolvedFile, "utf8"));
+    raw = JSON.parse(readFileSync24(resolvedFile, "utf8"));
   } catch {
     return;
   }
   if (raw.shipName === name) return;
   raw.shipName = name;
-  mkdirSync16(dirname14(resolvedFile), { recursive: true });
+  mkdirSync17(dirname14(resolvedFile), { recursive: true });
   const tmp = `${resolvedFile}.tmp${process.pid}`;
-  writeFileSync18(tmp, `${JSON.stringify(raw, null, 2)}
+  writeFileSync19(tmp, `${JSON.stringify(raw, null, 2)}
 `);
   renameSync2(tmp, resolvedFile);
 }
 async function reconcileShipName(i) {
   let local = i.ship.name;
   try {
-    local = shipNameOfYaml(readFileSync23(i.configFile, "utf8")) ?? local;
+    local = shipNameOfYaml(readFileSync24(i.configFile, "utf8")) ?? local;
   } catch {
   }
   const resolvedFile = resolvedPathFor(i.stateDir, i.route);
@@ -14420,8 +14502,8 @@ async function reconcileShipName(i) {
   }
   if (result.status !== "ok") return result;
   if (result.action === "adopt" || result.action === "row-wins") {
-    const text = readFileSync23(i.configFile, "utf8");
-    writeFileSync18(i.configFile, setShipNameInYaml(text, result.name));
+    const text = readFileSync24(i.configFile, "utf8");
+    writeFileSync19(i.configFile, setShipNameInYaml(text, result.name));
     i.ship.name = result.name;
     if (result.action === "row-wins") {
       i.emit?.warn(
@@ -15071,7 +15153,7 @@ function describeCapability(i) {
 }
 
 // src/agents-sync-run.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync24, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync18, readFileSync as readFileSync25, writeFileSync as writeFileSync20 } from "fs";
 import { dirname as dirname15 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
@@ -15105,12 +15187,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 = existsSync28(resolvedPath) ? JSON.parse(readFileSync24(resolvedPath, "utf8")) : {};
+    const raw = existsSync29(resolvedPath) ? JSON.parse(readFileSync25(resolvedPath, "utf8")) : {};
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
-    mkdirSync17(dirname15(resolvedPath), { recursive: true });
-    writeFileSync19(resolvedPath, `${JSON.stringify(raw, null, 2)}
+    mkdirSync18(dirname15(resolvedPath), { recursive: true });
+    writeFileSync20(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
     if (target.resolved) {
       target.resolved.agentPersonas = personaResult.agentPersonas;
@@ -15214,7 +15296,7 @@ async function showLogEntry(route, entryId, opts = {}) {
 
 // src/repos-check.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { readFileSync as readFileSync25 } from "fs";
+import { readFileSync as readFileSync26 } from "fs";
 import { basename as basename8 } from "path";
 var POSIX_SHELL = /^(?:ba|z|da|k|a|mk)?sh$|^fish$/;
 function checkHookSyntax(script, shell) {
@@ -15255,7 +15337,7 @@ function checkRepoSpec(dir, opts = {}) {
   }
   let parsed;
   try {
-    parsed = parseRepoConfig(readFileSync25(file, "utf8"), file);
+    parsed = parseRepoConfig(readFileSync26(file, "utf8"), file);
   } catch (e) {
     if (!(e instanceof RepoConfigError)) throw e;
     return { ...empty, file, error: e.message, exitCode: 1 };
@@ -15312,7 +15394,7 @@ import { isMap as isMap2, parseDocument as parseDocument3, YAMLMap } from "yaml"
 
 // src/repos-cmd.ts
 import { homedir as homedir9 } from "os";
-import { basename as basename9, join as join30, resolve as resolve3 } from "path";
+import { basename as basename9, join as join31, resolve as resolve3 } from "path";
 import { isMap, isSeq, parseDocument as parseDocument2, stringify as stringify2 } from "yaml";
 var ReposError = class extends Error {
 };
@@ -15590,7 +15672,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) : join30(expandDir(basePath, i.base), i.route.split("/")[0], name);
+  const target = i.dir ? expandDir(i.dir, i.base) : join31(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 };
 }
@@ -15989,7 +16071,7 @@ ${run2.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename10, dirname as dirname17, join as join31 } from "path";
+import { basename as basename10, dirname as dirname17, join as join32 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -16012,8 +16094,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 join31(dirname17(existing[0]), SAMPLE_REPO);
-  return join31(reposBase, workspace, SAMPLE_REPO);
+  if (existing.length > 0) return join32(dirname17(existing[0]), SAMPLE_REPO);
+  return join32(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
 function sampleDescription() {
@@ -16105,8 +16187,8 @@ function schedulerInstalled(plan, exists, crontab) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync29, readFileSync as readFileSync26, readdirSync as readdirSync11 } from "fs";
-import { basename as basename11, dirname as dirname18, join as join32, resolve as resolve4 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync27, readdirSync as readdirSync12 } from "fs";
+import { basename as basename11, dirname as dirname18, join as join33, 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;
@@ -16165,7 +16247,7 @@ function siblingWorktreeDirs(target) {
   const registered = new Set(worktrees(target.dir).map((w) => resolve4(w.path)));
   let names;
   try {
-    names = readdirSync11(parent);
+    names = readdirSync12(parent);
   } catch {
     return [];
   }
@@ -16173,7 +16255,7 @@ function siblingWorktreeDirs(target) {
   for (const name of names) {
     if (!name.startsWith(stem)) continue;
     const m = DIR_NUMBER_SUFFIXED.exec(name);
-    const path = join32(parent, name);
+    const path = join33(parent, name);
     if (m && !registered.has(resolve4(path))) out.push({ path, number: m[1] });
   }
   return out;
@@ -16208,7 +16290,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
   let removed = 0;
   let keptBranches = 0;
   for (const a of actions) {
-    if (!dryRun && base && !a.keepBranch && existsSync29(a.path) && isHandBackMerge(a.path, base)) {
+    if (!dryRun && base && !a.keepBranch && existsSync30(a.path) && isHandBackMerge(a.path, base)) {
       if (gitOk(a.path, ["merge", "--abort"]) !== null) {
         log.emit(
           `abandoned the hand-back merge of ${base} in ${a.path}: ${a.ticket.issue_id} deployed without it`,
@@ -16216,7 +16298,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         );
       }
     }
-    if (!dryRun && existsSync29(a.path)) {
+    if (!dryRun && existsSync30(a.path)) {
       let dirty = false;
       try {
         dirty = status(a.path).length > 0;
@@ -16227,7 +16309,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         continue;
       }
     }
-    if (!dryRun && a.requirePushed && a.branch && existsSync29(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
+    if (!dryRun && a.requirePushed && a.branch && existsSync30(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
       refuse(a, "unpushed commits", `${a.branch} has commits that are not on ${remote}`);
       continue;
     }
@@ -16276,7 +16358,7 @@ function isHandBackMerge(path, base) {
   if (!msgPath) return false;
   let first;
   try {
-    first = readFileSync26(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
+    first = readFileSync27(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
   } catch {
     return false;
   }
@@ -16381,14 +16463,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync30, readdirSync as readdirSync12, rmSync as rmSync13, statSync as statSync8 } from "fs";
-import { join as join33 } from "path";
+import { existsSync as existsSync31, readdirSync as readdirSync13, rmSync as rmSync14, statSync as statSync8 } from "fs";
+import { join as join34 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join33(stateDir, "streams");
-  if (!existsSync30(dir)) return [];
+  const dir = join34(stateDir, "streams");
+  if (!existsSync31(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync12(dir).map((name) => join33(dir, name)).filter((path) => {
+  return readdirSync13(dir).map((name) => join34(dir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -16404,7 +16486,7 @@ function applyStreamSweep(paths, dryRun, log) {
       continue;
     }
     try {
-      rmSync13(path, { force: true });
+      rmSync14(path, { force: true });
       removed++;
       log.emit(`removed stream artifact ${path}`, { step: "worktree" });
     } catch (e) {
@@ -16414,9 +16496,9 @@ function applyStreamSweep(paths, dryRun, log) {
   return removed;
 }
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
-  if (!existsSync30(stateDir)) return [];
+  if (!existsSync31(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync12(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join33(stateDir, name)).filter((path) => {
+  return readdirSync13(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join34(stateDir, name)).filter((path) => {
     try {
       return statSync8(path).mtimeMs < cutoff;
     } catch {
@@ -16426,7 +16508,7 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync31, existsSync as existsSync35, mkdirSync as mkdirSync22, writeFileSync as writeFileSync23, rmSync as rmSync15, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync16 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync32, existsSync as existsSync36, mkdirSync as mkdirSync23, writeFileSync as writeFileSync24, rmSync as rmSync16, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync10, readdirSync as readdirSync17 } from "fs";
 import { createInterface } from "readline/promises";
 
 // src/periscope-cmd.ts
@@ -16554,6 +16636,25 @@ ${tail(preview.output)}`);
     return abandon(`recording the Periscopes row failed: ${e.message}`);
   }
   d.say("recorded", "recorded the Periscopes row", { periscopeRecordId: row.id });
+  try {
+    d.recordLocal?.({
+      ticket: draft.tag,
+      ticketRecordId: draft.id,
+      periscopeRecordId: row.id,
+      repo: args.repo,
+      worktree: wt.path,
+      branch: wt.branch,
+      url,
+      host: d.host,
+      state: "live",
+      isolated: args.isolate,
+      startedAt: now.toISOString(),
+      lastActivityAt: now.toISOString(),
+      expiresAt: new Date(now.getTime() + d.caps.idleMinutes * 6e4).toISOString()
+    });
+  } catch (e) {
+    d.say("warning", `local periscope record not written: ${e.message}`);
+  }
   await d.comment(draft.id, progressComment(url, handoff?.output)).catch((e) => {
     d.say("warning", `progress comment not posted: ${e.message}`);
   });
@@ -16590,6 +16691,13 @@ function prototypeSection(files) {
     `${files.length} file${files.length === 1 ? "" : "s"} changed, ${added} insertion${added === 1 ? "" : "s"}(+), ${removed} deletion${removed === 1 ? "" : "s"}(\u2212)`
   ].join("\n");
 }
+function forgetLocal(d, ticketRecordId) {
+  try {
+    d.forgetLocal?.(ticketRecordId);
+  } catch (e) {
+    d.say("warn", `could not remove the local periscope record: ${e.message}`);
+  }
+}
 async function runPeriscopeDown(d, args) {
   const rows = await d.rowsForTicket(args.number);
   if (rows.length === 0) throw new PeriscopeError(`no periscope for ticket ${args.number} on this ship`);
@@ -16612,6 +16720,7 @@ async function runPeriscopeDown(d, args) {
     d.say("ticket", `${row.ticket} closed as obsolete`);
     await d.setRowState(row.id, "discarded");
     d.say("row", "row is discarded");
+    forgetLocal(d, row.ticketRecordId);
     return { ticket: row.ticket, mode: "discard", outcome: "done", state: "discarded" };
   }
   const dirty = d.hasChanges(row.worktree);
@@ -16642,6 +16751,7 @@ ${section}`;
   d.say("worktree", `removed ${row.worktree}; ${row.branch} stays, pushed`);
   await d.setRowState(row.id, "kept");
   d.say("row", "row is kept");
+  forgetLocal(d, row.ticketRecordId);
   return { ticket: row.ticket, mode: "keep", outcome: "done", state: "kept", sha: pushed.sha };
 }
 function periscopeListEntries(rows, now, isListening) {
@@ -16664,22 +16774,22 @@ function formatPeriscopeList(entries) {
 }
 
 // src/cli.ts
-import { dirname as dirOf, resolve as resolvePath } from "path";
+import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync31, mkdirSync as mkdirSync18, readFileSync as readFileSync27, chmodSync } from "fs";
-import { dirname as dirname19, join as join34 } from "path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync28, chmodSync } from "fs";
+import { dirname as dirname19, join as join35 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join34(stateDir, "ssh", "id_ed25519");
+  return join35(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync31(privateKeyPath)) {
-    mkdirSync18(dirname19(privateKeyPath), { recursive: true });
+  if (!existsSync32(privateKeyPath)) {
+    mkdirSync19(dirname19(privateKeyPath), { recursive: true });
     try {
       execFileSync6("ssh-keygen", [
         "-t",
@@ -16699,10 +16809,10 @@ function ensureShipSshKeypair(stateDir) {
     }
     chmodSync(privateKeyPath, 384);
   }
-  if (!existsSync31(publicKeyPath)) {
+  if (!existsSync32(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync27(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync28(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -16919,9 +17029,9 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync28, writeFileSync as writeFileSync20, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync20, readFileSync as readFileSync29, writeFileSync as writeFileSync21, unlinkSync as unlinkSync3, readdirSync as readdirSync14 } from "fs";
 import { randomInt } from "crypto";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn5(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -16988,21 +17098,21 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join35(stateDir, "passengers", `${workspaceId}.json`);
+  return join36(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
-  if (!existsSync32(path)) return void 0;
+  if (!existsSync33(path)) return void 0;
   try {
-    return JSON.parse(readFileSync28(path, "utf8"));
+    return JSON.parse(readFileSync29(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync19(join35(stateDir, "passengers"), { recursive: true });
-  writeFileSync20(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync20(join36(stateDir, "passengers"), { recursive: true });
+  writeFileSync21(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function updatePersistedTunnel(stateDir, workspaceId, patch2) {
@@ -17099,9 +17209,9 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join35(stateDir, "passengers");
-  if (!existsSync32(dir)) return [];
-  return readdirSync13(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
+  const dir = join36(stateDir, "passengers");
+  if (!existsSync33(dir)) return [];
+  return readdirSync14(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
 // src/mcp-endpoint-registry.ts
@@ -17221,8 +17331,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 existsSync33, mkdirSync as mkdirSync20, readFileSync as readFileSync29, writeFileSync as writeFileSync21, unlinkSync as unlinkSync4, readdirSync as readdirSync14 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync30, writeFileSync as writeFileSync22, unlinkSync as unlinkSync4, readdirSync as readdirSync15 } from "fs";
+import { join as join37 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -17311,21 +17421,21 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join36(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join37(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
-  if (!existsSync33(path)) return void 0;
+  if (!existsSync34(path)) return void 0;
   try {
-    return JSON.parse(readFileSync29(path, "utf8"));
+    return JSON.parse(readFileSync30(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync20(join36(stateDir, "passengers"), { recursive: true });
-  writeFileSync21(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync21(join37(stateDir, "passengers"), { recursive: true });
+  writeFileSync22(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function removePersistedSyncDaemon(stateDir, workspaceId) {
@@ -17345,10 +17455,10 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join36(stateDir, "passengers");
-  if (!existsSync33(dir)) return [];
+  const dir = join37(stateDir, "passengers");
+  if (!existsSync34(dir)) return [];
   const suffix = "-sync.json";
-  return readdirSync14(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
+  return readdirSync15(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
 function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
   const alive = deps.isPidAlive ?? isPidAlive;
@@ -17434,8 +17544,8 @@ function describeCause(err) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync34, mkdirSync as mkdirSync21, readFileSync as readFileSync30, readdirSync as readdirSync15, rmSync as rmSync14, statSync as statSync9, writeFileSync as writeFileSync22 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync31, readdirSync as readdirSync16, rmSync as rmSync15, statSync as statSync9, writeFileSync as writeFileSync23 } from "fs";
+import { join as join38 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
@@ -17505,8 +17615,8 @@ function latestMtime(path) {
   if (stat.isFile()) return stat.mtimeMs;
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
-  for (const entry of readdirSync15(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join37(path, entry.name)));
+  for (const entry of readdirSync16(path, { withFileTypes: true })) {
+    latest = Math.max(latest, latestMtime(join38(path, entry.name)));
   }
   return latest;
 }
@@ -17515,23 +17625,23 @@ function computeTreeSignature(paths) {
 }
 function makeStaleChecker(paths, opts = {}) {
   const initial = computeTreeSignature(paths);
-  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync34(opts.reloadSentinel);
+  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync35(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join37(stateDir, "reload-requested");
+  return join38(stateDir, "reload-requested");
 }
 function daemonStampFor(stateDir) {
-  return join37(stateDir, "daemon.started");
+  return join38(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
-  mkdirSync21(stateDir, { recursive: true });
-  rmSync14(reloadSentinelFor(stateDir), { force: true });
-  writeFileSync22(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
+  mkdirSync22(stateDir, { recursive: true });
+  rmSync15(reloadSentinelFor(stateDir), { force: true });
+  writeFileSync23(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
 `);
 }
 function readDaemonStarted(stateDir) {
   try {
-    const v = JSON.parse(readFileSync30(daemonStampFor(stateDir), "utf8")).startedAt;
+    const v = JSON.parse(readFileSync31(daemonStampFor(stateDir), "utf8")).startedAt;
     return typeof v === "number" ? v : null;
   } catch {
     return null;
@@ -18403,7 +18513,7 @@ if (command === "passenger-sync-daemon") {
     } else {
       const toleratesNoRoutes = command === "repos" || command === "ship" || command === "disconnect" && flag("reset") || command === "connect" && flag("sign-out");
       const configless = command === "connect" && flag("sign-out") || command === "disconnect" && flag("reset");
-      if (configless && !existsSync35(findConfigFile(CREW_HOME))) {
+      if (configless && !existsSync36(findConfigFile(CREW_HOME))) {
         cfg = loadConfig(CREW_HOME, firstRunConfigPath(), { text: "ship: {}\n", allowNoRoutes: true });
       } else {
         cfg = loadConfig(CREW_HOME, void 0, toleratesNoRoutes ? { allowNoRoutes: true } : {});
@@ -18641,8 +18751,8 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join38(homedir10(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync35(staleTimer)) {
+      const staleTimer = join39(homedir10(), ".config", "systemd", "user", `${label}.timer`);
+      if (existsSync36(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -18669,7 +18779,7 @@ if (command === "passenger-sync-daemon") {
     const tracker = new Tracker(c, cfg.ship);
     problems.push(...validateContract(tracker.contract).map((p) => `contract: ${p}`));
     for (const r of await resolvedRepos(c)) {
-      if (!existsSync35(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync36(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
       if (!satisfies(host, r.config.platform)) problems.push(`repo ${r.name}: requires ${r.config.platform}, this host is ${host}`);
       readiness.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
     }
@@ -18687,7 +18797,7 @@ if (command === "passenger-sync-daemon") {
   }
   async function doctorFix(o) {
     const routes = await Promise.all(routesInScope(cfg.routes, named).map((c) => gatherHealth({ route: c.route, enabled: c.enabled, hasRepos: reposOf(c).length > 0 }, () => routeProblems(c))));
-    const unitExists = (p) => existsSync35(p);
+    const unitExists = (p) => existsSync36(p);
     const crontab = o.host === "linux" ? spawnSync7("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
     const schedulerAbsent = o.host !== "windows" ? !schedulerInstalled(planInstall(cfg.ship, CREW_HOME, o.host, detectSystemd(), "run"), unitExists, crontab) : true;
     const plan = planFix({ routes, schedulerAbsent, host: o.host });
@@ -18704,7 +18814,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;
-          writeFileSync23(cfg.configFile, planEnable(readFileSync31(cfg.configFile, "utf8"), a.route));
+          writeFileSync24(cfg.configFile, planEnable(readFileSync32(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -19808,7 +19918,7 @@ ${cu.tail.trimEnd()}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join38(CREW_HOME, "src"), join38(CREW_HOME, "dist"), join38(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join39(CREW_HOME, "src"), join39(CREW_HOME, "dist"), join39(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -20037,10 +20147,10 @@ ${cu.tail.trimEnd()}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync35(resolvedPath) ? JSON.parse(readFileSync31(resolvedPath, "utf8")) : {};
+        const raw = existsSync36(resolvedPath) ? JSON.parse(readFileSync32(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
-        mkdirSync22(dirOf(resolvedPath), { recursive: true });
-        writeFileSync23(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        mkdirSync23(dirOf2(resolvedPath), { recursive: true });
+        writeFileSync24(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (result.outcomes.some((o) => o.action === "diverged")) process.exitCode = 1;
@@ -20063,7 +20173,7 @@ ${cu.tail.trimEnd()}
         throw e;
       }
       const oldName = cfg.ship.name;
-      writeFileSync23(cfg.configFile, setShipNameInYaml(readFileSync31(cfg.configFile, "utf8"), newName));
+      writeFileSync24(cfg.configFile, setShipNameInYaml(readFileSync32(cfg.configFile, "utf8"), newName));
       cfg.ship.name = newName;
       let renameMachineId;
       try {
@@ -20110,7 +20220,7 @@ ${cu.tail.trimEnd()}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list" && sub !== "clone" && sub !== "hooks" && sub !== "check") usage2();
-      const configText = readFileSync31(cfg.configFile, "utf8");
+      const configText = readFileSync32(cfg.configFile, "utf8");
       if (sub === "check") {
         try {
           const routeArg = value("route") ?? positional[2];
@@ -20141,16 +20251,16 @@ ${cu.tail.trimEnd()}
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
           const dir = repoDirOf(configText, dirname20(cfg.configFile), a.route, a.name);
-          if (!existsSync35(dir)) throw new ReposError(`${dir} does not exist on disk`);
-          const files = { exists: (r) => existsSync35(resolvePath(dir, r)), list: (r) => {
+          if (!existsSync36(dir)) throw new ReposError(`${dir} does not exist on disk`);
+          const files = { exists: (r) => existsSync36(resolvePath(dir, r)), list: (r) => {
             try {
-              return readdirSync16(resolvePath(dir, r));
+              return readdirSync17(resolvePath(dir, r));
             } catch {
               return [];
             }
           }, read: (r) => {
             try {
-              return readFileSync31(resolvePath(dir, r), "utf8");
+              return readFileSync32(resolvePath(dir, r), "utf8");
             } catch {
               return void 0;
             }
@@ -20192,19 +20302,19 @@ ${cu.tail.trimEnd()}
           let cleared;
           if (clear2) {
             const plan = clearRouteHooks(configText, a.route, a.name);
-            if (plan.removed.length > 0) writeFileSync23(cfg.configFile, plan.text);
+            if (plan.removed.length > 0) writeFileSync24(cfg.configFile, plan.text);
             cleared = { file: cfg.configFile, removed: plan.removed };
           }
           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, { replace: flag("replace") });
-            writeFileSync23(cfg.configFile, plan.text);
+            writeFileSync24(cfg.configFile, plan.text);
             written = { target: "route", file: cfg.configFile, hooks: plan.written, kept: plan.kept, replaced: plan.replaced };
           } 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");
-            writeFileSync23(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
+            writeFileSync24(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
             written = { target: "repo", file, hooks: Object.keys(picked.hooks), kept: [], replaced: [] };
           }
           if (flag("json")) {
@@ -20260,7 +20370,7 @@ ${cu.tail.trimEnd()}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync35(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync36(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -20289,16 +20399,16 @@ ${cu.tail.trimEnd()}
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       let resolvedRemotes;
-      if (existsSync35(resolvedFile)) {
+      if (existsSync36(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync31(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync32(resolvedFile, "utf8"));
         } catch {
         }
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text = configText;
       const base = dirname20(cfg.configFile);
-      const isCheckout = (d) => existsSync35(`${d}/.git`);
+      const isCheckout = (d) => existsSync36(`${d}/.git`);
       try {
         if (sub === "list") {
           if (flag("json")) {
@@ -20308,11 +20418,11 @@ ${cu.tail.trimEnd()}
               base,
               resolved: resolvedRemotes,
               originOf,
-              exists: (d) => existsSync35(d),
+              exists: (d) => existsSync36(d),
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
-                  return Object.keys(parseRepoConfig(readFileSync31(resolvePath(d, f), "utf8"), f).hooks).length > 0;
+                  return Object.keys(parseRepoConfig(readFileSync32(resolvePath(d, f), "utf8"), f).hooks).length > 0;
                 } catch {
                   return false;
                 }
@@ -20329,7 +20439,7 @@ ${cu.tail.trimEnd()}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync35(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync36(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
             process.stdout.write(`${r.name}	${r.dir}	${note}
 `);
           }
@@ -20341,9 +20451,9 @@ ${cu.tail.trimEnd()}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir"), isCheckout });
-          if (existsSync35(plan2.target) && (existsSync35(`${plan2.target}/.git`) || readdirSync16(plan2.target).length > 0)) {
+          if (existsSync36(plan2.target) && (existsSync36(`${plan2.target}/.git`) || readdirSync17(plan2.target).length > 0)) {
             throw new ReposError(
-              existsSync35(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
+              existsSync36(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
             );
           }
           if (dryRun) {
@@ -20361,14 +20471,14 @@ ${cu.tail.trimEnd()}
             throw new ReposError(`${e.message}${authHint}
   crew.yaml was not changed`);
           }
-          writeFileSync23(cfg.configFile, plan2.text);
+          writeFileSync24(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}`);
           break;
         }
         const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir10()));
-        const top = existsSync35(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync36(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
         if (!top) throw new ReposError(`${target} is not a git checkout`);
         const origin = originOf(top);
         const plan = planRepoAdd({
@@ -20420,15 +20530,15 @@ ${cu.tail.trimEnd()}
           const created = await rowTracker.createRepoRow(rowPayload);
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
-          if (existsSync35(resolvedFile)) {
-            const raw = JSON.parse(readFileSync31(resolvedFile, "utf8"));
+          if (existsSync36(resolvedFile)) {
+            const raw = JSON.parse(readFileSync32(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
-            writeFileSync23(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync24(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        writeFileSync23(cfg.configFile, plan.text);
+        writeFileSync24(cfg.configFile, plan.text);
         process.stdout.write(`added ${top} to ${routeName} as ${plan.mode === "dir" ? "dir" : `repos.${plan.name}`} in ${cfg.configFile}
 `);
       } catch (e) {
@@ -20795,7 +20905,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.exit(2);
         }
         if (found.shipNameAdopted && !dryRun) {
-          writeFileSync23(cfg.configFile, setShipNameInYaml(readFileSync31(cfg.configFile, "utf8"), found.shipNameAdopted));
+          writeFileSync24(cfg.configFile, setShipNameInYaml(readFileSync32(cfg.configFile, "utf8"), found.shipNameAdopted));
           cfg.ship.name = found.shipNameAdopted;
         }
         if (found.shipRow) {
@@ -20838,10 +20948,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
         let previous;
-        const hadPreviousFile = existsSync35(resolvedPath);
+        const hadPreviousFile = existsSync36(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync31(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync32(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -20970,10 +21080,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 {
-          mkdirSync22(dirname20(resolvedPath), { recursive: true });
+          mkdirSync23(dirname20(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
-          writeFileSync23(tmpPath, `${JSON.stringify(resolved, null, 2)}
+          writeFileSync24(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
           renameSync3(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
@@ -21019,8 +21129,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 {
-            mkdirSync22(dirname20(apiKeyFile), { recursive: true });
-            writeFileSync23(apiKeyFile, `${apiKeyVar}=${apiKey}
+            mkdirSync23(dirname20(apiKeyFile), { recursive: true });
+            writeFileSync24(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
 `);
@@ -21669,6 +21779,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
               if (deleteBranch) gitOk(repoD.dir, ["branch", "-D", branch]);
             },
             setRowState: (id, state2) => trD.updatePeriscope(id, { state: state2 }),
+            forgetLocal: (id) => removePeriscopeSidecar(cfg.ship.stateDir, id),
             say
           };
           if (dryRun) {
@@ -21753,10 +21864,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           },
           prepare: async (path) => {
             for (const f of repoP.config.worktrees.copy) {
-              const src = join38(repoP.dir, f);
-              if (!existsSync35(src)) continue;
-              mkdirSync22(dirOf(join38(path, f)), { recursive: true });
-              copyFileSync2(src, join38(path, f));
+              const src = join39(repoP.dir, f);
+              if (!existsSync36(src)) continue;
+              mkdirSync23(dirOf2(join39(path, f)), { recursive: true });
+              copyFileSync2(src, join39(path, f));
             }
             const setup = repoP.config.hooks.setup;
             return setup ? runScript(setup, { cwd: path, shell: shellP, onLine: (l) => {
@@ -21768,6 +21879,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             return script ? runScript(script, { cwd, env, shell: shellP, timeoutMs: name === "preview" ? 18e4 : void 0 }) : null;
           },
           createRow: (fields) => trackerP.createPeriscope(fields),
+          recordLocal: (sc) => writePeriscopeSidecar(cfg.ship.stateDir, sc),
           comment: (ticketId, body) => trackerP.postComment(ticketId, body, memberId),
           teardown: async (path, branch) => {
             const n = Number(path.match(/(\d+)\/?$/)?.[1]);
@@ -21979,7 +22091,7 @@ ${res.url}
       };
       const droppedRoutes = [];
       try {
-        const rawCfg = parseYaml2(readFileSync31(cfg.configFile, "utf8"));
+        const rawCfg = parseYaml2(readFileSync32(cfg.configFile, "utf8"));
         for (const r of rawCfg?.routes ?? []) {
           if (typeof r?.route !== "string" || cfg.routes.some((x) => x.route === r.route)) continue;
           try {
@@ -22021,8 +22133,8 @@ ${res.url}
         process.stdout.write("crew reload: no daemon unit is running \u2014 nothing to reload (the next run reads crew.yaml fresh)\n");
         break;
       }
-      mkdirSync22(cfg.ship.stateDir, { recursive: true });
-      writeFileSync23(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
+      mkdirSync23(cfg.ship.stateDir, { recursive: true });
+      writeFileSync24(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) {
@@ -22073,7 +22185,7 @@ ${res.url}
     }
     case "log": {
       try {
-        const text = readFileSync31(cfg.ship.logFile, "utf8").split("\n");
+        const text = readFileSync32(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -22096,7 +22208,7 @@ ${res.url}
       };
       if (!route.resolved) fail(`route ${route.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route, cfg.ship);
-      const configText = readFileSync31(cfg.configFile, "utf8");
+      const configText = readFileSync32(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]);
@@ -22125,7 +22237,7 @@ ${res.url}
         }
         if (configured.some((r) => r.dir === dir)) {
           try {
-            writeFileSync23(cfg.configFile, planRepoRemove(configText, cfgBase, route.route, dir).text);
+            writeFileSync24(cfg.configFile, planRepoRemove(configText, cfgBase, route.route, dir).text);
           } catch (e) {
             if (e instanceof ReposError) fail(e.message);
             throw e;
@@ -22133,29 +22245,29 @@ ${res.url}
         }
         if (row) {
           await tracker.deleteRepoRow(row.id);
-          if (existsSync35(resolvedFile)) {
-            const raw = JSON.parse(readFileSync31(resolvedFile, "utf8"));
+          if (existsSync36(resolvedFile)) {
+            const raw = JSON.parse(readFileSync32(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
-            writeFileSync23(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync24(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        if (existsSync35(join38(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync15(dir, { recursive: true, force: true });
+        if (existsSync36(join39(dir, ".git")) && basename12(dir) === SAMPLE_REPO) rmSync16(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 = !existsSync35(join38(dir, ".git"));
-      if (existsSync35(dir) && fresh && readdirSync16(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      const fresh = !existsSync36(join39(dir, ".git"));
+      if (existsSync36(dir) && fresh && readdirSync17(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) {
-        mkdirSync22(dir, { recursive: true });
-        writeFileSync23(join38(dir, "README.md"), SAMPLE_README);
-        writeFileSync23(join38(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        mkdirSync23(dir, { recursive: true });
+        writeFileSync24(join39(dir, "README.md"), SAMPLE_README);
+        writeFileSync24(join39(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync7("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -22173,17 +22285,17 @@ ${res.url}
           spec: { platform: "unix", releaseMode: "integrate", ciProvider: "none" }
         });
         repoId = (await tracker.createRepoRow(payload)).id;
-        if (existsSync35(resolvedFile)) {
-          const raw = JSON.parse(readFileSync31(resolvedFile, "utf8"));
+        if (existsSync36(resolvedFile)) {
+          const raw = JSON.parse(readFileSync32(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
-          writeFileSync23(resolvedFile, `${JSON.stringify(raw, null, 2)}
+          writeFileSync24(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
         }
       }
       if (!configured.some((r) => r.dir === dir)) {
         try {
-          writeFileSync23(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route.route, path: dir, name: SAMPLE_REPO }).text);
+          writeFileSync24(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;
@@ -22305,6 +22417,7 @@ ${res.url}
       const projects = projectModeLabels(await statusTracker.projectRowsWithModes().catch(() => []));
       const crewMinVersion = await readCrewFloor(route, cfg.ship) ?? null;
       const runs = liveRuns(cfg.ship.stateDir);
+      const periscopes = await periscopesForStatus(cfg.ship.stateDir);
       if (flag("json")) {
         const nameSync = await reconcileRouteShipName({ route, ship: cfg.ship, configFile: cfg.configFile, readOnly: true });
         const repos = await resolvedRepos(route);
@@ -22369,6 +22482,8 @@ ${res.url}
           },
           // Additive (CREW-2822): every live run on this ship. `version` stays 1.
           runs: runs.map((x) => describeRun(x, route, seatIds)),
+          // Additive (CREW-2857): every live periscope on this ship, from its local record. `version` stays 1.
+          periscopes,
           watermark: state.watermark(),
           route: {
             name: route.route,
@@ -22443,7 +22558,8 @@ ${owed.map((l) => `  ${l}
 route:      ${route.route} -> ${route.dir}
 enabled:    ${route.enabled}
 periscopes: ${periscopeSummary(cfg)}
-crew:       ${state.isPaused() ? "paused" : "active"}
+` + periscopes.map((p) => `periscope:  ${p.ticket} ${p.repo} ${p.url} ${p.state}${p.serving ? "" : " (not serving)"} expires ${p.expiresAt}
+`).join("") + `crew:       ${state.isPaused() ? "paused" : "active"}
 release:    ${state.releaseSkipReason() ? "paused" : "active"}
 watermark:  ${state.watermark()}
 `
@@ -22514,7 +22630,7 @@ watermark:  ${state.watermark()}
           }
           for (const r of repos) {
             const remote = r.config.branch.remote;
-            if (existsSync35(r.dir)) {
+            if (existsSync36(r.dir)) {
               pushAuth.push({
                 route: c.route,
                 repo: r.name,
@@ -22561,7 +22677,12 @@ watermark:  ${state.watermark()}
         }
         for (const message of roleCapWarnings(cfg.ship)) problems.push({ severity: "note", kind: "role_cap_above_ship_cap", message });
         const previewProblem2 = await previewHostProblem(cfg);
-        if (previewProblem2) problems.push({ severity: "blocker", kind: "preview_host", message: previewProblem2 });
+        if (previewProblem2) problems.push(previewHostFinding(previewProblem2));
+        if (cfg.routes.some((x) => x.route === route.route && x.enabled && x.hostPeriscopes)) {
+          const { settled } = await settleRepos(reposOf(route), (t) => t.name, (t) => resolveOneRepo(route, t));
+          const tablePresent = flag("offline") ? void 0 : (await new Tracker(route, cfg.ship).periscopesStatus().catch(() => ({ present: true }))).present;
+          problems.push(...routePeriscopeProblems({ route: route.route, hosts: true, repos: settled.map((r) => ({ name: r.name, hasPreviewHook: !!r.config.hooks.preview })), tablePresent }));
+        }
         problems.push(...attentionProblems(openShipAttention(state), problems));
         if (problems.some((p) => p.severity === "blocker")) process.exitCode = 1;
         process.stdout.write(`${JSON.stringify({ offline: flag("offline"), pushAuth, tools: toolRows, problems, passed }, null, 2)}
@@ -22579,13 +22700,14 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
 `);
       const previewProblem = await previewHostProblem(cfg);
       if (previewProblem) {
-        process.stdout.write(`                   BLOCKER ${previewProblem}
+        const blocks = previewHostFinding(previewProblem).severity === "blocker";
+        process.stdout.write(`                   ${blocks ? "BLOCKER" : "ATTENTION"} ${previewProblem}
 `);
-        process.exitCode = 1;
+        if (blocks) process.exitCode = 1;
       }
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync35(evFile) ? statSync10(evFile).size : 0;
+        const evSize = existsSync36(evFile) ? statSync10(evFile).size : 0;
         process.stdout.write(
           evSize > cfg.ship.eventsRotateBytes * 4 ? `events log:        WARN ${evFile} is ${Math.round(evSize / 1048576)} MB (> 4x eventsRotateBytes); run \`crew reap\` to rotate it
 ` : "events log:        ok\n"
@@ -22596,7 +22718,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 readFileSync31(p, "utf8");
+            return readFileSync32(p, "utf8");
           } catch {
             return null;
           }
@@ -22687,6 +22809,18 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
 `
       );
       const periscopes = await tracker.periscopesStatus();
+      if (cfg.routes.some((x) => x.route === route.route && x.enabled && x.hostPeriscopes)) {
+        const { settled } = await settleRepos(reposOf(route), (t) => t.name, (t) => resolveOneRepo(route, t));
+        for (const f of routePeriscopeProblems({
+          route: route.route,
+          hosts: true,
+          tablePresent: periscopes.present,
+          repos: settled.map((r) => ({ name: r.name, hasPreviewHook: !!r.config.hooks.preview }))
+        })) {
+          process.stdout.write(`periscopes:      ${f.severity.toUpperCase()} ${f.message}
+`);
+        }
+      }
       process.stdout.write(
         !periscopes.present ? "periscopes:      Periscopes table absent \u2014 this workspace cannot host periscopes\n" : periscopes.missing.length === 0 ? `periscopes:      Periscopes table present (${periscopes.modelId})
 ` : `periscopes:      Periscopes table present (${periscopes.modelId}) but missing ${periscopes.missing.join(", ")} \u2014 update the Issues template