@tablation/crew 0.100.0 → 0.100.1

package/dist/cli.js

@@ -7218,6 +7218,12 @@ var Tracker = class {
     if (!model) return [];
     return this.client.records.list(model, { limit: 200 });
   }
+  /** Every `Repos` row with the columns the resolved file mirrors (CREW-2885). */
+  async repoRowsForMap() {
+    const model = this.route.resolved?.reposModelId;
+    if (!model) return [];
+    return this.client.records.list(model, { limit: 200 });
+  }
   /** Delete a `Repos` row (`crew sample-ticket --remove`). */
   async deleteRepoRow(id) {
     const model = this.route.resolved?.reposModelId;
@@ -10685,7 +10691,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve6, dirname as dirname23, join as join46, basename as basename14 } from "path";
+import { resolve as resolve6, dirname as dirname24, join as join46, basename as basename14 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname3, homedir as homedir10 } from "os";
 import { spawnSync as spawnSync8 } from "child_process";
@@ -12366,6 +12372,115 @@ async function resolveOne(tracker, t, seat, approvedStatus, buildingStatus, affi
   }
 }
 
+// src/repo-refresh.ts
+import { existsSync as existsSync24, mkdirSync as mkdirSync16, readFileSync as readFileSync23, writeFileSync as writeFileSync18 } from "fs";
+import { dirname as dirname11 } from "path";
+var REFRESH_COOLDOWN_MS = 2 * 6e4;
+var UNSERVABLE_PASSES_BEFORE_ATTENTION = 3;
+var lastAsked = /* @__PURE__ */ new Map();
+function unknownRepoIds(route2, repoIds) {
+  const names = route2.resolved?.repoNames;
+  if (!route2.resolved?.reposModelId || !names) return [];
+  return [...new Set(repoIds.filter((id) => !!id && !(id in names)))];
+}
+function applyRepoRows(resolved, rows) {
+  const added = [];
+  const names = resolved.repoNames ??= {};
+  const remotes = resolved.repoRemotes ??= {};
+  const hosts = resolved.repoForgeHosts ??= {};
+  for (const r of rows) {
+    if (!(r.id in names)) added.push(r.id);
+    names[r.id] = r.name ?? "";
+    if (r.remote) remotes[r.id] = r.remote;
+    else delete remotes[r.id];
+    const h = r.forge_host?.trim().toLowerCase();
+    if (h) hosts[r.id] = h;
+    else delete hosts[r.id];
+  }
+  if (Object.keys(remotes).length === 0) delete resolved.repoRemotes;
+  if (Object.keys(hosts).length === 0) delete resolved.repoForgeHosts;
+  return added;
+}
+function persistRepoRows(stateDir, routeName, rows) {
+  const path = resolvedPathFor(stateDir, routeName);
+  if (!existsSync24(path)) return;
+  const raw = JSON.parse(readFileSync23(path, "utf8"));
+  applyRepoRows(raw, rows);
+  mkdirSync16(dirname11(path), { recursive: true });
+  writeFileSync18(path, `${JSON.stringify(raw, null, 2)}
+`);
+}
+async function refreshUnknownRepos(o) {
+  const unknown = unknownRepoIds(o.route, o.tickets.map((t) => t.repo_id));
+  if (unknown.length === 0 || !o.route.resolved) return [];
+  const now = o.now ?? Date.now();
+  const last = lastAsked.get(o.route.route);
+  if (!o.force && last !== void 0 && now - last < REFRESH_COOLDOWN_MS) return [];
+  lastAsked.set(o.route.route, now);
+  let rows;
+  try {
+    rows = await o.fetchRows();
+  } catch {
+    return [];
+  }
+  const added = applyRepoRows(o.route.resolved, rows);
+  try {
+    persistRepoRows(o.stateDir, o.route.route, rows);
+  } catch {
+  }
+  return added;
+}
+var repoUnservableKey = (route2, issueId) => `repo_unservable:${route2}:${issueId}`;
+function repoUnservableItem(route2, issueId, repoLabel, nowIso = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    kind: "repo_unservable",
+    key: repoUnservableKey(route2, issueId),
+    since: nowIso,
+    message: `${route2}: ${issueId} is skipped \u2014 this ship has no checkout for ${repoLabel}. Resumes automatically once the route lists that repository (\`crew repos add\`) or a Repos row for it exists`
+  };
+}
+function trackUnservable(streaks, unservable) {
+  const now = new Set(unservable);
+  const recovered = [];
+  for (const id of [...streaks.keys()]) {
+    if (!now.has(id)) {
+      streaks.delete(id);
+      recovered.push(id);
+    }
+  }
+  const raise = [];
+  for (const id of now) {
+    const n = (streaks.get(id) ?? 0) + 1;
+    streaks.set(id, n);
+    if (n >= UNSERVABLE_PASSES_BEFORE_ATTENTION) raise.push(id);
+  }
+  return { raise, recovered };
+}
+var streaksByRoute = /* @__PURE__ */ new Map();
+async function reportUnservable(o, unservable, repoLabelOf) {
+  const streaks = streaksByRoute.get(o.route.route) ?? /* @__PURE__ */ new Map();
+  streaksByRoute.set(o.route.route, streaks);
+  const { raise, recovered } = trackUnservable(streaks, unservable);
+  for (const id of recovered) {
+    try {
+      clearShipAttention(o.state, repoUnservableKey(o.route.route, id));
+    } catch {
+    }
+  }
+  for (const id of raise) {
+    try {
+      await raiseShipAttention(o, repoUnservableItem(o.route.route, id, repoLabelOf(id)));
+    } catch {
+    }
+  }
+}
+function repoLabelFor(route2, ticket) {
+  const id = ticket?.repo_id;
+  if (!id) return "a repository (the ticket names none)";
+  const name = route2.resolved?.repoNames?.[id];
+  return name ? `repository "${name}"` : `repository ${id} (no Repos row by that id)`;
+}
+
 // src/conflict.ts
 import { StaleWriteError as StaleWriteError7 } from "@tablation/client";
 var BOUNCE_MARKER = calloutHeader("WARNING", "Merge Conflict");
@@ -12742,13 +12857,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 dirname11, join as join27 } from "path";
-import { accessSync as accessSync3, constants as constants3, existsSync as existsSync24, mkdirSync as mkdirSync16, writeFileSync as writeFileSync18 } from "fs";
+import { delimiter, dirname as dirname12, join as join27 } from "path";
+import { accessSync as accessSync3, constants as constants3, existsSync as existsSync25, mkdirSync as mkdirSync17, writeFileSync as writeFileSync19 } 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 ?? existsSync24;
+  const exists = opts.configExists ?? existsSync25;
   return !configSearchPath(opts.crewHome).some((p) => exists(p));
 }
 function firstRunConfigPath() {
@@ -12791,9 +12906,9 @@ async function runWizard(p, env) {
     if (entered && isExec(entered)) agentBin = entered;
     else p.say(entered ? `${entered} is not an executable file.` : "A path is required.");
   }
-  const nodeDir = dirname11(env.nodePath);
+  const nodeDir = dirname12(env.nodePath);
   const pnpmPath = findOnPath2("pnpm", env.pathEnv, isExec);
-  const baseDirs = [nodeDir, pnpmPath ? dirname11(pnpmPath) : void 0];
+  const baseDirs = [nodeDir, pnpmPath ? dirname12(pnpmPath) : void 0];
   p.say(
     `
 Host Passengers lets this machine run the agent sessions that other people's
@@ -12804,7 +12919,7 @@ Tablation workspaces ask for, in a container. More: ${HOST_PASSENGERS_DOCS_URL}`
     p.say("Docker is not available here, so nothing will be hosted until it is. Your answer is recorded anyway.");
   }
   const dockerPath = hostPassengers ? findOnPath2("docker", env.pathEnv, isExec) : void 0;
-  const extraPath = deriveExtraPath([...baseDirs, dockerPath ? dirname11(dockerPath) : void 0]);
+  const extraPath = deriveExtraPath([...baseDirs, dockerPath ? dirname12(dockerPath) : void 0]);
   if (extraPath) {
     p.say(`Hooks will get ${extraPath} on their PATH (where node, pnpm${dockerPath ? " and docker" : ""} live).`);
   }
@@ -12826,9 +12941,9 @@ routes:
 ${routeBlock}`;
 }
 function writeNewConfig(path, text2) {
-  mkdirSync16(dirname11(path), { recursive: true });
+  mkdirSync17(dirname12(path), { recursive: true });
   try {
-    writeFileSync18(path, text2, { mode: 384, flag: "wx" });
+    writeFileSync19(path, text2, { mode: 384, flag: "wx" });
     return true;
   } catch (e) {
     if (e.code === "EEXIST") return false;
@@ -12862,7 +12977,7 @@ Wrote ${o.configPath}.
 // src/connect-json.ts
 import { accessSync as accessSync4, constants as constants4 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname12, join as join28 } from "path";
+import { dirname as dirname13, join as join28 } from "path";
 import { delimiter as delimiter2 } from "path";
 var CHOICE_EXIT_CODE = 3;
 function createEmitter(json2, write) {
@@ -12928,7 +13043,7 @@ function flagWizardAnswers(f, env) {
   const agentBin = f.agentBin ?? found?.bin;
   const pnpmPath = findOnPath2("pnpm", env.pathEnv, isExec);
   const dockerPath = f.hostPassengers ? findOnPath2("docker", env.pathEnv, isExec) : void 0;
-  const extraPath = f.extraPath ?? deriveExtraPath([dirname12(env.nodePath), pnpmPath ? dirname12(pnpmPath) : void 0, dockerPath ? dirname12(dockerPath) : void 0]);
+  const extraPath = f.extraPath ?? deriveExtraPath([dirname13(env.nodePath), pnpmPath ? dirname13(pnpmPath) : void 0, dockerPath ? dirname13(dockerPath) : void 0]);
   return {
     answers: {
       name: f.shipName?.trim() || env.hostname,
@@ -12943,7 +13058,7 @@ function flagWizardAnswers(f, env) {
 
 // src/provision.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync23, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync24, writeFileSync as writeFileSync20 } from "fs";
 import { hostname as hostname2 } from "os";
 import { parseDocument as parseDocument3 } from "yaml";
 
@@ -13460,7 +13575,7 @@ function realProvisionDeps(crewHome) {
   };
   const configFile = () => {
     const f = findConfigFile(crewHome);
-    return existsSync25(f) ? f : null;
+    return existsSync26(f) ? f : null;
   };
   return {
     crew: spawnCrew,
@@ -13468,13 +13583,13 @@ function realProvisionDeps(crewHome) {
     enableRoute(route2) {
       const file = configFile();
       if (!file) return false;
-      const text2 = readFileSync23(file, "utf8");
+      const text2 = readFileSync24(file, "utf8");
       const doc = parseDocument3(text2);
       const routes = doc.get("routes");
       const entry = routes?.items?.find((r) => r.get("route") === route2);
       if (!entry) throw new Error(`route ${route2} is not in ${file}`);
       if (entry.get("enabled") === true) return false;
-      writeFileSync19(file, planEnable(text2, route2));
+      writeFileSync20(file, planEnable(text2, route2));
       return true;
     },
     installState() {
@@ -13494,14 +13609,14 @@ function realProvisionDeps(crewHome) {
           continue;
         }
         for (const p of plan.unitPaths) {
-          if (!existsSync25(p) || readFileSync23(p, "utf8") !== plan.unitContent[p]) unitsStale = true;
+          if (!existsSync26(p) || readFileSync24(p, "utf8") !== plan.unitContent[p]) unitsStale = true;
         }
       }
       const label = labelFor(crewHome, "run");
       let running = false;
       let lingering = true;
       if (mechanism === "systemd") {
-        const system = ctx.root || existsSync25(systemUnitPathFor(label));
+        const system = ctx.root || existsSync26(systemUnitPathFor(label));
         const ctl = system ? ["systemctl"] : ["systemctl", "--user"];
         running = spawnSync6(ctl[0], [...ctl.slice(1), "is-active", "--quiet", `${label}.service`]).status === 0;
         if (!system) {
@@ -13528,8 +13643,8 @@ host=${host}
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync24, writeFileSync as writeFileSync20, existsSync as existsSync26, copyFileSync, mkdirSync as mkdirSync17, mkdtempSync as mkdtempSync2, rmSync as rmSync14 } from "fs";
-import { dirname as dirname14, join as join30 } from "path";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync21, existsSync as existsSync27, copyFileSync, mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync2, rmSync as rmSync14 } from "fs";
+import { dirname as dirname15, join as join30 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 
 // src/release.ts
@@ -14272,11 +14387,11 @@ async function bump(o, size) {
   }
   const files = o.repo.release.versionFiles.map((f) => join30(o.cwd, f));
   const first = files[0];
-  if (!existsSync26(first)) {
+  if (!existsSync27(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
     return null;
   }
-  const current = JSON.parse(readFileSync24(first, "utf8")).version;
+  const current = JSON.parse(readFileSync25(first, "utf8")).version;
   if (!current) {
     o.emit.error(`no version field in ${o.repo.release.versionFiles[0]}`);
     return null;
@@ -14289,13 +14404,13 @@ async function bump(o, size) {
     return version;
   }
   for (const f of files) {
-    const src = readFileSync24(f, "utf8");
+    const src = readFileSync25(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;
     }
-    writeFileSync20(f, out);
+    writeFileSync21(f, out);
   }
   return version;
 }
@@ -14308,8 +14423,8 @@ function writeChangelog(o, version, entries) {
     o.emit.emit(`would prepend ${entries.length} entr(ies) to ${file}`);
     return;
   }
-  const existing = existsSync26(path) ? readFileSync24(path, "utf8") : "# Changelog\n";
-  writeFileSync20(path, insertChangelogSection(existing, section));
+  const existing = existsSync27(path) ? readFileSync25(path, "utf8") : "# Changelog\n";
+  writeFileSync21(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
   if (!o.repo.hooks.released) return void 0;
@@ -14414,8 +14529,8 @@ function openReleaseCheckout(o) {
   }
   for (const f of o.repo.worktrees.copy) {
     const src = join30(o.cwd, f);
-    if (!existsSync26(src)) continue;
-    mkdirSync17(dirname14(join30(dir, f)), { recursive: true });
+    if (!existsSync27(src)) continue;
+    mkdirSync18(dirname15(join30(dir, f)), { recursive: true });
     copyFileSync(src, join30(dir, f));
   }
   return { dir, branch, close };
@@ -15117,11 +15232,11 @@ Passed: ${passed}.${willClose ? " Closing this alert." : ""}`,
 }
 
 // src/live-runs.ts
-import { existsSync as existsSync28, readdirSync as readdirSync11 } from "fs";
+import { existsSync as existsSync29, readdirSync as readdirSync11 } from "fs";
 import { join as join32 } from "path";
 
 // src/interrupted.ts
-import { existsSync as existsSync27, readdirSync as readdirSync10, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync28, readdirSync as readdirSync10, readFileSync as readFileSync26 } from "fs";
 import { join as join31 } from "path";
 var INTERRUPTED_MARKER = calloutHeader("NOTE", "Interrupted");
 function interruptedComment(b) {
@@ -15141,16 +15256,16 @@ var pidAlive = (pid) => {
 };
 function runFinished(streamPath) {
   const path = `${streamPath}.meta.json`;
-  if (!existsSync27(path)) return false;
+  if (!existsSync28(path)) return false;
   try {
-    return JSON.parse(readFileSync25(path, "utf8")).running !== true;
+    return JSON.parse(readFileSync26(path, "utf8")).running !== true;
   } catch {
     return true;
   }
 }
 function orphanedStreams(o) {
   const dir = join31(o.stateDir, "streams");
-  if (!existsSync27(dir)) return [];
+  if (!existsSync28(dir)) return [];
   const ownerAlive = o.isOwnerAlive ?? pidAlive;
   const out = [];
   for (const name of readdirSync10(dir)) {
@@ -15210,7 +15325,7 @@ async function reconcileRuns(o) {
 // src/live-runs.ts
 function liveRuns(stateDir, isAlive = runIsAlive) {
   const dir = join32(stateDir, "streams");
-  if (!existsSync28(dir)) return [];
+  if (!existsSync29(dir)) return [];
   const out = [];
   for (const name of readdirSync11(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
@@ -15549,7 +15664,7 @@ function missingReleaserWarning(repo, release, ships, now = Date.now()) {
 }
 
 // src/watch.ts
-import { watch as watchFile, existsSync as existsSync29, statSync as statSync9, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
+import { watch as watchFile, existsSync as existsSync30, statSync as statSync9, 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`;
@@ -15650,7 +15765,7 @@ function renderHeaders(states, now = Date.now()) {
   return states.map((s) => renderHeader(s, now)).join("");
 }
 function readFrom(file, from) {
-  if (!existsSync29(file)) return { events: [], offset: from };
+  if (!existsSync30(file)) return { events: [], offset: from };
   const size = statSync9(file).size;
   if (size < from) return readFrom(file, 0);
   if (size === from) return { events: [], offset: from };
@@ -15893,15 +16008,15 @@ function nextRoles(decision, ran) {
 }
 
 // src/ship-name.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync19, readFileSync as readFileSync27, renameSync as renameSync3, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname16 } from "path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync20, readFileSync as readFileSync28, renameSync as renameSync3, writeFileSync as writeFileSync23 } from "fs";
+import { dirname as dirname17 } from "path";
 import { parseDocument as parseDocument5 } from "yaml";
 
 // src/machine-id.ts
 import { execFileSync as execFileSync5 } from "child_process";
 import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync30, mkdirSync as mkdirSync18, readFileSync as readFileSync26, writeFileSync as writeFileSync21 } from "fs";
-import { dirname as dirname15, join as join33 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync19, readFileSync as readFileSync27, writeFileSync as writeFileSync22 } from "fs";
+import { dirname as dirname16, join as join33 } from "path";
 function machineIdPathFor(stateDir) {
   return join33(stateDir, "machine-id");
 }
@@ -15916,8 +16031,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 (existsSync30(p)) {
-        const id = readFileSync26(p, "utf8").trim();
+      if (existsSync31(p)) {
+        const id = readFileSync27(p, "utf8").trim();
         if (id) return id;
       }
     }
@@ -15928,15 +16043,15 @@ function readRawMachineId(platform2 = process.platform) {
 function ensureMachineId(stateDir, opts = {}) {
   if (opts.override?.trim()) return sha256(opts.override.trim());
   const path = machineIdPathFor(stateDir);
-  if (existsSync30(path)) {
-    const cached = readFileSync26(path, "utf8").trim();
+  if (existsSync31(path)) {
+    const cached = readFileSync27(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);
-  mkdirSync18(dirname15(path), { recursive: true });
-  writeFileSync21(path, `${hashed}
+  mkdirSync19(dirname16(path), { recursive: true });
+  writeFileSync22(path, `${hashed}
 `, { mode: 384 });
   return hashed;
 }
@@ -16007,34 +16122,34 @@ async function syncRouteName(i) {
   return { status: "ok", ...base, action, name: i.local };
 }
 function readSyncedName(resolvedFile) {
-  if (!existsSync31(resolvedFile)) return void 0;
+  if (!existsSync32(resolvedFile)) return void 0;
   try {
-    const v = JSON.parse(readFileSync27(resolvedFile, "utf8")).shipName;
+    const v = JSON.parse(readFileSync28(resolvedFile, "utf8")).shipName;
     return typeof v === "string" ? v : void 0;
   } catch {
     return void 0;
   }
 }
 function writeSyncedName(resolvedFile, name) {
-  if (!existsSync31(resolvedFile)) return;
+  if (!existsSync32(resolvedFile)) return;
   let raw;
   try {
-    raw = JSON.parse(readFileSync27(resolvedFile, "utf8"));
+    raw = JSON.parse(readFileSync28(resolvedFile, "utf8"));
   } catch {
     return;
   }
   if (raw.shipName === name) return;
   raw.shipName = name;
-  mkdirSync19(dirname16(resolvedFile), { recursive: true });
+  mkdirSync20(dirname17(resolvedFile), { recursive: true });
   const tmp = `${resolvedFile}.tmp${process.pid}`;
-  writeFileSync22(tmp, `${JSON.stringify(raw, null, 2)}
+  writeFileSync23(tmp, `${JSON.stringify(raw, null, 2)}
 `);
   renameSync3(tmp, resolvedFile);
 }
 async function reconcileShipName(i) {
   let local = i.ship.name;
   try {
-    local = shipNameOfYaml(readFileSync27(i.configFile, "utf8")) ?? local;
+    local = shipNameOfYaml(readFileSync28(i.configFile, "utf8")) ?? local;
   } catch {
   }
   const resolvedFile = resolvedPathFor(i.stateDir, i.route);
@@ -16058,8 +16173,8 @@ async function reconcileShipName(i) {
   }
   if (result.status !== "ok") return result;
   if (result.action === "adopt" || result.action === "row-wins") {
-    const text2 = readFileSync27(i.configFile, "utf8");
-    writeFileSync22(i.configFile, setShipNameInYaml(text2, result.name));
+    const text2 = readFileSync28(i.configFile, "utf8");
+    writeFileSync23(i.configFile, setShipNameInYaml(text2, result.name));
     i.ship.name = result.name;
     if (result.action === "row-wins") {
       i.emit?.warn(
@@ -16715,8 +16830,8 @@ function describeCapability(i) {
 }
 
 // src/agents-sync-run.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync20, readFileSync as readFileSync28, writeFileSync as writeFileSync23 } from "fs";
-import { dirname as dirname17 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync21, readFileSync as readFileSync29, writeFileSync as writeFileSync24 } from "fs";
+import { dirname as dirname18 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
   const force = o.force ?? false;
@@ -16749,12 +16864,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 = existsSync32(resolvedPath) ? JSON.parse(readFileSync28(resolvedPath, "utf8")) : {};
+    const raw = existsSync33(resolvedPath) ? JSON.parse(readFileSync29(resolvedPath, "utf8")) : {};
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
-    mkdirSync20(dirname17(resolvedPath), { recursive: true });
-    writeFileSync23(resolvedPath, `${JSON.stringify(raw, null, 2)}
+    mkdirSync21(dirname18(resolvedPath), { recursive: true });
+    writeFileSync24(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
     if (target.resolved) {
       target.resolved.agentPersonas = personaResult.agentPersonas;
@@ -16858,7 +16973,7 @@ async function showLogEntry(route2, entryId, opts = {}) {
 
 // src/repos-check.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import { readFileSync as readFileSync29 } from "fs";
+import { readFileSync as readFileSync30 } from "fs";
 import { basename as basename9 } from "path";
 var POSIX_SHELL = /^(?:ba|z|da|k|a|mk)?sh$|^fish$/;
 function checkHookSyntax(script, shell) {
@@ -16899,7 +17014,7 @@ function checkRepoSpec(dir, opts = {}) {
   }
   let parsed;
   try {
-    parsed = parseRepoConfig(readFileSync29(file, "utf8"), file);
+    parsed = parseRepoConfig(readFileSync30(file, "utf8"), file);
   } catch (e) {
     if (!(e instanceof RepoConfigError)) throw e;
     return { ...empty, file, error: e.message, exitCode: 1 };
@@ -17346,7 +17461,7 @@ ${run2.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename10, dirname as dirname18, join as join34 } from "path";
+import { basename as basename10, dirname as dirname19, join as join34 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -17369,7 +17484,7 @@ 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 join34(dirname18(existing[0]), SAMPLE_REPO);
+  if (existing.length > 0) return join34(dirname19(existing[0]), SAMPLE_REPO);
   return join34(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
@@ -17414,8 +17529,8 @@ function planSampleTicket(i) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync33, readFileSync as readFileSync30, readdirSync as readdirSync12 } from "fs";
-import { basename as basename11, dirname as dirname19, join as join35, resolve as resolve4 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync31, readdirSync as readdirSync12 } from "fs";
+import { basename as basename11, dirname as dirname20, join as join35, 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;
@@ -17479,7 +17594,7 @@ function worktreeTicketNumbers(target) {
   return [...nums];
 }
 function siblingWorktreeDirs(target) {
-  const parent = dirname19(target.dir.replace(/[/\\]+$/, ""));
+  const parent = dirname20(target.dir.replace(/[/\\]+$/, ""));
   const stem = `${basename11(target.dir.replace(/[/\\]+$/, ""))}-`;
   const registered = new Set(worktrees(target.dir).map((w) => resolve4(w.path)));
   let names;
@@ -17527,7 +17642,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 && existsSync33(a.path) && isHandBackMerge(a.path, base)) {
+    if (!dryRun && base && !a.keepBranch && existsSync34(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`,
@@ -17535,7 +17650,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         );
       }
     }
-    if (!dryRun && existsSync33(a.path)) {
+    if (!dryRun && existsSync34(a.path)) {
       let dirty = false;
       try {
         dirty = status(a.path).length > 0;
@@ -17546,7 +17661,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         continue;
       }
     }
-    if (!dryRun && a.requirePushed && a.branch && existsSync33(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
+    if (!dryRun && a.requirePushed && a.branch && existsSync34(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
       refuse(a, "unpushed commits", `${a.branch} has commits that are not on ${remote}`);
       continue;
     }
@@ -17595,7 +17710,7 @@ function isHandBackMerge(path, base) {
   if (!msgPath) return false;
   let first;
   try {
-    first = readFileSync30(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
+    first = readFileSync31(resolve4(path, msgPath), "utf8").split("\n")[0] ?? "";
   } catch {
     return false;
   }
@@ -17700,12 +17815,12 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync34, readdirSync as readdirSync13, rmSync as rmSync15, statSync as statSync10 } from "fs";
+import { existsSync as existsSync35, readdirSync as readdirSync13, rmSync as rmSync15, statSync as statSync10 } from "fs";
 import { join as join36 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
   const dir = join36(stateDir, "streams");
-  if (!existsSync34(dir)) return [];
+  if (!existsSync35(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
   return readdirSync13(dir).map((name) => join36(dir, name)).filter((path) => {
     try {
@@ -17733,7 +17848,7 @@ function applyStreamSweep(paths, dryRun, log) {
   return removed;
 }
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
-  if (!existsSync34(stateDir)) return [];
+  if (!existsSync35(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
   return readdirSync13(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join36(stateDir, name)).filter((path) => {
     try {
@@ -17745,11 +17860,11 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync37, existsSync as existsSync42, mkdirSync as mkdirSync27, writeFileSync as writeFileSync29, rmSync as rmSync20, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync4, statSync as statSync14, readdirSync as readdirSync19 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync38, existsSync as existsSync43, mkdirSync as mkdirSync28, writeFileSync as writeFileSync30, rmSync as rmSync20, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync4, statSync as statSync14, readdirSync as readdirSync19 } from "fs";
 import { createInterface } from "readline/promises";
 
 // src/periscope-cmd.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync21, readFileSync as readFileSync31, rmSync as rmSync16, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync36, mkdirSync as mkdirSync22, readFileSync as readFileSync32, rmSync as rmSync16, writeFileSync as writeFileSync25 } from "fs";
 import { join as join37 } from "path";
 var PeriscopeError = class extends Error {
 };
@@ -17767,15 +17882,15 @@ function removePeriscopePrior(stateDir, ticketRecordId) {
 }
 function writePeriscopePrior(stateDir, ticketRecordId, prior) {
   try {
-    mkdirSync21(priorDir(stateDir), { recursive: true });
-    writeFileSync24(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
+    mkdirSync22(priorDir(stateDir), { recursive: true });
+    writeFileSync25(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
   } catch {
   }
 }
 function readPeriscopePrior(stateDir, ticketRecordId) {
   try {
     const p = priorPath(stateDir, ticketRecordId);
-    return existsSync35(p) ? JSON.parse(readFileSync31(p, "utf8")) : void 0;
+    return existsSync36(p) ? JSON.parse(readFileSync32(p, "utf8")) : void 0;
   } catch {
     return void 0;
   }
@@ -18270,8 +18385,8 @@ import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync8 } from "child_process";
-import { existsSync as existsSync36, mkdirSync as mkdirSync22, readFileSync as readFileSync32, chmodSync as chmodSync3 } from "fs";
-import { dirname as dirname20, join as join39 } from "path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync23, readFileSync as readFileSync33, chmodSync as chmodSync3 } from "fs";
+import { dirname as dirname21, join as join39 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
@@ -18280,8 +18395,8 @@ function shipSshKeyPathFor(stateDir) {
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync36(privateKeyPath)) {
-    mkdirSync22(dirname20(privateKeyPath), { recursive: true });
+  if (!existsSync37(privateKeyPath)) {
+    mkdirSync23(dirname21(privateKeyPath), { recursive: true });
     try {
       execFileSync8("ssh-keygen", [
         "-t",
@@ -18301,10 +18416,10 @@ function ensureShipSshKeypair(stateDir) {
     }
     chmodSync3(privateKeyPath, 384);
   }
-  if (!existsSync36(publicKeyPath)) {
+  if (!existsSync37(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync32(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync33(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -18542,7 +18657,7 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync37, mkdirSync as mkdirSync23, readFileSync as readFileSync33, writeFileSync as writeFileSync25, unlinkSync as unlinkSync3, readdirSync as readdirSync14 } from "fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync24, readFileSync as readFileSync34, writeFileSync as writeFileSync26, unlinkSync as unlinkSync3, readdirSync as readdirSync14 } from "fs";
 import { randomInt } from "crypto";
 import { join as join40 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
@@ -18620,17 +18735,17 @@ function tunnelStatePath(stateDir, workspaceId) {
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
-  if (!existsSync37(path)) return void 0;
+  if (!existsSync38(path)) return void 0;
   try {
-    return JSON.parse(readFileSync33(path, "utf8"));
+    return JSON.parse(readFileSync34(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync23(join40(stateDir, "passengers"), { recursive: true });
-  writeFileSync25(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync24(join40(stateDir, "passengers"), { recursive: true });
+  writeFileSync26(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function updatePersistedTunnel(stateDir, workspaceId, patch2) {
@@ -18733,7 +18848,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
 }
 function readAllPersistedWorkspaceIds(stateDir) {
   const dir = join40(stateDir, "passengers");
-  if (!existsSync37(dir)) return [];
+  if (!existsSync38(dir)) return [];
   return readdirSync14(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
@@ -18854,7 +18969,7 @@ 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 existsSync38, mkdirSync as mkdirSync24, readFileSync as readFileSync34, writeFileSync as writeFileSync26, unlinkSync as unlinkSync4, readdirSync as readdirSync15 } from "fs";
+import { existsSync as existsSync39, mkdirSync as mkdirSync25, readFileSync as readFileSync35, writeFileSync as writeFileSync27, unlinkSync as unlinkSync4, readdirSync as readdirSync15 } from "fs";
 import { join as join41 } from "path";
 
 // src/secret-compare.ts
@@ -18948,17 +19063,17 @@ function syncDaemonStatePath(stateDir, workspaceId) {
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
-  if (!existsSync38(path)) return void 0;
+  if (!existsSync39(path)) return void 0;
   try {
-    return JSON.parse(readFileSync34(path, "utf8"));
+    return JSON.parse(readFileSync35(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync24(join41(stateDir, "passengers"), { recursive: true });
-  writeFileSync26(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync25(join41(stateDir, "passengers"), { recursive: true });
+  writeFileSync27(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function removePersistedSyncDaemon(stateDir, workspaceId) {
@@ -18979,7 +19094,7 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
   const dir = join41(stateDir, "passengers");
-  if (!existsSync38(dir)) return [];
+  if (!existsSync39(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync15(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
@@ -19067,7 +19182,7 @@ function describeCause(err3) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync25, readFileSync as readFileSync35, readdirSync as readdirSync16, rmSync as rmSync17, statSync as statSync12, writeFileSync as writeFileSync27 } from "fs";
+import { existsSync as existsSync40, mkdirSync as mkdirSync26, readFileSync as readFileSync36, readdirSync as readdirSync16, rmSync as rmSync17, statSync as statSync12, writeFileSync as writeFileSync28 } from "fs";
 import { join as join42 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 var DEFAULT_FLOOR_MS = 5e3;
@@ -19149,7 +19264,7 @@ function computeTreeSignature(paths) {
 }
 function makeStaleChecker(paths, opts = {}) {
   const initial = computeTreeSignature(paths);
-  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync39(opts.reloadSentinel);
+  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync40(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
   return join42(stateDir, "reload-requested");
@@ -19158,14 +19273,14 @@ function daemonStampFor(stateDir) {
   return join42(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
-  mkdirSync25(stateDir, { recursive: true });
+  mkdirSync26(stateDir, { recursive: true });
   rmSync17(reloadSentinelFor(stateDir), { force: true });
-  writeFileSync27(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
+  writeFileSync28(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
 `);
 }
 function readDaemonStarted(stateDir) {
   try {
-    const v = JSON.parse(readFileSync35(daemonStampFor(stateDir), "utf8")).startedAt;
+    const v = JSON.parse(readFileSync36(daemonStampFor(stateDir), "utf8")).startedAt;
     return typeof v === "number" ? v : null;
   } catch {
     return null;
@@ -19545,6 +19660,7 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
     if (seat) {
       const candidates2 = rankedCandidates(role, decision.selectionInput);
       const contract = decision.selectionInput.contract ?? DEFAULT_CONTRACT;
+      await refreshUnknownRepos({ route: route2, stateDir: ship.stateDir, fetchRows: () => tracker.repoRowsForMap(), tickets: candidates2 });
       const result = await resolveTopCandidate(
         tracker,
         candidates2,
@@ -19571,6 +19687,11 @@ async function runRoleAgentLocked(role, decision, ctx, hooks, held) {
           role
         });
       }
+      await reportUnservable(
+        { state: ctx.state, emit, route: route2, ship },
+        result.unservable,
+        (id) => repoLabelFor(route2, candidates2.find((c) => c.issue_id === id))
+      );
       if (result.held.length) {
         emit.emit(`skipped ${result.held.join(", ")} \u2014 held by another live ship`, { step: "select", role });
       }
@@ -19714,7 +19835,7 @@ import { createHash as createHash9 } from "crypto";
 import {
   chmodSync as chmodSync4,
   closeSync as closeSync5,
-  existsSync as existsSync40,
+  existsSync as existsSync41,
   fstatSync,
   openSync as openSync5,
   readSync as readSync3,
@@ -19725,7 +19846,7 @@ import {
 } from "fs";
 import { createConnection } from "net";
 import { createServer } from "http";
-import { basename as basename12, dirname as dirname21, join as join43 } from "path";
+import { basename as basename12, dirname as dirname22, join as join43 } from "path";
 import { execFile, spawn as spawn8 } from "child_process";
 
 // src/periscope-control.ts
@@ -20029,7 +20150,7 @@ function candidates(live, rotated) {
   const out = [live];
   if (!rotated) return out;
   try {
-    for (const n of readdirSync17(dirname21(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join43(dirname21(live), n));
+    for (const n of readdirSync17(dirname22(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join43(dirname22(live), n));
   } catch {
   }
   return out;
@@ -20073,7 +20194,7 @@ function lastLines2(path, n) {
 }
 function readTail(live, opts) {
   const max = opts.maxBytes ?? MAX_TAIL_BYTES;
-  if (!existsSync40(live)) {
+  if (!existsSync41(live)) {
     return { lines: [], cursor: opts.after ?? encodeCursor({ dev: 0, ino: 0, off: 0 }), reset: false };
   }
   const cur = opts.after ? decodeCursor(opts.after) : null;
@@ -20189,7 +20310,7 @@ async function tailReply(path, q, rotated, abort) {
   const deadline = Date.now() + Math.min(wait, MAX_WAIT_SECONDS) * 1e3;
   let r = readTail(path, { after, tail: tail3, rotated });
   while (after && !r.lines.length && !r.reset && Date.now() < deadline && !abort.aborted) {
-    await waitForChange(dirname21(path), deadline - Date.now(), abort);
+    await waitForChange(dirname22(path), deadline - Date.now(), abort);
     r = readTail(path, { after: r.cursor, rotated });
   }
   return reply2(200, r);
@@ -20230,7 +20351,7 @@ async function route(deps, method, url, req, abort) {
     const run2 = decodeURIComponent(p.slice("/streams/".length));
     if (!RUN_NAME_RE.test(run2) || run2.includes("..") || /\.(pid|meta\.json|events\.jsonl)$/.test(run2)) return err2(400, "not a run name");
     const file = join43(deps.stateDir, "streams", run2.endsWith(".jsonl") ? run2 : `${run2}.jsonl`);
-    if (!existsSync40(file)) return err2(404, "no such run");
+    if (!existsSync41(file)) return err2(404, "no such run");
     return tailReply(file, url.searchParams, false, abort);
   }
   if ((p === "/pause" || p === "/resume") && post3) {
@@ -20274,7 +20395,7 @@ function send(res, r) {
   res.end(body);
 }
 async function socketIsStale(path) {
-  if (!existsSync40(path)) return false;
+  if (!existsSync41(path)) return false;
   return new Promise((resolve7) => {
     const c = createConnection(path);
     c.once("connect", () => {
@@ -20293,7 +20414,7 @@ async function startControlServer(deps) {
     return null;
   }
   if (await socketIsStale(path)) rmSync18(path, { force: true });
-  else if (existsSync40(path)) {
+  else if (existsSync41(path)) {
     log(`control API not started: ${path} is in use by another process`);
     return null;
   }
@@ -20376,31 +20497,31 @@ function crewJson(args, timeoutMs = 6e4) {
 
 // src/periscope-mcp.ts
 import { lstat, mkdir, readdir, readFile, readlink, realpath, rm, stat, writeFile } from "fs/promises";
-import { basename as basename13, dirname as dirname22, isAbsolute as isAbsolute3, join as join45, relative as relative2, resolve as resolve5, sep } from "path";
+import { basename as basename13, dirname as dirname23, isAbsolute as isAbsolute3, join as join45, relative as relative2, resolve as resolve5, sep } from "path";
 import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 
 // src/periscope-endpoints.ts
 import { randomBytes as randomBytes3 } from "crypto";
-import { chmodSync as chmodSync5, existsSync as existsSync41, mkdirSync as mkdirSync26, readdirSync as readdirSync18, readFileSync as readFileSync36, rmSync as rmSync19, writeFileSync as writeFileSync28 } from "fs";
+import { chmodSync as chmodSync5, existsSync as existsSync42, mkdirSync as mkdirSync27, readdirSync as readdirSync18, readFileSync as readFileSync37, rmSync as rmSync19, writeFileSync as writeFileSync29 } from "fs";
 import { join as join44 } from "path";
 var secretDir = (stateDir) => join44(stateDir, "periscope-mcp");
 var secretFile = (stateDir, id) => join44(secretDir(stateDir), `${id}.json`);
 var endpointDir = (stateDir) => join44(stateDir, "periscope-endpoints");
 var endpointFile = (stateDir, id) => join44(endpointDir(stateDir), `${id}.json`);
 function mintPeriscopeSecret(stateDir, ticketRecordId) {
-  mkdirSync26(secretDir(stateDir), { recursive: true, mode: 448 });
+  mkdirSync27(secretDir(stateDir), { recursive: true, mode: 448 });
   const secret = randomBytes3(32).toString("base64url");
   const file = secretFile(stateDir, ticketRecordId);
-  writeFileSync28(file, `${JSON.stringify({ secret })}
+  writeFileSync29(file, `${JSON.stringify({ secret })}
 `, { mode: 384 });
   chmodSync5(file, 384);
   return secret;
 }
 function readPeriscopeSecret(stateDir, ticketRecordId) {
   try {
-    const v = JSON.parse(readFileSync36(secretFile(stateDir, ticketRecordId), "utf8"));
+    const v = JSON.parse(readFileSync37(secretFile(stateDir, ticketRecordId), "utf8"));
     return typeof v.secret === "string" && v.secret ? v.secret : void 0;
   } catch {
     return void 0;
@@ -20411,14 +20532,14 @@ function removePeriscopeSecret(stateDir, ticketRecordId) {
 }
 function readPeriscopeEndpoint(stateDir, ticketRecordId) {
   try {
-    return JSON.parse(readFileSync36(endpointFile(stateDir, ticketRecordId), "utf8"));
+    return JSON.parse(readFileSync37(endpointFile(stateDir, ticketRecordId), "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePeriscopeEndpoint(stateDir, rec) {
-  mkdirSync26(endpointDir(stateDir), { recursive: true });
-  writeFileSync28(endpointFile(stateDir, rec.ticketRecordId), `${JSON.stringify(rec, null, 2)}
+  mkdirSync27(endpointDir(stateDir), { recursive: true });
+  writeFileSync29(endpointFile(stateDir, rec.ticketRecordId), `${JSON.stringify(rec, null, 2)}
 `);
 }
 function removePeriscopeEndpointRecord(stateDir, ticketRecordId) {
@@ -20426,7 +20547,7 @@ function removePeriscopeEndpointRecord(stateDir, ticketRecordId) {
 }
 function listPeriscopeEndpoints(stateDir) {
   const dir = endpointDir(stateDir);
-  if (!existsSync41(dir)) return [];
+  if (!existsSync42(dir)) return [];
   const out = [];
   for (const name of readdirSync18(dir)) {
     if (!name.endsWith(".json")) continue;
@@ -20513,10 +20634,10 @@ async function realAncestor(p) {
     }
     if (isLink) {
       if (++hops > 40) throw new PathRefusal(`too many symbolic links resolving ${p}`);
-      cur = resolve5(dirname22(cur), await readlink(cur));
+      cur = resolve5(dirname23(cur), await readlink(cur));
       continue;
     }
-    const parent = dirname22(cur);
+    const parent = dirname23(cur);
     if (parent === cur) throw new PathRefusal(`cannot resolve ${p}`);
     tail3.push(basename13(cur));
     cur = parent;
@@ -20627,7 +20748,7 @@ function createPeriscopeMcpServer(d, sc) {
     if (Buffer.byteLength(content) > MAX_WRITE_BYTES) return text(`content exceeds ${MAX_WRITE_BYTES} bytes`, true);
     const abs = await inTree(path);
     if (abs === await realpath(root)) return text("path must name a file", true);
-    await mkdir(dirname22(abs), { recursive: true });
+    await mkdir(dirname23(abs), { recursive: true });
     await inTree(path);
     await writeFile(abs, content);
     return text(`Wrote ${Buffer.byteLength(content)} bytes to ${await rel(abs)}`);
@@ -20667,7 +20788,7 @@ function createPeriscopeMcpServer(d, sc) {
     inputSchema: { path: z.string() },
     annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
   }, async ({ path }) => {
-    const parent = await inTree(dirname22(path) === "" ? "." : dirname22(path));
+    const parent = await inTree(dirname23(path) === "" ? "." : dirname23(path));
     const abs = join45(parent, basename13(path));
     if (basename13(path) === ".git" || abs === parent) return text("path must name a file", true);
     const st = await lstat(abs).catch(() => void 0);
@@ -20789,7 +20910,7 @@ function findPeriscope(sidecars, segment) {
 }
 
 // src/cli.ts
-var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname23(process.execPath) : resolve6(dirname23(fileURLToPath(import.meta.url)), "..");
+var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname24(process.execPath) : resolve6(dirname24(fileURLToPath(import.meta.url)), "..");
 var RELEASE_LOCK_TTL_MS = 20 * 60 * 1e3;
 var CYCLE_SECONDS2 = 120;
 var STALE_CYCLES = 3;
@@ -21306,7 +21427,7 @@ if (command === "passenger-sync-daemon") {
     } else {
       const toleratesNoRoutes = command === "credential" || command === "forge" || 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 && !existsSync42(findConfigFile(CREW_HOME))) {
+      if (configless && !existsSync43(findConfigFile(CREW_HOME))) {
         cfg = loadConfig(CREW_HOME, firstRunConfigPath(), { text: "ship: {}\n", allowNoRoutes: true });
       } else {
         cfg = loadConfig(CREW_HOME, void 0, toleratesNoRoutes ? { allowNoRoutes: true } : {});
@@ -21321,7 +21442,7 @@ if (command === "passenger-sync-daemon") {
     throw e;
   }
   if (command === "credential") {
-    const r = runCredential(positional[1], readFileSync37(0, "utf8"), cfg.ship.forges, cfg.ship.stateDir);
+    const r = runCredential(positional[1], readFileSync38(0, "utf8"), cfg.ship.forges, cfg.ship.stateDir);
     process.stdout.write(r.out);
     process.stderr.write(r.err);
     process.exit(r.code);
@@ -21333,9 +21454,9 @@ if (command === "passenger-sync-daemon") {
         forges: cfg.ship.forges,
         stateDir: cfg.ship.stateDir,
         configFile: cfg.configFile,
-        readFile: (p) => readFileSync37(p, "utf8"),
-        writeFile: (p, t) => writeFileSync29(p, t),
-        stdin: () => readFileSync37(0, "utf8"),
+        readFile: (p) => readFileSync38(p, "utf8"),
+        writeFile: (p, t) => writeFileSync30(p, t),
+        stdin: () => readFileSync38(0, "utf8"),
         env: process.env
       }
     );
@@ -21619,7 +21740,7 @@ if (command === "passenger-sync-daemon") {
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
       const staleTimer = join46(homedir10(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync42(staleTimer)) {
+      if (existsSync43(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -21646,7 +21767,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 (!existsSync42(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync43(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}`));
     }
@@ -21664,7 +21785,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) => existsSync42(p);
+    const unitExists = (p) => existsSync43(p);
     const crontab = o.host === "linux" ? spawnSync8("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
     const schedulerAbsent = o.host !== "windows" ? !schedulerInstalled(planInstall(cfg.ship, CREW_HOME, o.host, detectSystemd(), "run", installContext()), unitExists, crontab) : true;
     const plan = planFix({ routes, schedulerAbsent, host: o.host });
@@ -21681,7 +21802,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;
-          writeFileSync29(cfg.configFile, planEnable(readFileSync37(cfg.configFile, "utf8"), a.route));
+          writeFileSync30(cfg.configFile, planEnable(readFileSync38(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -22360,6 +22481,7 @@ ${cu.tail.trimEnd()}
           if (seat) {
             const candidates2 = rankedCandidates(w.role, w.decision.selectionInput);
             const contract = w.decision.selectionInput.contract ?? DEFAULT_CONTRACT;
+            await refreshUnknownRepos({ route: w.route, stateDir: cfg.ship.stateDir, fetchRows: () => fleetTracker.repoRowsForMap(), tickets: candidates2 });
             const result = await resolveTopCandidate(
               fleetTracker,
               candidates2,
@@ -22571,6 +22693,7 @@ ${cu.tail.trimEnd()}
           if (seat) {
             const candidates2 = rankedCandidates(current, decision.selectionInput);
             const contract = decision.selectionInput.contract ?? DEFAULT_CONTRACT;
+            await refreshUnknownRepos({ route: route2, stateDir: cfg.ship.stateDir, fetchRows: () => tracker2.repoRowsForMap(), tickets: candidates2 });
             const result = await resolveTopCandidate(
               tracker2,
               candidates2,
@@ -23077,10 +23200,10 @@ ${cu.tail.trimEnd()}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync42(resolvedPath) ? JSON.parse(readFileSync37(resolvedPath, "utf8")) : {};
+        const raw = existsSync43(resolvedPath) ? JSON.parse(readFileSync38(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
-        mkdirSync27(dirOf2(resolvedPath), { recursive: true });
-        writeFileSync29(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        mkdirSync28(dirOf2(resolvedPath), { recursive: true });
+        writeFileSync30(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (result.outcomes.some((o) => o.action === "diverged")) process.exitCode = 1;
@@ -23103,7 +23226,7 @@ ${cu.tail.trimEnd()}
         throw e;
       }
       const oldName = cfg.ship.name;
-      writeFileSync29(cfg.configFile, setShipNameInYaml(readFileSync37(cfg.configFile, "utf8"), newName));
+      writeFileSync30(cfg.configFile, setShipNameInYaml(readFileSync38(cfg.configFile, "utf8"), newName));
       cfg.ship.name = newName;
       let renameMachineId;
       try {
@@ -23150,14 +23273,14 @@ ${cu.tail.trimEnd()}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list" && sub !== "clone" && sub !== "hooks" && sub !== "check") usage2();
-      const configText = readFileSync37(cfg.configFile, "utf8");
+      const configText = readFileSync38(cfg.configFile, "utf8");
       if (sub === "check") {
         try {
           const routeArg = value("route") ?? positional[2];
           const found = cfg.routes.find((r) => r.route === routeArg);
           if (!found) throw new ReposError(`no route "${routeArg}" in the config (have: ${cfg.routes.map((r) => r.route).join(", ") || "none"})`);
           const named2 = value("route") ? void 0 : positional[3];
-          const dir = named2 ? repoDirOf(configText, dirname23(cfg.configFile), found.route, named2) : resolvePath(positional[value("route") ? 2 : 3] ?? ".");
+          const dir = named2 ? repoDirOf(configText, dirname24(cfg.configFile), found.route, named2) : resolvePath(positional[value("route") ? 2 : 3] ?? ".");
           const target = reposOf(found).find((t) => resolvePath(t.dir) === dir || t.name === named2);
           const o = target ? found.repoOverrides[target.name] : void 0;
           runReposCheck(dir, {
@@ -23180,9 +23303,9 @@ ${cu.tail.trimEnd()}
       if (sub === "hooks") {
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
-          const dir = repoDirOf(configText, dirname23(cfg.configFile), a.route, a.name);
-          if (!existsSync42(dir)) throw new ReposError(`${dir} does not exist on disk`);
-          const files = { exists: (r) => existsSync42(resolvePath(dir, r)), list: (r) => {
+          const dir = repoDirOf(configText, dirname24(cfg.configFile), a.route, a.name);
+          if (!existsSync43(dir)) throw new ReposError(`${dir} does not exist on disk`);
+          const files = { exists: (r) => existsSync43(resolvePath(dir, r)), list: (r) => {
             try {
               return readdirSync19(resolvePath(dir, r));
             } catch {
@@ -23190,7 +23313,7 @@ ${cu.tail.trimEnd()}
             }
           }, read: (r) => {
             try {
-              return readFileSync37(resolvePath(dir, r), "utf8");
+              return readFileSync38(resolvePath(dir, r), "utf8");
             } catch {
               return void 0;
             }
@@ -23232,19 +23355,19 @@ ${cu.tail.trimEnd()}
           let cleared;
           if (clear2) {
             const plan = clearRouteHooks(configText, a.route, a.name);
-            if (plan.removed.length > 0) writeFileSync29(cfg.configFile, plan.text);
+            if (plan.removed.length > 0) writeFileSync30(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") });
-            writeFileSync29(cfg.configFile, plan.text);
+            writeFileSync30(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");
-            writeFileSync29(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
+            writeFileSync30(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
             written = { target: "repo", file, hooks: Object.keys(picked.hooks), kept: [], replaced: [] };
           }
           if (flag("json")) {
@@ -23300,7 +23423,7 @@ ${cu.tail.trimEnd()}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync42(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync43(resolvePath(p.replace(/^~(?=\/|$)/, homedir10()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -23328,17 +23451,27 @@ ${cu.tail.trimEnd()}
         }
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
+      if (sub === "list" || sub === "add") {
+        const liveRoute = cfg.routes.find((r) => r.route === routeName);
+        if (liveRoute?.resolved?.reposModelId && existsSync43(resolvedFile) && !dryRun) {
+          try {
+            await hydrateApiKeys([liveRoute]);
+            persistRepoRows(cfg.ship.stateDir, liveRoute.route, await new Tracker(liveRoute, cfg.ship).repoRowsForMap());
+          } catch {
+          }
+        }
+      }
       let resolvedRemotes;
-      if (existsSync42(resolvedFile)) {
+      if (existsSync43(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync37(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync38(resolvedFile, "utf8"));
         } catch {
         }
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text2 = configText;
-      const base = dirname23(cfg.configFile);
-      const isCheckout = (d) => existsSync42(`${d}/.git`);
+      const base = dirname24(cfg.configFile);
+      const isCheckout = (d) => existsSync43(`${d}/.git`);
       try {
         if (sub === "list") {
           if (flag("json")) {
@@ -23348,11 +23481,11 @@ ${cu.tail.trimEnd()}
               base,
               resolved: resolvedRemotes,
               originOf,
-              exists: (d) => existsSync42(d),
+              exists: (d) => existsSync43(d),
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
-                  return Object.keys(parseRepoConfig(readFileSync37(resolvePath(d, f), "utf8"), f).hooks).length > 0;
+                  return Object.keys(parseRepoConfig(readFileSync38(resolvePath(d, f), "utf8"), f).hooks).length > 0;
                 } catch {
                   return false;
                 }
@@ -23369,7 +23502,7 @@ ${cu.tail.trimEnd()}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync42(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync43(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}
 `);
           }
@@ -23381,9 +23514,9 @@ ${cu.tail.trimEnd()}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text: text2, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir"), isCheckout });
-          if (existsSync42(plan2.target) && (existsSync42(`${plan2.target}/.git`) || readdirSync19(plan2.target).length > 0)) {
+          if (existsSync43(plan2.target) && (existsSync43(`${plan2.target}/.git`) || readdirSync19(plan2.target).length > 0)) {
             throw new ReposError(
-              existsSync42(`${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`
+              existsSync43(`${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) {
@@ -23401,14 +23534,14 @@ ${cu.tail.trimEnd()}
             throw new ReposError(`${e.message}${authHint}
   crew.yaml was not changed`);
           }
-          writeFileSync29(cfg.configFile, plan2.text);
+          writeFileSync30(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 = existsSync42(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync43(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({
@@ -23460,15 +23593,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 (existsSync42(resolvedFile)) {
-            const raw = JSON.parse(readFileSync37(resolvedFile, "utf8"));
+          if (existsSync43(resolvedFile)) {
+            const raw = JSON.parse(readFileSync38(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
-            writeFileSync29(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync30(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        writeFileSync29(cfg.configFile, plan.text);
+        writeFileSync30(cfg.configFile, plan.text);
         process.stdout.write(`added ${top} to ${routeName} as ${plan.mode === "dir" ? "dir" : `repos.${plan.name}`} in ${cfg.configFile}
 `);
       } catch (e) {
@@ -23835,7 +23968,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.exit(2);
         }
         if (found.shipNameAdopted && !dryRun) {
-          writeFileSync29(cfg.configFile, setShipNameInYaml(readFileSync37(cfg.configFile, "utf8"), found.shipNameAdopted));
+          writeFileSync30(cfg.configFile, setShipNameInYaml(readFileSync38(cfg.configFile, "utf8"), found.shipNameAdopted));
           cfg.ship.name = found.shipNameAdopted;
         }
         if (found.shipRow) {
@@ -23878,10 +24011,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
         let previous;
-        const hadPreviousFile = existsSync42(resolvedPath);
+        const hadPreviousFile = existsSync43(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync37(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync38(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -24011,10 +24144,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 {
-          mkdirSync27(dirname23(resolvedPath), { recursive: true });
+          mkdirSync28(dirname24(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
-          writeFileSync29(tmpPath, `${JSON.stringify(resolved, null, 2)}
+          writeFileSync30(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
           renameSync4(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
@@ -24060,8 +24193,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 {
-            mkdirSync27(dirname23(apiKeyFile), { recursive: true });
-            writeFileSync29(apiKeyFile, `${apiKeyVar}=${apiKey}
+            mkdirSync28(dirname24(apiKeyFile), { recursive: true });
+            writeFileSync30(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
 `);
@@ -24797,7 +24930,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           const shellR = hit && resolveShell(hit.repo.config.shell ?? cfg.ship.shell);
           const resumed = await runPeriscopeResume({
             find: async () => hit && { row: hit.row, tag: hit.tag },
-            worktreeExists: (p) => existsSync42(p),
+            worktreeExists: (p) => existsSync43(p),
             caps: periscopeCaps(cfg.ship),
             runHook: async (name, cwd, env) => {
               const script = hit?.repo.config.hooks[name];
@@ -24892,8 +25025,8 @@ ${where.join("\n")}`);
           prepare: async (path) => {
             for (const f of repoP.config.worktrees.copy) {
               const src = join46(repoP.dir, f);
-              if (!existsSync42(src)) continue;
-              mkdirSync27(dirOf2(join46(path, f)), { recursive: true });
+              if (!existsSync43(src)) continue;
+              mkdirSync28(dirOf2(join46(path, f)), { recursive: true });
               copyFileSync2(src, join46(path, f));
             }
             const setup = repoP.config.hooks.setup;
@@ -25187,7 +25320,7 @@ ${where.join("\n")}`);
       };
       const droppedRoutes = [];
       try {
-        const rawCfg = parseYaml2(readFileSync37(cfg.configFile, "utf8"));
+        const rawCfg = parseYaml2(readFileSync38(cfg.configFile, "utf8"));
         for (const r of rawCfg?.routes ?? []) {
           if (typeof r?.route !== "string" || cfg.routes.some((x) => x.route === r.route)) continue;
           try {
@@ -25229,8 +25362,8 @@ ${where.join("\n")}`);
         process.stdout.write("crew reload: no daemon unit is running \u2014 nothing to reload (the next run reads crew.yaml fresh)\n");
         break;
       }
-      mkdirSync27(cfg.ship.stateDir, { recursive: true });
-      writeFileSync29(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
+      mkdirSync28(cfg.ship.stateDir, { recursive: true });
+      writeFileSync30(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) {
@@ -25281,7 +25414,7 @@ ${where.join("\n")}`);
     }
     case "log": {
       try {
-        const text2 = readFileSync37(cfg.ship.logFile, "utf8").split("\n");
+        const text2 = readFileSync38(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text2.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -25304,8 +25437,8 @@ ${where.join("\n")}`);
       };
       if (!route2.resolved) fail(`route ${route2.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route2, cfg.ship);
-      const configText = readFileSync37(cfg.configFile, "utf8");
-      const cfgBase = dirname23(cfg.configFile);
+      const configText = readFileSync38(cfg.configFile, "utf8");
+      const cfgBase = dirname24(cfg.configFile);
       const configured2 = configuredRepos(configText, route2.route, cfgBase);
       const dir = configured2.find((r) => r.name === SAMPLE_REPO)?.dir ?? sampleDir(configured2.map((r) => r.dir), route2.reposBasePath, route2.route.split("/")[0]);
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, route2.route);
@@ -25333,7 +25466,7 @@ ${where.join("\n")}`);
         }
         if (configured2.some((r) => r.dir === dir)) {
           try {
-            writeFileSync29(cfg.configFile, planRepoRemove(configText, cfgBase, route2.route, dir).text);
+            writeFileSync30(cfg.configFile, planRepoRemove(configText, cfgBase, route2.route, dir).text);
           } catch (e) {
             if (e instanceof ReposError) fail(e.message);
             throw e;
@@ -25341,29 +25474,29 @@ ${where.join("\n")}`);
         }
         if (row) {
           await tracker.deleteRepoRow(row.id);
-          if (existsSync42(resolvedFile)) {
-            const raw = JSON.parse(readFileSync37(resolvedFile, "utf8"));
+          if (existsSync43(resolvedFile)) {
+            const raw = JSON.parse(readFileSync38(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
-            writeFileSync29(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync30(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        if (existsSync42(join46(dir, ".git")) && basename14(dir) === SAMPLE_REPO) rmSync20(dir, { recursive: true, force: true });
+        if (existsSync43(join46(dir, ".git")) && basename14(dir) === SAMPLE_REPO) rmSync20(dir, { recursive: true, force: true });
         say("removed", { dir, closed }, `removed the sample repo${closed.length ? `, closed ${closed.join(", ")}` : ""}`);
         break;
       }
       const projectId = route2.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
-      const fresh = !existsSync42(join46(dir, ".git"));
-      if (existsSync42(dir) && fresh && readdirSync19(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      const fresh = !existsSync43(join46(dir, ".git"));
+      if (existsSync43(dir) && fresh && readdirSync19(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) {
-        mkdirSync27(dir, { recursive: true });
-        writeFileSync29(join46(dir, "README.md"), SAMPLE_README);
-        writeFileSync29(join46(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        mkdirSync28(dir, { recursive: true });
+        writeFileSync30(join46(dir, "README.md"), SAMPLE_README);
+        writeFileSync30(join46(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync8("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -25381,17 +25514,17 @@ ${where.join("\n")}`);
           spec: { platform: "unix", releaseMode: "integrate", ciProvider: "none" }
         });
         repoId = (await tracker.createRepoRow(payload)).id;
-        if (existsSync42(resolvedFile)) {
-          const raw = JSON.parse(readFileSync37(resolvedFile, "utf8"));
+        if (existsSync43(resolvedFile)) {
+          const raw = JSON.parse(readFileSync38(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
-          writeFileSync29(resolvedFile, `${JSON.stringify(raw, null, 2)}
+          writeFileSync30(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
         }
       }
       if (!configured2.some((r) => r.dir === dir)) {
         try {
-          writeFileSync29(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route2.route, path: dir, name: SAMPLE_REPO }).text);
+          writeFileSync30(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route2.route, path: dir, name: SAMPLE_REPO }).text);
         } catch (e) {
           if (e instanceof ReposError) fail(e.message);
           throw e;
@@ -25729,7 +25862,7 @@ watermark:  ${state.watermark()}
           }
           for (const r of repos) {
             const remote = r.config.branch.remote;
-            if (existsSync42(r.dir)) {
+            if (existsSync43(r.dir)) {
               pushAuth.push({
                 route: c.route,
                 repo: r.name,
@@ -25815,7 +25948,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       }
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync42(evFile) ? statSync14(evFile).size : 0;
+        const evSize = existsSync43(evFile) ? statSync14(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"
@@ -25826,7 +25959,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
         const unitPlan = planInstall(cfg.ship, CREW_HOME, host, detectSystemd(), "run", installContext());
         const abandons = unitAbandonsAgents(unitPlan, (p) => {
           try {
-            return readFileSync37(p, "utf8");
+            return readFileSync38(p, "utf8");
           } catch {
             return null;
           }