@tablation/crew 0.122.0 → 0.123.0

package/dist/cli.js

@@ -5850,6 +5850,78 @@ function cloneFailureMarker(dir) {
   return `${dir}.clone-failed`;
 }
 
+// src/repo-map.ts
+import { readFileSync as readFileSync18 } from "fs";
+import { join as join20 } from "path";
+var CHARS_PER_TOKEN = 4;
+var MAP_TIMEOUT_MS = 6e4;
+function budgetMap(text2, tokenBudget) {
+  const body = text2.replace(/\s+$/, "");
+  const limit = tokenBudget * CHARS_PER_TOKEN;
+  if (body.length <= limit) return body;
+  const lines2 = body.split("\n");
+  const noteFor = (kept2) => `\u2026 ${lines2.length - kept2} of ${lines2.length} lines cut to fit ship.mapTokenBudget (${tokenBudget} tokens)`;
+  let kept = lines2.length;
+  let size = body.length;
+  while (kept > 0 && size + 1 + noteFor(kept).length > limit) {
+    kept--;
+    size -= lines2[kept].length + 1;
+  }
+  return [...lines2.slice(0, kept), noteFor(kept)].join("\n");
+}
+function mapFilePath(value2) {
+  if (!value2) return null;
+  const v = value2.trim();
+  if (!/^[A-Za-z0-9_.+@-]+(?:\/[A-Za-z0-9_.+@-]+)*\.md$/i.test(v)) return null;
+  if (v.split("/").some((seg) => seg === ".." || seg === ".")) return null;
+  return v;
+}
+function inspectMapFile(dir, path) {
+  try {
+    const text2 = readFileSync18(join20(dir, path), "utf8").replace(/\s+$/, "");
+    return { path, exists: true, lines: text2 ? text2.split("\n").length : 0, tokens: Math.ceil(text2.length / CHARS_PER_TOKEN) };
+  } catch {
+    return { path, exists: false, lines: 0, tokens: 0 };
+  }
+}
+function loadRepoMap(repo, tokenBudget, shellFallback) {
+  const script = repo.config.hooks.map;
+  if (!script) return Promise.resolve({ skipped: "" });
+  const file = mapFilePath(script);
+  if (file) {
+    const m = inspectMapFile(repo.dir, file);
+    if (!m.exists) return Promise.resolve({ skipped: `the \`map\` file ${file} for ${repo.name} is missing or unreadable, so the brief has no repository map` });
+    let text2 = "";
+    try {
+      text2 = readFileSync18(join20(repo.dir, file), "utf8");
+    } catch {
+    }
+    if (!text2.trim()) return Promise.resolve({ skipped: `the \`map\` file ${file} for ${repo.name} is empty, so the brief has no repository map` });
+    return Promise.resolve({ text: budgetMap(text2, tokenBudget) });
+  }
+  return runScript(script, {
+    cwd: repo.dir,
+    shell: resolveShell(repo.config.shell ?? shellFallback),
+    env: { CREW_REPO: repo.name },
+    timeoutMs: MAP_TIMEOUT_MS
+  }).then(
+    (r) => {
+      if (r.code !== 0) return { skipped: `the \`map\` hook for ${repo.name} exited ${r.code}, so the brief has no repository map` };
+      if (!r.stdout.trim()) return { skipped: `the \`map\` hook for ${repo.name} printed nothing, so the brief has no repository map` };
+      return { text: budgetMap(r.stdout, tokenBudget) };
+    },
+    (e) => ({ skipped: `the \`map\` hook for ${repo.name} could not run (${e instanceof Error ? e.message : String(e)}), so the brief has no repository map` })
+  );
+}
+async function withRepoMaps(repos, tokenBudget, shellFallback) {
+  return Promise.all(repos.map(async (r) => {
+    if (!r.config.hooks.map) return r;
+    const out = await loadRepoMap(r, tokenBudget, shellFallback);
+    if ("skipped" in out) return out.skipped ? { ...r, mapSkipped: out.skipped } : r;
+    return { ...r, map: out.text };
+  }));
+}
+
 // src/ship-attention.ts
 var RELEASE_STALE_AFTER_INTERVALS = 3;
 function upsert(items, item) {
@@ -6091,6 +6163,7 @@ function clearShipAttention(state, key) {
   if (next.length !== previous.length) store.persist(next);
 }
 function hookCommand(script) {
+  if (mapFilePath(script)) return null;
   for (const raw of script.split("\n")) {
     const line = raw.trim();
     if (!line || line.startsWith("#")) continue;
@@ -6170,6 +6243,18 @@ function repoFindings(o) {
       remedy: "add the directory holding it to ship.extraPath in crew.yaml"
     });
   }
+  if (o.mapFile) {
+    if (!o.mapFile.exists) {
+      problems.push({
+        severity: "attention",
+        kind: "map_file_missing",
+        ...at,
+        hook: "map",
+        message: `${o.route}/${o.repo}: hooks.map names ${o.mapFile.path}, which is not in the checkout, so briefs carry no repository map`,
+        remedy: `commit ${o.mapFile.path}, or correct hooks.map in the repository's .crew.yaml`
+      });
+    } else passed++;
+  }
   if (o.intelSyntax) {
     if (o.intelSyntax.status === "error") {
       problems.push({
@@ -6205,8 +6290,8 @@ function attentionProblems(items, already) {
 import { createHash as createHash6 } from "crypto";
 import { spawn as spawn5 } from "child_process";
 import { execFileSync as execFileSync8 } from "child_process";
-import { mkdirSync as mkdirSync19, readFileSync as readFileSync26, renameSync as renameSync3, writeFileSync as writeFileSync20, rmSync as rmSync15 } from "fs";
-import { dirname as dirname14, join as join31 } from "path";
+import { mkdirSync as mkdirSync19, readFileSync as readFileSync27, renameSync as renameSync3, writeFileSync as writeFileSync20, rmSync as rmSync15 } from "fs";
+import { dirname as dirname14, join as join32 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 
 // src/passenger-containers.ts
@@ -6222,20 +6307,20 @@ import { spawnSync as spawnSync7 } from "child_process";
 import { existsSync as existsSync29, readdirSync as readdirSync11 } from "fs";
 
 // src/interrupted.ts
-import { existsSync as existsSync27, readdirSync as readdirSync9, readFileSync as readFileSync25 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync27, readdirSync as readdirSync9, readFileSync as readFileSync26 } from "fs";
+import { join as join30 } from "path";
 
 // src/agent.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { readFileSync as readFileSync24, existsSync as existsSync26, statSync as statSync8, mkdirSync as mkdirSync18, writeFileSync as writeFileSync19, createWriteStream, openSync as openSync4, closeSync as closeSync4, readSync } from "fs";
+import { readFileSync as readFileSync25, existsSync as existsSync26, statSync as statSync8, mkdirSync as mkdirSync18, writeFileSync as writeFileSync19, createWriteStream, openSync as openSync4, closeSync as closeSync4, readSync } from "fs";
 import { StringDecoder } from "string_decoder";
 import { finished } from "stream/promises";
-import { join as join28, dirname as dirname13, basename as basename9 } from "path";
+import { join as join29, dirname as dirname13, basename as basename9 } from "path";
 import { createHash as createHash4 } from "crypto";
 
 // src/state.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync14, existsSync as existsSync19, mkdirSync as mkdirSync13, rmSync as rmSync10, statSync as statSync7, readdirSync as readdirSync5 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync14, existsSync as existsSync19, mkdirSync as mkdirSync13, rmSync as rmSync10, statSync as statSync7, readdirSync as readdirSync5 } from "fs";
+import { join as join21 } from "path";
 var EPOCH = "1970-01-01T00:00:00.000Z";
 var State = class _State {
   dir;
@@ -6244,7 +6329,7 @@ var State = class _State {
     mkdirSync13(dir, { recursive: true });
   }
   path(...parts) {
-    return join20(this.dir, ...parts);
+    return join21(this.dir, ...parts);
   }
   /**
    * The timestamp every "new since last poll" check is measured against.
@@ -6255,7 +6340,7 @@ var State = class _State {
    */
   watermark() {
     try {
-      const v = readFileSync18(this.path(".poll-watermark"), "utf8").trim();
+      const v = readFileSync19(this.path(".poll-watermark"), "utf8").trim();
       return v || EPOCH;
     } catch {
       return EPOCH;
@@ -6341,7 +6426,7 @@ var State = class _State {
     const name = _State.safe(rawName);
     const file = this.path(`.${name}.lock`);
     try {
-      const existing = Number.parseInt(readFileSync18(file, "utf8").trim(), 10);
+      const existing = Number.parseInt(readFileSync19(file, "utf8").trim(), 10);
       if (Number.isFinite(existing) && existing > 0) {
         try {
           process.kill(existing, 0);
@@ -6379,7 +6464,7 @@ var State = class _State {
       if (!/^\.release-.+\.lock$/.test(n)) continue;
       let pid = 0;
       try {
-        pid = Number.parseInt(readFileSync18(this.path(n), "utf8").trim(), 10);
+        pid = Number.parseInt(readFileSync19(this.path(n), "utf8").trim(), 10);
       } catch {
         continue;
       }
@@ -6465,7 +6550,7 @@ var State = class _State {
   ticketInFlight(recordId) {
     const file = this.path(`.${_State.safe(`crew-ticket-${recordId}`)}.lock`);
     try {
-      const pid = Number.parseInt(readFileSync18(file, "utf8").trim(), 10);
+      const pid = Number.parseInt(readFileSync19(file, "utf8").trim(), 10);
       if (!Number.isFinite(pid) || pid <= 0) return false;
       process.kill(pid, 0);
       return true;
@@ -6499,7 +6584,7 @@ var State = class _State {
     const heldReported = `.release-held-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync18(this.path(f), "utf8").trim() || null;
+        return readFileSync19(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -6549,7 +6634,7 @@ var State = class _State {
       /** Whether the board was already told about this head's red gate. */
       heldReported: () => {
         try {
-          return readFileSync18(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
+          return readFileSync19(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
         } catch {
           return null;
         }
@@ -6586,7 +6671,7 @@ var State = class _State {
     const ticketStreakFile = `.fairness-ticket-streak-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync18(this.path(f), "utf8").trim() || null;
+        return readFileSync19(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -6651,7 +6736,7 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync18(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync19(this.path(file), "utf8"));
           return parsed && typeof parsed === "object" ? parsed : {};
         } catch {
           return {};
@@ -6674,7 +6759,7 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync18(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync19(this.path(file), "utf8"));
           return Array.isArray(parsed) ? parsed.filter((x) => typeof x === "string") : [];
         } catch {
           return [];
@@ -6695,7 +6780,7 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync18(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync19(this.path(file), "utf8"));
           return Array.isArray(parsed) ? parsed : [];
         } catch {
           return [];
@@ -6728,7 +6813,7 @@ var State = class _State {
   }
   readInt(file) {
     try {
-      return Number.parseInt(readFileSync18(this.path(file), "utf8").trim(), 10) || 0;
+      return Number.parseInt(readFileSync19(this.path(file), "utf8").trim(), 10) || 0;
     } catch {
       return 0;
     }
@@ -7117,8 +7202,8 @@ function renderEnvironment(i) {
 }
 
 // src/intel-bridge.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync14, readFileSync as readFileSync19, rmSync as rmSync11, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname10, join as join21 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync14, readFileSync as readFileSync20, rmSync as rmSync11, writeFileSync as writeFileSync15 } from "fs";
+import { dirname as dirname10, join as join22 } from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -7132,9 +7217,9 @@ var STATUS_WAITING = "The symbol service is not available yet: the worktree has
 var STATUS_LOST = "The symbol service stopped answering, so its tools are unavailable. They return if the service comes back; until then use text search.";
 function intelDir(stateDir, route2, ticket) {
   const safe = (s) => s.replace(/[^A-Za-z0-9._-]+/g, "_");
-  return join21(stateDir, "intel", safe(route2), safe(ticket));
+  return join22(stateDir, "intel", safe(route2), safe(ticket));
 }
-var attachFilePath = (stateDir, route2, ticket) => join21(intelDir(stateDir, route2, ticket), "url");
+var attachFilePath = (stateDir, route2, ticket) => join22(intelDir(stateDir, route2, ticket), "url");
 function writeAttachFile(file, url) {
   mkdirSync14(dirname10(file), { recursive: true });
   writeFileSync15(file, `${url}
@@ -7142,7 +7227,7 @@ function writeAttachFile(file, url) {
 }
 function readAttachFile(file) {
   try {
-    const url = readFileSync19(file, "utf8").trim();
+    const url = readFileSync20(file, "utf8").trim();
     return /^https?:\/\/\S+$/i.test(url) ? url : void 0;
   } catch {
     return void 0;
@@ -7482,8 +7567,8 @@ var BeforeFirstEditTracker = class {
 };
 
 // src/agent-log.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync15, readdirSync as readdirSync6, readFileSync as readFileSync20, rmSync as rmSync12, writeFileSync as writeFileSync16 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync15, readdirSync as readdirSync6, readFileSync as readFileSync21, rmSync as rmSync12, writeFileSync as writeFileSync16 } from "fs";
+import { join as join23 } from "path";
 
 // src/pending-backoff.ts
 var sleepBackoff = (attempts) => Math.min(6e4 * 2 ** Math.max(0, attempts - 1), 30 * 6e4);
@@ -7686,20 +7771,20 @@ async function addRunToTicket(target, t, recordId, run3) {
     };
   }
 }
-var queueDir = (stateDir) => join22(stateDir, "pending-agent-logs");
+var queueDir = (stateDir) => join23(stateDir, "pending-agent-logs");
 function queueAgentRun(stateDir, name, q2) {
   mkdirSync15(queueDir(stateDir), { recursive: true });
-  writeFileSync16(join22(queueDir(stateDir), `${name}.json`), JSON.stringify(q2));
+  writeFileSync16(join23(queueDir(stateDir), `${name}.json`), JSON.stringify(q2));
 }
 async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = queueDir(stateDir);
   if (!existsSync21(dir)) return 0;
   let sent = 0;
   for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join22(dir, f);
+    const path = join23(dir, f);
     let q2;
     try {
-      q2 = JSON.parse(readFileSync20(path, "utf8"));
+      q2 = JSON.parse(readFileSync21(path, "utf8"));
     } catch {
       continue;
     }
@@ -7739,20 +7824,20 @@ async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__
   }
   return sent;
 }
-var countersDir = (stateDir) => join22(stateDir, "pending-ticket-counters");
+var countersDir = (stateDir) => join23(stateDir, "pending-ticket-counters");
 function queueTicketCounters(stateDir, name, q2) {
   mkdirSync15(countersDir(stateDir), { recursive: true });
-  writeFileSync16(join22(countersDir(stateDir), `${name}.json`), JSON.stringify(q2));
+  writeFileSync16(join23(countersDir(stateDir), `${name}.json`), JSON.stringify(q2));
 }
 async function replayQueuedTicketCounters(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = countersDir(stateDir);
   if (!existsSync21(dir)) return 0;
   let sent = 0;
   for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join22(dir, f);
+    const path = join23(dir, f);
     let q2;
     try {
-      q2 = JSON.parse(readFileSync20(path, "utf8"));
+      q2 = JSON.parse(readFileSync21(path, "utf8"));
     } catch {
       continue;
     }
@@ -7974,8 +8059,8 @@ var HandoffTranscriptTracker = class {
 };
 
 // src/pending-handoff.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync16, readdirSync as readdirSync7, readFileSync as readFileSync21, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync16, readdirSync as readdirSync7, readFileSync as readFileSync22, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "fs";
+import { join as join25 } from "path";
 
 // src/ticket-branch.ts
 import { basename as basename7 } from "path";
@@ -9142,7 +9227,7 @@ function holdWarnings(tickets, ships, contract, humanHolds, now = Date.now()) {
 
 // src/run-worktree.ts
 import { existsSync as existsSync22 } from "fs";
-import { dirname as dirname11, join as join23 } from "path";
+import { dirname as dirname11, join as join24 } from "path";
 var describeRunWorktreePlan = (p) => {
   switch (p.action) {
     case "cut-remote":
@@ -9199,7 +9284,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 = join23(dirname11(dir), worktreeForTicket(dir, cfg, t, role));
+  const path = join24(dirname11(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 };
   }
@@ -9656,12 +9741,12 @@ async function guardRunStrays(route2, ship, tracker, role, workingId, since2, lo
 
 // src/pending-handoff.ts
 var PENDING_MAX_AGE_MS = 48 * 36e5;
-var pendingDirFor = (stateDir) => join24(stateDir, "pending-handoffs");
-var stateDirOfStream = (streamPath) => join24(streamPath, "..", "..");
+var pendingDirFor = (stateDir) => join25(stateDir, "pending-handoffs");
+var stateDirOfStream = (streamPath) => join25(streamPath, "..", "..");
 function writePendingHandoff(stateDir, rec) {
   const dir = pendingDirFor(stateDir);
   mkdirSync16(dir, { recursive: true });
-  writeFileSync17(join24(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
+  writeFileSync17(join25(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
 }
 function listPendingHandoffs(stateDir, route2) {
   const dir = pendingDirFor(stateDir);
@@ -9669,7 +9754,7 @@ function listPendingHandoffs(stateDir, route2) {
   const out = [];
   for (const f of readdirSync7(dir).filter((n) => n.endsWith(".json")).sort()) {
     try {
-      const rec = JSON.parse(readFileSync21(join24(dir, f), "utf8"));
+      const rec = JSON.parse(readFileSync22(join25(dir, f), "utf8"));
       if (rec.version === 1 && rec.ticketRecordId && (!route2 || rec.route === route2)) out.push(rec);
     } catch {
     }
@@ -9677,7 +9762,7 @@ function listPendingHandoffs(stateDir, route2) {
   return out;
 }
 function removePendingHandoff(stateDir, ticketRecordId) {
-  rmSync13(join24(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
+  rmSync13(join25(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
 }
 function pendingHandoffFor(stateDir, ticketRecordId) {
   return listPendingHandoffs(stateDir).find((r) => r.ticketRecordId === ticketRecordId);
@@ -9787,8 +9872,8 @@ function expandSkillMarkers(text2, lookup2, opts = {}) {
 }
 
 // src/skills.ts
-import { readFileSync as readFileSync23, readdirSync as readdirSync8, existsSync as existsSync25 } from "fs";
-import { join as join26 } from "path";
+import { readFileSync as readFileSync24, readdirSync as readdirSync8, existsSync as existsSync25 } from "fs";
+import { join as join27 } from "path";
 import { parse as parseYaml } from "yaml";
 import { TablationClient as TablationClient3, StaleWriteError as StaleWriteError3, TablationApiError as TablationApiError2 } from "@tablation/client";
 
@@ -9804,8 +9889,8 @@ ${additions}`;
 }
 
 // src/agents.ts
-import { readFileSync as readFileSync22, existsSync as existsSync24 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync23, existsSync as existsSync24 } from "fs";
+import { join as join26 } from "path";
 import { TablationClient as TablationClient2, StaleWriteError as StaleWriteError2, TablationApiError } from "@tablation/client";
 var PERSONA_NAME = {
   dev: "Developer",
@@ -9819,12 +9904,12 @@ var CREW_AGENT_COLUMN = "agent_id";
 var AgentsSyncError = class extends Error {
 };
 function personaDefaultPrompt(promptsDir, role) {
-  const briefPath = join25(promptsDir, "personas", `lane-${role}.md`);
+  const briefPath = join26(promptsDir, "personas", `lane-${role}.md`);
   if (!existsSync24(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
-  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync22(briefPath, "utf8");
-  const commonPath = join25(promptsDir, "personas", "common.md");
-  if (!existsSync24(commonPath)) return readFileSync22(briefPath, "utf8");
-  return `${readFileSync22(commonPath, "utf8")}${readFileSync22(briefPath, "utf8")}`;
+  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync23(briefPath, "utf8");
+  const commonPath = join26(promptsDir, "personas", "common.md");
+  if (!existsSync24(commonPath)) return readFileSync23(briefPath, "utf8");
+  return `${readFileSync23(commonPath, "utf8")}${readFileSync23(briefPath, "utf8")}`;
 }
 async function resolveAgentId(route2, role, opts) {
   const cached = route2.resolved?.agentPersonas?.[role]?.agentId;
@@ -10271,7 +10356,7 @@ function describeCrewLink(o) {
 var SkillSyncError = class extends Error {
 };
 function parseSkillFile(path) {
-  const text2 = readFileSync23(path, "utf8");
+  const text2 = readFileSync24(path, "utf8");
   const match = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/.exec(text2);
   if (!match) throw new SkillSyncError(`${path}: missing YAML frontmatter (expected a leading --- block)`);
   const frontmatter = match[1];
@@ -10284,9 +10369,9 @@ function parseSkillFile(path) {
   return { name: meta.name, description: meta.description, prompt: body, file: path };
 }
 function listLocalSkills(promptsDir) {
-  const dir = join26(promptsDir, "skills");
+  const dir = join27(promptsDir, "skills");
   if (!existsSync25(dir)) return [];
-  return readdirSync8(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join26(dir, f)));
+  return readdirSync8(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join27(dir, f)));
 }
 async function syncSkills(route2, opts) {
   if (!route2.resolved) {
@@ -10473,7 +10558,7 @@ function skillMarkerWarnings(promptsDir, personaPrompts) {
 import { spawn as spawn3, execFile, execFileSync as execFileSync6 } from "child_process";
 import { mkdtempSync, mkdirSync as mkdirSync17, writeFileSync as writeFileSync18, rmSync as rmSync14 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename8, dirname as dirname12, join as join27 } from "path";
+import { basename as basename8, dirname as dirname12, join as join28 } from "path";
 import { promisify } from "util";
 
 // src/run-limit.ts
@@ -10646,9 +10731,9 @@ var SandboxRunner = class {
       const harness = cfg.agentBin ?? basename8(plan.bin);
       const viaUpload = Buffer.byteLength(plan.prompt) > SANDBOX_STDIN_LIMIT;
       if (viaUpload) {
-        const tmp = mkdtempSync(join27(tmpdir2(), "crew-prompt-"));
+        const tmp = mkdtempSync(join28(tmpdir2(), "crew-prompt-"));
         try {
-          const file = join27(tmp, "prompt.txt");
+          const file = join28(tmp, "prompt.txt");
           writeFileSync18(file, plan.prompt, { mode: 384 });
           await this.os(["sandbox", "upload", name, file, SANDBOX_PROMPT_PATH]);
         } finally {
@@ -10802,7 +10887,7 @@ var ALLOWANCE_REFUSAL_MARKER = "AI_ALLOWANCE_EXCEEDED";
 function streamShowsAllowanceRefusal(streamPath) {
   let raw;
   try {
-    raw = readFileSync24(streamPath, "utf8");
+    raw = readFileSync25(streamPath, "utf8");
   } catch {
     return false;
   }
@@ -10825,7 +10910,7 @@ function streamShowsAllowanceRefusal(streamPath) {
   }
   return false;
 }
-var digestPathFor = (stateDir, routeLabel, role, runId) => join28(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPathFor = (stateDir, routeLabel, role, runId) => join29(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
 function codeBridgeFor(o, harness) {
   if (o.ship.runner === "sandbox" || !o.ticket) return void 0;
   const number = /(\d+)$/.exec(o.ticket)?.[1];
@@ -10841,7 +10926,7 @@ function codeBridgeFor(o, harness) {
   const args = [...process.execArgv, process.argv[1] ?? "crew", "intel", "bridge", o.route.route, number, "--state-dir", o.stateDir];
   const bridge = { command: process.execPath, args };
   if (harness === "gemini") {
-    const file = join28(intelDir(o.stateDir, o.route.route, number), "gemini-settings.json");
+    const file = join29(intelDir(o.stateDir, o.route.route, number), "gemini-settings.json");
     mkdirSync18(dirname13(file), { recursive: true });
     writeFileSync19(file, `${JSON.stringify({ mcpServers: { [INTEL_SERVER_NAME]: { command: bridge.command, args } } }, null, 2)}
 `);
@@ -10850,11 +10935,11 @@ function codeBridgeFor(o, harness) {
   return bridge;
 }
 function planAgentRun(o) {
-  const briefPath = join28(o.route.promptsDir, "personas", `lane-${o.role}.md`);
+  const briefPath = join29(o.route.promptsDir, "personas", `lane-${o.role}.md`);
   if (!existsSync26(briefPath)) {
     throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
   }
-  const commonPath = join28(o.route.promptsDir, "personas", "common.md");
+  const commonPath = join29(o.route.promptsDir, "personas", "common.md");
   const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync26(commonPath);
   const now = o.now ?? (() => Date.now());
   const routeLabel = routeSlug(o.route.route);
@@ -10864,10 +10949,10 @@ function planAgentRun(o) {
   let ageSeconds;
   if (existsSync26(digestPath2)) {
     ageSeconds = Math.floor((now() - statSync8(digestPath2).mtimeMs) / 1e3);
-    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync24(digestPath2, "utf8");
+    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync25(digestPath2, "utf8");
   }
-  const common = usesCommon ? readFileSync24(commonPath, "utf8") : "";
-  const brief = readFileSync24(briefPath, "utf8");
+  const common = usesCommon ? readFileSync25(commonPath, "utf8") : "";
+  const brief = readFileSync25(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]));
@@ -10890,7 +10975,7 @@ function planAgentRun(o) {
     digest
   });
   const promptSha = createHash4("sha256").update(expanded.text).digest("hex");
-  const streamsDir = join28(o.stateDir, "streams");
+  const streamsDir = join29(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 { model } = seat;
@@ -10983,8 +11068,8 @@ function planAgentRun(o) {
     digestAttached: digest !== void 0,
     digestAgeSeconds: ageSeconds,
     model,
-    streamPath: join28(streamsDir, `${base}.jsonl`),
-    eventsPath: join28(streamsDir, `${base}.events.jsonl`),
+    streamPath: join29(streamsDir, `${base}.jsonl`),
+    eventsPath: join29(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
     ticketRecordId: o.ticketRecordId ?? null,
     repo: o.repo ?? null,
@@ -11015,7 +11100,7 @@ function describePlan(p) {
 var pidPathFor = (streamPath) => `${streamPath}.pid`;
 function readRunSidecar(streamPath) {
   try {
-    const sc = JSON.parse(readFileSync24(pidPathFor(streamPath), "utf8"));
+    const sc = JSON.parse(readFileSync25(pidPathFor(streamPath), "utf8"));
     return typeof sc.pid === "number" && typeof sc.spawnedAt === "string" && typeof sc.role === "string" ? sc : null;
   } catch {
     return null;
@@ -11588,19 +11673,19 @@ function runFinished(streamPath) {
   const path = `${streamPath}.meta.json`;
   if (!existsSync27(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 = join29(o.stateDir, "streams");
+  const dir = join30(o.stateDir, "streams");
   if (!existsSync27(dir)) return [];
   const ownerAlive = o.isOwnerAlive ?? pidAlive;
   const out = [];
   for (const name of readdirSync9(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join29(dir, name);
+    const streamPath = join30(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || sidecar.route !== o.routeLabel) continue;
@@ -11654,14 +11739,14 @@ async function reconcileRuns(o) {
 
 // src/live-runs.ts
 import { existsSync as existsSync28, readdirSync as readdirSync10, statSync as statSync9 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 function liveRuns(stateDir, isAlive = runIsAlive) {
-  const dir = join30(stateDir, "streams");
+  const dir = join31(stateDir, "streams");
   if (!existsSync28(dir)) return [];
   const out = [];
   for (const name of readdirSync10(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join30(dir, name);
+    const streamPath = join31(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || !isAlive(sidecar)) continue;
@@ -11671,12 +11756,12 @@ function liveRuns(stateDir, isAlive = runIsAlive) {
 }
 function runActivity(stateDir, isAlive = runIsAlive) {
   const activeRuns = liveRuns(stateDir, isAlive).length;
-  const dir = join30(stateDir, "streams");
+  const dir = join31(stateDir, "streams");
   let newest = 0;
   if (existsSync28(dir)) {
     for (const name of readdirSync10(dir)) {
       if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-      const streamPath = join30(dir, name);
+      const streamPath = join31(dir, name);
       if (!runFinished(streamPath)) continue;
       try {
         newest = Math.max(newest, statSync9(`${streamPath}.meta.json`).mtimeMs);
@@ -12716,10 +12801,10 @@ function planSandbox(repo, decl, warm = {}) {
   const layer = repoLayer(repo, decl, crew, warm);
   return { repo, tag: layer.tag, claude: SANDBOX_CLAUDE_VERSION, layers: [base, crew, layer] };
 }
-var sandboxStatePath = (stateDir) => join31(stateDir, "sandbox-images.json");
+var sandboxStatePath = (stateDir) => join32(stateDir, "sandbox-images.json");
 function readSandboxState(stateDir) {
   try {
-    const v = JSON.parse(readFileSync26(sandboxStatePath(stateDir), "utf8"));
+    const v = JSON.parse(readFileSync27(sandboxStatePath(stateDir), "utf8"));
     return v && typeof v === "object" && !Array.isArray(v) ? v : {};
   } catch {
     return {};
@@ -12770,7 +12855,7 @@ var engineRemoveImage = (engine = "docker", exec = realExec2) => (tag) => {
   } catch {
   }
 };
-var sandboxLogDir = (stateDir) => join31(stateDir, "sandbox-logs");
+var sandboxLogDir = (stateDir) => join32(stateDir, "sandbox-logs");
 async function buildSandboxImage(plan, deps) {
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const state = readSandboxState(deps.stateDir);
@@ -12780,19 +12865,19 @@ async function buildSandboxImage(plan, deps) {
   }
   const logDir = sandboxLogDir(deps.stateDir);
   mkdirSync19(logDir, { recursive: true });
-  const logPath = join31(logDir, `${slug(plan.repo)}-${now().toISOString().replace(/[:.]/g, "-")}.log`);
+  const logPath = join32(logDir, `${slug(plan.repo)}-${now().toISOString().replace(/[:.]/g, "-")}.log`);
   const builtLayers = [];
   for (const layer of plan.layers) {
     if (deps.hasImage(layer.tag)) continue;
-    const ctx = join31(tmpdir3(), `crew-sandbox-${hash([layer.tag, process.pid, Date.now()])}`);
+    const ctx = join32(tmpdir3(), `crew-sandbox-${hash([layer.tag, process.pid, Date.now()])}`);
     mkdirSync19(ctx, { recursive: true });
     try {
-      writeFileSync20(join31(ctx, "Dockerfile"), layer.dockerfile);
+      writeFileSync20(join32(ctx, "Dockerfile"), layer.dockerfile);
       for (const [name, content] of Object.entries(layer.files)) {
-        mkdirSync19(dirname14(join31(ctx, name)), { recursive: true });
-        writeFileSync20(join31(ctx, name), content);
+        mkdirSync19(dirname14(join32(ctx, name)), { recursive: true });
+        writeFileSync20(join32(ctx, name), content);
       }
-      const code = await deps.run(["build", "--tag", layer.tag, "--file", join31(ctx, "Dockerfile"), ctx], logPath);
+      const code = await deps.run(["build", "--tag", layer.tag, "--file", join32(ctx, "Dockerfile"), ctx], logPath);
       if (code !== 0) {
         state[plan.repo] = { ...entry, failure: { tag: plan.tag, at: now().toISOString(), logPath } };
         writeSandboxState(deps.stateDir, state);
@@ -12981,9 +13066,9 @@ function managedRuntimeWarnings(kind, ship) {
 
 // src/selftest.ts
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync30, mkdirSync as mkdirSync20, mkdtempSync as mkdtempSync2, readFileSync as readFileSync27, rmSync as rmSync16, writeFileSync as writeFileSync21 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync20, mkdtempSync as mkdtempSync2, readFileSync as readFileSync28, rmSync as rmSync16, writeFileSync as writeFileSync21 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 var SELFTEST_TIMEOUT_MS = 12e4;
 var KEY_VAR = "CREW_API_KEY";
 var SELFTEST_PROMPT = "This is a read-only connectivity check. Use the tracker MCP tool to read this workspace (the workspaces find-one tool, using the workspace id below) and reply with the workspace's name alone, on one line. Do not write anything, do not create files, and do not use any other tool.\n\nWorkspace id: ";
@@ -13144,7 +13229,7 @@ async function runSelftest(i, deps = realDeps) {
     ...adapter.runEnv(spec),
     [KEY_VAR]: i.apiKey
   };
-  const cwd = mkdtempSync2(join32(tmpdir4(), "crew-selftest-"));
+  const cwd = mkdtempSync2(join33(tmpdir4(), "crew-selftest-"));
   try {
     const run3 = await deps.run({
       bin: invocation.bin,
@@ -13177,11 +13262,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) => join32(stateDir, "selftest.json");
+var fileFor2 = (stateDir) => join33(stateDir, "selftest.json");
 function readSelftest(stateDir) {
   try {
     const p = fileFor2(stateDir);
-    return existsSync30(p) ? JSON.parse(readFileSync27(p, "utf8")) : {};
+    return existsSync30(p) ? JSON.parse(readFileSync28(p, "utf8")) : {};
   } catch {
     return {};
   }
@@ -13202,7 +13287,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve7, dirname as dirname33, join as join54, basename as basename16 } from "path";
+import { resolve as resolve7, dirname as dirname33, join as join55, basename as basename16 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname4, homedir as homedir11 } from "os";
 import { spawnSync as spawnSync11 } from "child_process";
@@ -13400,14 +13485,14 @@ function rosterMarkdown(roster, meId) {
 }
 
 // src/connect-resume.ts
-import { mkdirSync as mkdirSync21, readFileSync as readFileSync28, rmSync as rmSync17, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname15, join as join33 } from "path";
+import { mkdirSync as mkdirSync21, readFileSync as readFileSync29, rmSync as rmSync17, writeFileSync as writeFileSync22 } from "fs";
+import { dirname as dirname15, join as join34 } from "path";
 function lastSessionFile(stateDir) {
-  return join33(stateDir, "connect-session.json");
+  return join34(stateDir, "connect-session.json");
 }
 function readPointers(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync28(lastSessionFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync29(lastSessionFile(stateDir), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     const out = {};
     for (const [host, v] of Object.entries(parsed)) {
@@ -13507,15 +13592,15 @@ async function signOutSessions(o) {
 }
 
 // src/reset.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync22, readFileSync as readFileSync29, readdirSync as readdirSync12, rmSync as rmSync18, statSync as statSync10, writeFileSync as writeFileSync23 } from "fs";
-import { dirname as dirname16, join as join34 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync22, readFileSync as readFileSync30, readdirSync as readdirSync12, rmSync as rmSync18, statSync as statSync10, writeFileSync as writeFileSync23 } from "fs";
+import { dirname as dirname16, join as join35 } from "path";
 import { hostFromUrl as hostFromUrl3 } from "@tablation/client";
 function clonedCheckoutsFile(stateDir) {
-  return join34(stateDir, "cloned-checkouts.json");
+  return join35(stateDir, "cloned-checkouts.json");
 }
 function readClonedCheckouts(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync29(clonedCheckoutsFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync30(clonedCheckoutsFile(stateDir), "utf8"));
     return Array.isArray(parsed) ? parsed.filter((d) => typeof d === "string") : [];
   } catch {
     return [];
@@ -13602,10 +13687,10 @@ function removeCheckout(dir, dryRun, fx) {
 }
 function removeState(stateDir, dryRun) {
   const out = [];
-  const targets = [join34(stateDir, "resolved"), join34(stateDir, "keys"), clonedCheckoutsFile(stateDir), join34(stateDir, "connect-session.json"), join34(stateDir, "reload-requested"), join34(stateDir, "daemon.started")];
+  const targets = [join35(stateDir, "resolved"), join35(stateDir, "keys"), clonedCheckoutsFile(stateDir), join35(stateDir, "connect-session.json"), join35(stateDir, "reload-requested"), join35(stateDir, "daemon.started")];
   try {
     for (const name of readdirSync12(stateDir)) {
-      if (name.startsWith(".") && statSync10(join34(stateDir, name)).isFile()) targets.push(join34(stateDir, name));
+      if (name.startsWith(".") && statSync10(join35(stateDir, name)).isFile()) targets.push(join35(stateDir, name));
     }
   } catch {
   }
@@ -13625,7 +13710,7 @@ function wipeStateDir(stateDir, dryRun) {
     return [{ step: "state", target: stateDir, action: "absent", detail: "no state directory" }];
   }
   if (!names.length) return [{ step: "state", target: stateDir, action: "absent", detail: "already empty" }];
-  if (!dryRun) for (const n of names) rmSync18(join34(stateDir, n), { recursive: true, force: true });
+  if (!dryRun) for (const n of names) rmSync18(join35(stateDir, n), { recursive: true, force: true });
   return [{ step: "state", target: stateDir, action: mark(dryRun), detail: `${names.length} entr${names.length === 1 ? "y" : "ies"}` }];
 }
 function describeResetStep(s) {
@@ -13706,9 +13791,9 @@ async function runDeprovision(o, fx, deps) {
 }
 
 // src/pool-member.ts
-import { mkdirSync as mkdirSync23, readFileSync as readFileSync30, renameSync as renameSync4, writeFileSync as writeFileSync24 } from "fs";
+import { mkdirSync as mkdirSync23, readFileSync as readFileSync31, renameSync as renameSync4, writeFileSync as writeFileSync24 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname17, join as join35 } from "path";
+import { dirname as dirname17, join as join36 } from "path";
 var POOL_EXIT = { ok: 0, failed: 1, credential: 2 };
 function backoffMs(attempt) {
   return Math.min(6e4, 5e3 * 2 ** Math.max(0, attempt));
@@ -13939,14 +14024,14 @@ async function runPoolMember(deps) {
   }
 }
 function defaultMemberDir(env = process.env) {
-  return env.CREW_POOL_DIR ?? join35(env.XDG_STATE_HOME ?? join35(homedir8(), ".local", "state"), "crew-pool-member");
+  return env.CREW_POOL_DIR ?? join36(env.XDG_STATE_HOME ?? join36(homedir8(), ".local", "state"), "crew-pool-member");
 }
 function fileMemberStore(dir) {
-  const file = join35(dir, "member.json");
+  const file = join36(dir, "member.json");
   return {
     read() {
       try {
-        return JSON.parse(readFileSync30(file, "utf8"));
+        return JSON.parse(readFileSync31(file, "utf8"));
       } catch {
         return {};
       }
@@ -14012,10 +14097,10 @@ import { hostname as hostname3 } from "os";
 // src/machine-id.ts
 import { execFileSync as execFileSync10 } from "child_process";
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync32, mkdirSync as mkdirSync24, readFileSync as readFileSync31, writeFileSync as writeFileSync25 } from "fs";
-import { dirname as dirname18, join as join36 } from "path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync24, readFileSync as readFileSync32, writeFileSync as writeFileSync25 } from "fs";
+import { dirname as dirname18, join as join37 } from "path";
 function machineIdPathFor(stateDir) {
-  return join36(stateDir, "machine-id");
+  return join37(stateDir, "machine-id");
 }
 var sha256 = (s) => createHash7("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
@@ -14029,7 +14114,7 @@ function readRawMachineId(platform2 = process.platform) {
     }
     for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
       if (existsSync32(p)) {
-        const id = readFileSync31(p, "utf8").trim();
+        const id = readFileSync32(p, "utf8").trim();
         if (id) return id;
       }
     }
@@ -14041,7 +14126,7 @@ function ensureMachineId(stateDir, opts = {}) {
   if (opts.override?.trim()) return sha256(opts.override.trim());
   const path = machineIdPathFor(stateDir);
   if (existsSync32(path)) {
-    const cached = readFileSync31(path, "utf8").trim();
+    const cached = readFileSync32(path, "utf8").trim();
     if (/^[0-9a-f]{64}$/.test(cached)) return cached;
   }
   const raw = (opts.read ?? readRawMachineId)();
@@ -14061,7 +14146,7 @@ function matchShipRows(ships, shipName2, machineId) {
 
 // src/provision.ts
 import { spawnSync as spawnSync8 } from "child_process";
-import { existsSync as existsSync33, readFileSync as readFileSync32, writeFileSync as writeFileSync26 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync33, writeFileSync as writeFileSync26 } from "fs";
 import { hostname as hostname2 } from "os";
 import { parseDocument as parseDocument3, isMap as isMap2, isScalar } from "yaml";
 
@@ -14070,7 +14155,7 @@ import { parseDocument as parseDocument2 } from "yaml";
 
 // src/repos-cmd.ts
 import { homedir as homedir9 } from "os";
-import { basename as basename10, join as join37, resolve as resolve4 } from "path";
+import { basename as basename10, join as join38, resolve as resolve4 } from "path";
 import { isMap, isSeq, parseDocument, stringify as stringify2 } from "yaml";
 var ReposError = class extends Error {
 };
@@ -14348,7 +14433,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) : join37(expandDir(basePath, i.base), i.route.split("/")[0], name);
+  const target = i.dir ? expandDir(i.dir, i.base) : join38(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 });
   const forgeHost = i.resolved?.repoForgeHosts?.[id];
   return { ...add, remote, target, ...forgeHost ? { forgeHost } : {} };
@@ -14663,7 +14748,7 @@ function realProvisionDeps(crewHome) {
     enableRoute(route2) {
       const file = configFile();
       if (!file) return false;
-      const text2 = readFileSync32(file, "utf8");
+      const text2 = readFileSync33(file, "utf8");
       const doc = parseDocument3(text2);
       const routes = doc.get("routes");
       const entry = routes?.items?.find((r) => r.get("route") === route2);
@@ -14689,7 +14774,7 @@ function realProvisionDeps(crewHome) {
           continue;
         }
         for (const p of plan.unitPaths) {
-          if (!existsSync33(p) || readFileSync32(p, "utf8") !== plan.unitContent[p]) unitsStale = true;
+          if (!existsSync33(p) || readFileSync33(p, "utf8") !== plan.unitContent[p]) unitsStale = true;
         }
       }
       const label = labelFor(crewHome, "run");
@@ -14713,7 +14798,7 @@ function realProvisionDeps(crewHome) {
     setShipSetting(key, value2) {
       const file = configFile();
       if (!file) return false;
-      const doc = parseDocument3(readFileSync32(file, "utf8"));
+      const doc = parseDocument3(readFileSync33(file, "utf8"));
       if (doc.getIn(["ship", key]) === value2) return false;
       doc.setIn(["ship", key], value2);
       writeFileSync26(file, doc.toString());
@@ -14722,7 +14807,7 @@ function realProvisionDeps(crewHome) {
     applyManagedDefaults() {
       const file = configFile();
       if (!file) return [];
-      const doc = parseDocument3(readFileSync32(file, "utf8"));
+      const doc = parseDocument3(readFileSync33(file, "utf8"));
       const wrote = applyManagedDefaultsToDoc(doc);
       if (wrote.length) writeFileSync26(file, doc.toString());
       return wrote;
@@ -14741,9 +14826,9 @@ host=${host}
 
 // src/tunnel.ts
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync34, mkdirSync as mkdirSync25, readFileSync as readFileSync33, writeFileSync as writeFileSync27, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync25, readFileSync as readFileSync34, writeFileSync as writeFileSync27, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
 import { randomInt } from "crypto";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn7(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -14815,20 +14900,20 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join38(stateDir, "passengers", `${workspaceId}.json`);
+  return join39(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
   if (!existsSync34(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);
-  mkdirSync25(join38(stateDir, "passengers"), { recursive: true });
+  mkdirSync25(join39(stateDir, "passengers"), { recursive: true });
   writeFileSync27(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -14931,7 +15016,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join38(stateDir, "passengers");
+  const dir = join39(stateDir, "passengers");
   if (!existsSync34(dir)) return [];
   return readdirSync13(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
@@ -15834,7 +15919,7 @@ ${waiting.map((t) => `| ${displayKey2(t)} | ${t.status} | ${blockers(t, i)} |`).
 
 // src/poll.ts
 import { writeFileSync as writeFileSync28 } from "fs";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 
 // src/stalled.ts
 var STALLED_AFTER_CYCLES = 30;
@@ -16141,7 +16226,7 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route2, role, runId) => join39(stateDir, `digest-${route2}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPath = (stateDir, route2, role, runId) => join40(stateDir, `digest-${route2}-${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));
@@ -16327,7 +16412,7 @@ async function resolveOne(tracker, t, seat, approvedStatus, buildingStatus, affi
 }
 
 // src/repo-refresh.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync26, readFileSync as readFileSync34, writeFileSync as writeFileSync29 } from "fs";
+import { existsSync as existsSync36, mkdirSync as mkdirSync26, readFileSync as readFileSync35, writeFileSync as writeFileSync29 } from "fs";
 import { dirname as dirname20 } from "path";
 var REFRESH_COOLDOWN_MS = 2 * 6e4;
 var UNSERVABLE_PASSES_BEFORE_ATTENTION = 3;
@@ -16358,7 +16443,7 @@ function applyRepoRows(resolved, rows) {
 function persistRepoRows(stateDir, routeName, rows) {
   const path = resolvedPathFor(stateDir, routeName);
   if (!existsSync36(path)) return;
-  const raw = JSON.parse(readFileSync34(path, "utf8"));
+  const raw = JSON.parse(readFileSync35(path, "utf8"));
   applyRepoRows(raw, rows);
   mkdirSync26(dirname20(path), { recursive: true });
   writeFileSync29(path, `${JSON.stringify(raw, null, 2)}
@@ -16811,7 +16896,7 @@ 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 dirname21, join as join40 } from "path";
+import { delimiter, dirname as dirname21, join as join41 } from "path";
 import { accessSync as accessSync3, constants as constants3, existsSync as existsSync37, mkdirSync as mkdirSync27, writeFileSync as writeFileSync30 } from "fs";
 import { stringify as stringify3 } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
@@ -16834,7 +16919,7 @@ function defaultIsExecutable(p) {
 function findOnPath2(name, pathEnv, isExecutable = defaultIsExecutable) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join40(dir, name);
+    const candidate = join41(dir, name);
     if (isExecutable(candidate)) return candidate;
   }
   return void 0;
@@ -16931,7 +17016,7 @@ Wrote ${o.configPath}.
 // src/connect-json.ts
 import { accessSync as accessSync4, constants as constants4 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname22, join as join41 } from "path";
+import { dirname as dirname22, join as join42 } from "path";
 import { delimiter as delimiter2 } from "path";
 var CHOICE_EXIT_CODE = 3;
 function createEmitter(json2, write) {
@@ -16970,12 +17055,12 @@ function agentBinSearchDirs(home, pathEnv, extraPath) {
   const dirs = [
     ...pathEnv.split(delimiter2),
     ...(extraPath ?? "").split(delimiter2),
-    join41(home, ".local/bin"),
-    join41(home, ".claude/local"),
+    join42(home, ".local/bin"),
+    join42(home, ".claude/local"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
-    join41(home, ".npm-global/bin"),
-    join41(home, ".volta/bin")
+    join42(home, ".npm-global/bin"),
+    join42(home, ".volta/bin")
   ];
   return [...new Set(dirs.filter(Boolean))];
 }
@@ -17011,8 +17096,8 @@ function flagWizardAnswers(f, env) {
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync35, writeFileSync as writeFileSync31, existsSync as existsSync38, copyFileSync, mkdirSync as mkdirSync28, mkdtempSync as mkdtempSync3, rmSync as rmSync19 } from "fs";
-import { dirname as dirname23, join as join42 } from "path";
+import { readFileSync as readFileSync36, writeFileSync as writeFileSync31, existsSync as existsSync38, copyFileSync, mkdirSync as mkdirSync28, mkdtempSync as mkdtempSync3, rmSync as rmSync19 } from "fs";
+import { dirname as dirname23, join as join43 } from "path";
 import { tmpdir as tmpdir5 } from "os";
 
 // src/release.ts
@@ -17753,13 +17838,13 @@ async function bump(o, size) {
     }
     return printed;
   }
-  const files = o.repo.release.versionFiles.map((f) => join42(o.cwd, f));
+  const files = o.repo.release.versionFiles.map((f) => join43(o.cwd, f));
   const first = files[0];
   if (!existsSync38(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
     return null;
   }
-  const current = JSON.parse(readFileSync35(first, "utf8")).version;
+  const current = JSON.parse(readFileSync36(first, "utf8")).version;
   if (!current) {
     o.emit.error(`no version field in ${o.repo.release.versionFiles[0]}`);
     return null;
@@ -17772,7 +17857,7 @@ async function bump(o, size) {
     return version;
   }
   for (const f of files) {
-    const src = readFileSync35(f, "utf8");
+    const src = readFileSync36(f, "utf8");
     const out = src.replace(/("version"\s*:\s*")[^"]*(")/, `$1${version}$2`);
     if (out === src) {
       o.emit.error(`no version field in ${f}`);
@@ -17785,13 +17870,13 @@ async function bump(o, size) {
 function writeChangelog(o, version, entries) {
   const file = o.repo.release.changelog;
   if (!file || entries.length === 0) return;
-  const path = join42(o.cwd, file);
+  const path = join43(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 = existsSync38(path) ? readFileSync35(path, "utf8") : "# Changelog\n";
+  const existing = existsSync38(path) ? readFileSync36(path, "utf8") : "# Changelog\n";
   writeFileSync31(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
@@ -17885,8 +17970,8 @@ function closeReleaseCheckout(cwd, root, dir, branch, run3 = gitOk) {
 function openReleaseCheckout(o) {
   const { remote, base } = o.repo.branch;
   const branch = `crew/release-${Date.now()}`;
-  const root = mkdtempSync3(join42(tmpdir5(), "crew-release-"));
-  const dir = join42(root, "checkout");
+  const root = mkdtempSync3(join43(tmpdir5(), "crew-release-"));
+  const dir = join43(root, "checkout");
   o.emit.emit(`release checkout: ${dir}`, { step: "release" });
   const close = () => closeReleaseCheckout(o.cwd, root, dir, branch);
   try {
@@ -17896,10 +17981,10 @@ function openReleaseCheckout(o) {
     throw e;
   }
   for (const f of o.repo.worktrees.copy) {
-    const src = join42(o.cwd, f);
+    const src = join43(o.cwd, f);
     if (!existsSync38(src)) continue;
-    mkdirSync28(dirname23(join42(dir, f)), { recursive: true });
-    copyFileSync(src, join42(dir, f));
+    mkdirSync28(dirname23(join43(dir, f)), { recursive: true });
+    copyFileSync(src, join43(dir, f));
   }
   return { dir, branch, close };
 }
@@ -18489,49 +18574,6 @@ async function mergeAndRelease(o, decision, fresh, releaseBranch, isolated = fal
   return { merged, conflicts, unbuildable, version, tag, deployed, integrated, confirmed, decision };
 }
 
-// src/repo-map.ts
-var CHARS_PER_TOKEN = 4;
-var MAP_TIMEOUT_MS = 6e4;
-function budgetMap(text2, tokenBudget) {
-  const body = text2.replace(/\s+$/, "");
-  const limit = tokenBudget * CHARS_PER_TOKEN;
-  if (body.length <= limit) return body;
-  const lines2 = body.split("\n");
-  const noteFor = (kept2) => `\u2026 ${lines2.length - kept2} of ${lines2.length} lines cut to fit ship.mapTokenBudget (${tokenBudget} tokens)`;
-  let kept = lines2.length;
-  let size = body.length;
-  while (kept > 0 && size + 1 + noteFor(kept).length > limit) {
-    kept--;
-    size -= lines2[kept].length + 1;
-  }
-  return [...lines2.slice(0, kept), noteFor(kept)].join("\n");
-}
-function loadRepoMap(repo, tokenBudget, shellFallback) {
-  const script = repo.config.hooks.map;
-  if (!script) return Promise.resolve({ skipped: "" });
-  return runScript(script, {
-    cwd: repo.dir,
-    shell: resolveShell(repo.config.shell ?? shellFallback),
-    env: { CREW_REPO: repo.name },
-    timeoutMs: MAP_TIMEOUT_MS
-  }).then(
-    (r) => {
-      if (r.code !== 0) return { skipped: `the \`map\` hook for ${repo.name} exited ${r.code}, so the brief has no repository map` };
-      if (!r.stdout.trim()) return { skipped: `the \`map\` hook for ${repo.name} printed nothing, so the brief has no repository map` };
-      return { text: budgetMap(r.stdout, tokenBudget) };
-    },
-    (e) => ({ skipped: `the \`map\` hook for ${repo.name} could not run (${e instanceof Error ? e.message : String(e)}), so the brief has no repository map` })
-  );
-}
-async function withRepoMaps(repos, tokenBudget, shellFallback) {
-  return Promise.all(repos.map(async (r) => {
-    if (!r.config.hooks.map) return r;
-    const out = await loadRepoMap(r, tokenBudget, shellFallback);
-    if ("skipped" in out) return out.skipped ? { ...r, mapSkipped: out.skipped } : r;
-    return { ...r, map: out.text };
-  }));
-}
-
 // src/failure-alert.ts
 var FAILURE_ALERT_MARKER = calloutHeader("CAUTION", "Failure Alert");
 function findOpenFailureAlert(tickets, headline) {
@@ -19265,7 +19307,7 @@ function nextRoles(decision, ran) {
 }
 
 // src/ship-name.ts
-import { existsSync as existsSync40, mkdirSync as mkdirSync29, readFileSync as readFileSync36, renameSync as renameSync5, writeFileSync as writeFileSync32 } from "fs";
+import { existsSync as existsSync40, mkdirSync as mkdirSync29, readFileSync as readFileSync37, renameSync as renameSync5, writeFileSync as writeFileSync32 } from "fs";
 import { dirname as dirname24 } from "path";
 import { parseDocument as parseDocument5 } from "yaml";
 var ShipNameError = class extends Error {
@@ -19329,7 +19371,7 @@ async function syncRouteName(i) {
 function readSyncedName(resolvedFile) {
   if (!existsSync40(resolvedFile)) return void 0;
   try {
-    const v = JSON.parse(readFileSync36(resolvedFile, "utf8")).shipName;
+    const v = JSON.parse(readFileSync37(resolvedFile, "utf8")).shipName;
     return typeof v === "string" ? v : void 0;
   } catch {
     return void 0;
@@ -19339,7 +19381,7 @@ function writeSyncedName(resolvedFile, name) {
   if (!existsSync40(resolvedFile)) return;
   let raw;
   try {
-    raw = JSON.parse(readFileSync36(resolvedFile, "utf8"));
+    raw = JSON.parse(readFileSync37(resolvedFile, "utf8"));
   } catch {
     return;
   }
@@ -19354,7 +19396,7 @@ function writeSyncedName(resolvedFile, name) {
 async function reconcileShipName(i) {
   let local = i.ship.name;
   try {
-    local = shipNameOfYaml(readFileSync36(i.configFile, "utf8")) ?? local;
+    local = shipNameOfYaml(readFileSync37(i.configFile, "utf8")) ?? local;
   } catch {
   }
   const resolvedFile = resolvedPathFor(i.stateDir, i.route);
@@ -19378,7 +19420,7 @@ async function reconcileShipName(i) {
   }
   if (result.status !== "ok") return result;
   if (result.action === "adopt" || result.action === "row-wins") {
-    const text2 = readFileSync36(i.configFile, "utf8");
+    const text2 = readFileSync37(i.configFile, "utf8");
     writeFileSync32(i.configFile, setShipNameInYaml(text2, result.name));
     i.ship.name = result.name;
     if (result.action === "row-wins") {
@@ -20038,7 +20080,7 @@ function describeCapability(i) {
 }
 
 // src/agents-sync-run.ts
-import { existsSync as existsSync41, mkdirSync as mkdirSync30, readFileSync as readFileSync37, writeFileSync as writeFileSync33 } from "fs";
+import { existsSync as existsSync41, mkdirSync as mkdirSync30, readFileSync as readFileSync38, writeFileSync as writeFileSync33 } from "fs";
 import { dirname as dirname25 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
@@ -20072,7 +20114,7 @@ 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 = existsSync41(resolvedPath) ? JSON.parse(readFileSync37(resolvedPath, "utf8")) : {};
+    const raw = existsSync41(resolvedPath) ? JSON.parse(readFileSync38(resolvedPath, "utf8")) : {};
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
@@ -20194,7 +20236,7 @@ async function showLogEntry(route2, entryId, opts = {}) {
 
 // src/repos-check.ts
 import { spawnSync as spawnSync10 } from "child_process";
-import { readFileSync as readFileSync38 } from "fs";
+import { readFileSync as readFileSync39 } from "fs";
 import { basename as basename11 } from "path";
 var POSIX_SHELL = /^(?:ba|z|da|k|a|mk)?sh$|^fish$/;
 function checkHookSyntax(script, shell) {
@@ -20228,14 +20270,14 @@ function renderSamples(cfg, dir) {
   });
 }
 function checkRepoSpec(dir, opts = {}) {
-  const empty = { parsed: null, effective: null, readiness: [], hooks: [], shadowed: [], samples: [] };
+  const empty = { parsed: null, effective: null, readiness: [], hooks: [], shadowed: [], mapFile: null, samples: [] };
   const file = findRepoConfig(dir);
   if (!file) {
     return { ...empty, file: null, error: `no .crew.yaml, .crew.yml or .crew.json in ${dir}`, exitCode: 1 };
   }
   let parsed;
   try {
-    parsed = parseRepoConfig(readFileSync38(file, "utf8"), file);
+    parsed = parseRepoConfig(readFileSync39(file, "utf8"), file);
   } catch (e) {
     if (!(e instanceof RepoConfigError)) throw e;
     return { ...empty, file, error: e.message, exitCode: 1 };
@@ -20246,14 +20288,16 @@ function checkRepoSpec(dir, opts = {}) {
     const engine = effective.hooks.setup ? containerEngineUse(effective.hooks.setup) : null;
     if (engine) readiness.push(`hooks.setup runs \`${engine}\`, and a sandbox has no container engine \u2014 start the service as a process instead (REPO_SPEC.md, "Services inside the sandbox")`);
   }
-  const hooks = Object.keys(effective.hooks).map((name) => ({
+  const mapPath = mapFilePath(effective.hooks.map);
+  const mapFile = mapPath ? { ...inspectMapFile(dir, mapPath), budget: opts.ship?.mapTokenBudget ?? DEFAULT_MAP_TOKEN_BUDGET } : null;
+  const hooks = Object.keys(effective.hooks).filter((name) => !(name === "map" && mapPath)).map((name) => ({
     name,
     label: hookLabel(effective, name),
     // CREW-2914: a flavor name is not shell, so it is not syntax-checked.
     syntax: name === "intel" && intelFlavor(effective.hooks.intel) ? { status: "ok" } : checkHookSyntax(effective.hooks[name], effective.shell),
     ...name === "intel" && intelFlavor(effective.hooks.intel) ? { flavor: intelFlavor(effective.hooks.intel) } : {}
   }));
-  const failed = hooks.some((h) => h.syntax.status === "error");
+  const failed = hooks.some((h) => h.syntax.status === "error") || mapFile !== null && !mapFile.exists;
   return {
     file,
     parsed,
@@ -20261,6 +20305,7 @@ function checkRepoSpec(dir, opts = {}) {
     readiness,
     hooks,
     shadowed: effective.shadowed,
+    mapFile,
     samples: renderSamples(effective, dir),
     error: null,
     exitCode: failed || opts.strict && readiness.length > 0 ? 1 : 0
@@ -20280,6 +20325,10 @@ function renderRepoCheck(r) {
     `  branch.push        ${e.branch.push}`
   ];
   for (const s of r.samples) lines2.push(`  ${s.case}: branch ${s.branch}, worktree ../${s.worktree}`);
+  if (r.mapFile) {
+    const m = r.mapFile;
+    lines2.push(m.exists ? `  map: file ${m.path} (${m.lines} lines, about ${m.tokens} tokens; ship budget ${m.budget})` : `  map: file ${m.path} NOT FOUND \u2014 the brief will carry an absence note`);
+  }
   lines2.push(r.hooks.length ? "  hooks" : "  hooks              none");
   for (const h of r.hooks) {
     const named = h.label !== e.hooks[h.name] ? ` (${h.label})` : "";
@@ -20692,7 +20741,7 @@ ${run3.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename12, dirname as dirname26, join as join43 } from "path";
+import { basename as basename12, dirname as dirname26, join as join44 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -20715,8 +20764,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 join43(dirname26(existing[0]), SAMPLE_REPO);
-  return join43(reposBase, workspace, SAMPLE_REPO);
+  if (existing.length > 0) return join44(dirname26(existing[0]), SAMPLE_REPO);
+  return join44(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
 function sampleDescription() {
@@ -20760,8 +20809,8 @@ function planSampleTicket(i) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync42, readFileSync as readFileSync39, readdirSync as readdirSync14 } from "fs";
-import { basename as basename13, dirname as dirname27, join as join44, resolve as resolve5 } from "path";
+import { existsSync as existsSync42, readFileSync as readFileSync40, readdirSync as readdirSync14 } from "fs";
+import { basename as basename13, dirname as dirname27, join as join45, resolve as resolve5 } 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;
@@ -20838,7 +20887,7 @@ function siblingWorktreeDirs(target) {
   for (const name of names) {
     if (!name.startsWith(stem)) continue;
     const m = DIR_NUMBER_SUFFIXED.exec(name);
-    const path = join44(parent, name);
+    const path = join45(parent, name);
     if (m && !registered.has(resolve5(path))) out.push({ path, number: m[1] });
   }
   return out;
@@ -20941,7 +20990,7 @@ function isHandBackMerge(path, base) {
   if (!msgPath) return false;
   let first;
   try {
-    first = readFileSync39(resolve5(path, msgPath), "utf8").split("\n")[0] ?? "";
+    first = readFileSync40(resolve5(path, msgPath), "utf8").split("\n")[0] ?? "";
   } catch {
     return false;
   }
@@ -21047,13 +21096,13 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 
 // src/stream-sweep.ts
 import { existsSync as existsSync43, readdirSync as readdirSync15, rmSync as rmSync20, statSync as statSync12 } from "fs";
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join45(stateDir, "streams");
+  const dir = join46(stateDir, "streams");
   if (!existsSync43(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync15(dir).map((name) => join45(dir, name)).filter((path) => {
+  return readdirSync15(dir).map((name) => join46(dir, name)).filter((path) => {
     try {
       return statSync12(path).mtimeMs < cutoff;
     } catch {
@@ -21081,7 +21130,7 @@ function applyStreamSweep(paths, dryRun, log) {
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
   if (!existsSync43(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync15(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join45(stateDir, name)).filter((path) => {
+  return readdirSync15(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join46(stateDir, name)).filter((path) => {
     try {
       return statSync12(path).mtimeMs < cutoff;
     } catch {
@@ -21091,12 +21140,12 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync45, existsSync as existsSync50, mkdirSync as mkdirSync38, writeFileSync as writeFileSync38, rmSync as rmSync25, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync6, statSync as statSync16, readdirSync as readdirSync20 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync46, existsSync as existsSync50, mkdirSync as mkdirSync38, writeFileSync as writeFileSync38, rmSync as rmSync25, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync6, statSync as statSync16, readdirSync as readdirSync20 } from "fs";
 import { createInterface } from "readline/promises";
 
 // src/periscope-cmd.ts
-import { existsSync as existsSync44, mkdirSync as mkdirSync31, readFileSync as readFileSync40, rmSync as rmSync21, writeFileSync as writeFileSync34 } from "fs";
-import { join as join46 } from "path";
+import { existsSync as existsSync44, mkdirSync as mkdirSync31, readFileSync as readFileSync41, rmSync as rmSync21, writeFileSync as writeFileSync34 } from "fs";
+import { join as join47 } from "path";
 var PeriscopeError = class extends Error {
 };
 var LivePeriscopeError = class extends PeriscopeError {
@@ -21106,8 +21155,8 @@ var LivePeriscopeError = class extends PeriscopeError {
     this.data = { refused: "live_periscope_exists", ...live };
   }
 };
-var priorDir = (stateDir) => join46(stateDir, "periscope-priors");
-var priorPath = (stateDir, ticketRecordId) => join46(priorDir(stateDir), `${ticketRecordId}.json`);
+var priorDir = (stateDir) => join47(stateDir, "periscope-priors");
+var priorPath = (stateDir, ticketRecordId) => join47(priorDir(stateDir), `${ticketRecordId}.json`);
 function removePeriscopePrior(stateDir, ticketRecordId) {
   rmSync21(priorPath(stateDir, ticketRecordId), { force: true });
 }
@@ -21121,7 +21170,7 @@ function writePeriscopePrior(stateDir, ticketRecordId, prior) {
 function readPeriscopePrior(stateDir, ticketRecordId) {
   try {
     const p = priorPath(stateDir, ticketRecordId);
-    return existsSync44(p) ? JSON.parse(readFileSync40(p, "utf8")) : void 0;
+    return existsSync44(p) ? JSON.parse(readFileSync41(p, "utf8")) : void 0;
   } catch {
     return void 0;
   }
@@ -21575,7 +21624,7 @@ ${tail2(preview.output)}`);
 // src/periscope-idle.ts
 import { execFileSync as execFileSync12 } from "child_process";
 import { statSync as statSync13 } from "fs";
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 var MAX_SCANNED_FILES = 2e4;
 function newestWorktreeMtime(root) {
   const a = newestTrackedMtime(root);
@@ -21600,7 +21649,7 @@ function newestTrackedMtime(root) {
     if (!rel) continue;
     if (++scanned > MAX_SCANNED_FILES) break;
     try {
-      const m = statSync13(join47(root, rel)).mtimeMs;
+      const m = statSync13(join48(root, rel)).mtimeMs;
       if (newest === null || m > newest) newest = m;
     } catch {
     }
@@ -21676,12 +21725,12 @@ import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync13 } from "child_process";
-import { existsSync as existsSync45, mkdirSync as mkdirSync32, readFileSync as readFileSync41, chmodSync as chmodSync3 } from "fs";
-import { dirname as dirname28, join as join48 } from "path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync32, readFileSync as readFileSync42, chmodSync as chmodSync3 } from "fs";
+import { dirname as dirname28, join as join49 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join48(stateDir, "ssh", "id_ed25519");
+  return join49(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
@@ -21710,7 +21759,7 @@ function ensureShipSshKeypair(stateDir) {
   if (!existsSync45(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync41(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync42(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -21874,8 +21923,8 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn9 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync46, mkdirSync as mkdirSync34, readFileSync as readFileSync42, writeFileSync as writeFileSync35, unlinkSync as unlinkSync4, readdirSync as readdirSync16 } from "fs";
-import { join as join49 } from "path";
+import { existsSync as existsSync46, mkdirSync as mkdirSync34, readFileSync as readFileSync43, writeFileSync as writeFileSync35, unlinkSync as unlinkSync4, readdirSync as readdirSync16 } from "fs";
+import { join as join50 } from "path";
 
 // src/passenger-mirror.ts
 import { mkdirSync as mkdirSync33 } from "fs";
@@ -22005,20 +22054,20 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join49(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join50(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
   if (!existsSync46(path)) return void 0;
   try {
-    return JSON.parse(readFileSync42(path, "utf8"));
+    return JSON.parse(readFileSync43(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync34(join49(stateDir, "passengers"), { recursive: true });
+  mkdirSync34(join50(stateDir, "passengers"), { recursive: true });
   writeFileSync35(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -22039,7 +22088,7 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join49(stateDir, "passengers");
+  const dir = join50(stateDir, "passengers");
   if (!existsSync46(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync16(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
@@ -22537,8 +22586,8 @@ function describeCause(err3) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync47, mkdirSync as mkdirSync36, readFileSync as readFileSync43, readdirSync as readdirSync17, rmSync as rmSync22, statSync as statSync14, writeFileSync as writeFileSync36 } from "fs";
-import { join as join50 } from "path";
+import { existsSync as existsSync47, mkdirSync as mkdirSync36, readFileSync as readFileSync44, readdirSync as readdirSync17, rmSync as rmSync22, statSync as statSync14, writeFileSync as writeFileSync36 } from "fs";
+import { join as join51 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
@@ -22626,7 +22675,7 @@ function latestMtime(path) {
   if (!stat2.isDirectory()) return 0;
   let latest = stat2.mtimeMs;
   for (const entry of readdirSync17(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join50(path, entry.name)));
+    latest = Math.max(latest, latestMtime(join51(path, entry.name)));
   }
   return latest;
 }
@@ -22638,7 +22687,7 @@ function makeStaleChecker(paths, opts = {}) {
   return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync47(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join50(stateDir, "reload-requested");
+  return join51(stateDir, "reload-requested");
 }
 function readReloadRequestedAt(stateDir) {
   try {
@@ -22648,7 +22697,7 @@ function readReloadRequestedAt(stateDir) {
   }
 }
 function daemonStampFor(stateDir) {
-  return join50(stateDir, "daemon.started");
+  return join51(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
   mkdirSync36(stateDir, { recursive: true });
@@ -22658,7 +22707,7 @@ function noteDaemonStarted(stateDir, now = Date.now()) {
 }
 function readDaemonStarted(stateDir) {
   try {
-    const v = JSON.parse(readFileSync43(daemonStampFor(stateDir), "utf8")).startedAt;
+    const v = JSON.parse(readFileSync44(daemonStampFor(stateDir), "utf8")).startedAt;
     return typeof v === "number" ? v : null;
   } catch {
     return null;
@@ -23235,7 +23284,7 @@ import {
 } from "fs";
 import { createConnection } from "net";
 import { createServer as createServer2 } from "http";
-import { basename as basename14, dirname as dirname31, join as join51 } from "path";
+import { basename as basename14, dirname as dirname31, join as join52 } from "path";
 import { execFile as execFile3, spawn as spawn12 } from "child_process";
 
 // src/periscope-control.ts
@@ -23464,7 +23513,7 @@ function runCrew(args, onLine, timeoutMs = 20 * 6e4) {
 // src/control-api.ts
 var PAUSABLE = ["dev", "design", "qa"];
 var CONTROL_SOCKET_NAME = "control.sock";
-var controlSocketFor = (stateDir) => join51(stateDir, CONTROL_SOCKET_NAME);
+var controlSocketFor = (stateDir) => join52(stateDir, CONTROL_SOCKET_NAME);
 var MAX_SOCKET_PATH = 100;
 var MAX_TAIL_BYTES = 1024 * 1024;
 var MAX_WAIT_SECONDS = 30;
@@ -23551,7 +23600,7 @@ function candidates(live, rotated) {
   const out = [live];
   if (!rotated) return out;
   try {
-    for (const n of readdirSync18(dirname31(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join51(dirname31(live), n));
+    for (const n of readdirSync18(dirname31(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join52(dirname31(live), n));
   } catch {
   }
   return out;
@@ -23751,7 +23800,7 @@ async function route(deps, method, url, req, abort) {
   if (p.startsWith("/streams/") && get2) {
     const run3 = decodeURIComponent(p.slice("/streams/".length));
     if (!RUN_NAME_RE.test(run3) || run3.includes("..") || /\.(pid|meta\.json|events\.jsonl)$/.test(run3)) return err2(400, "not a run name");
-    const file = join51(deps.stateDir, "streams", run3.endsWith(".jsonl") ? run3 : `${run3}.jsonl`);
+    const file = join52(deps.stateDir, "streams", run3.endsWith(".jsonl") ? run3 : `${run3}.jsonl`);
     if (!existsSync48(file)) return err2(404, "no such run");
     return tailReply(file, url.searchParams, false, abort);
   }
@@ -23901,19 +23950,19 @@ 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 basename15, dirname as dirname32, isAbsolute as isAbsolute5, join as join53, relative as relative2, resolve as resolve6, sep } from "path";
+import { basename as basename15, dirname as dirname32, isAbsolute as isAbsolute5, join as join54, relative as relative2, resolve as resolve6, 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 existsSync49, mkdirSync as mkdirSync37, readdirSync as readdirSync19, readFileSync as readFileSync44, rmSync as rmSync24, writeFileSync as writeFileSync37 } from "fs";
-import { join as join52 } from "path";
-var secretDir = (stateDir) => join52(stateDir, "periscope-mcp");
-var secretFile = (stateDir, id) => join52(secretDir(stateDir), `${id}.json`);
-var endpointDir = (stateDir) => join52(stateDir, "periscope-endpoints");
-var endpointFile = (stateDir, id) => join52(endpointDir(stateDir), `${id}.json`);
+import { chmodSync as chmodSync5, existsSync as existsSync49, mkdirSync as mkdirSync37, readdirSync as readdirSync19, readFileSync as readFileSync45, rmSync as rmSync24, writeFileSync as writeFileSync37 } from "fs";
+import { join as join53 } from "path";
+var secretDir = (stateDir) => join53(stateDir, "periscope-mcp");
+var secretFile = (stateDir, id) => join53(secretDir(stateDir), `${id}.json`);
+var endpointDir = (stateDir) => join53(stateDir, "periscope-endpoints");
+var endpointFile = (stateDir, id) => join53(endpointDir(stateDir), `${id}.json`);
 function mintPeriscopeSecret(stateDir, ticketRecordId) {
   mkdirSync37(secretDir(stateDir), { recursive: true, mode: 448 });
   const secret = randomBytes3(32).toString("base64url");
@@ -23925,7 +23974,7 @@ function mintPeriscopeSecret(stateDir, ticketRecordId) {
 }
 function readPeriscopeSecret(stateDir, ticketRecordId) {
   try {
-    const v = JSON.parse(readFileSync44(secretFile(stateDir, ticketRecordId), "utf8"));
+    const v = JSON.parse(readFileSync45(secretFile(stateDir, ticketRecordId), "utf8"));
     return typeof v.secret === "string" && v.secret ? v.secret : void 0;
   } catch {
     return void 0;
@@ -23936,7 +23985,7 @@ function removePeriscopeSecret(stateDir, ticketRecordId) {
 }
 function readPeriscopeEndpoint(stateDir, ticketRecordId) {
   try {
-    return JSON.parse(readFileSync44(endpointFile(stateDir, ticketRecordId), "utf8"));
+    return JSON.parse(readFileSync45(endpointFile(stateDir, ticketRecordId), "utf8"));
   } catch {
     return void 0;
   }
@@ -24054,13 +24103,13 @@ async function resolveInWorktree(root, requested) {
   let abs;
   if (isAbsolute5(requested)) {
     abs = resolve6(requested);
-    if (isInside(root, abs)) abs = join53(realRoot, relative2(root, abs));
+    if (isInside(root, abs)) abs = join54(realRoot, relative2(root, abs));
   } else {
     abs = resolve6(realRoot, requested);
   }
   if (!isInside(realRoot, abs)) throw new PathRefusal(`${requested} is outside this periscope's worktree`);
   const { real, rest } = await realAncestor(abs);
-  const final = rest ? join53(real, rest) : real;
+  const final = rest ? join54(real, rest) : real;
   if (!isInside(realRoot, final)) throw new PathRefusal(`${requested} is outside this periscope's worktree`);
   if (relative2(realRoot, final).split(sep).includes(".git")) throw new PathRefusal(".git is not reachable from a periscope");
   return final;
@@ -24128,7 +24177,7 @@ function createPeriscopeMcpServer(d, sc) {
     const entries = (await readdir(abs, { withFileTypes: true })).filter((e) => e.name !== ".git");
     const lines2 = await Promise.all(entries.map(async (e) => {
       if (e.isDirectory()) return `[DIR]  ${e.name}`;
-      const size = (await lstat(join53(abs, e.name))).size;
+      const size = (await lstat(join54(abs, e.name))).size;
       return `[FILE] ${e.name} (${size} bytes)`;
     }));
     return text(lines2.join("\n") || "(empty)");
@@ -24194,7 +24243,7 @@ function createPeriscopeMcpServer(d, sc) {
     annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
   }, async ({ path }) => {
     const parent = await inTree(dirname32(path) === "" ? "." : dirname32(path));
-    const abs = join53(parent, basename15(path));
+    const abs = join54(parent, basename15(path));
     if (basename15(path) === ".git" || abs === parent) return text("path must name a file", true);
     const st = await lstat(abs).catch(() => void 0);
     if (!st) return text(`${path} does not exist`, true);
@@ -24685,7 +24734,7 @@ if (command === "provision") {
   process.exit(outcome.code);
 }
 if (command === "pool-member") {
-  const pool = poolConfigFrom(argv, process.env, () => readFileSync45(0, "utf8"));
+  const pool = poolConfigFrom(argv, process.env, () => readFileSync46(0, "utf8"));
   if (typeof pool === "string") {
     process.stderr.write(`crew pool-member: ${pool}
 `);
@@ -24943,7 +24992,7 @@ if (command === "passenger-sync-daemon") {
     throw e;
   }
   if (command === "credential") {
-    const r = runCredential(positional[1], readFileSync45(0, "utf8"), cfg.ship.forges, cfg.ship.stateDir);
+    const r = runCredential(positional[1], readFileSync46(0, "utf8"), cfg.ship.forges, cfg.ship.stateDir);
     process.stdout.write(r.out);
     process.stderr.write(r.err);
     process.exit(r.code);
@@ -24955,9 +25004,9 @@ if (command === "passenger-sync-daemon") {
         forges: cfg.ship.forges,
         stateDir: cfg.ship.stateDir,
         configFile: cfg.configFile,
-        readFile: (p) => readFileSync45(p, "utf8"),
+        readFile: (p) => readFileSync46(p, "utf8"),
         writeFile: (p, t) => writeFileSync38(p, t),
-        stdin: () => readFileSync45(0, "utf8"),
+        stdin: () => readFileSync46(0, "utf8"),
         env: process.env
       }
     );
@@ -25250,7 +25299,7 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join54(homedir11(), ".config", "systemd", "user", `${label}.timer`);
+      const staleTimer = join55(homedir11(), ".config", "systemd", "user", `${label}.timer`);
       if (existsSync50(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
@@ -25322,7 +25371,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;
-          writeFileSync38(cfg.configFile, planEnable(readFileSync45(cfg.configFile, "utf8"), a.route));
+          writeFileSync38(cfg.configFile, planEnable(readFileSync46(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -26461,7 +26510,7 @@ ${cu.tail.trimEnd()}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join54(CREW_HOME, "src"), join54(CREW_HOME, "dist"), join54(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join55(CREW_HOME, "src"), join55(CREW_HOME, "dist"), join55(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -26766,7 +26815,7 @@ ${cu.tail.trimEnd()}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync50(resolvedPath) ? JSON.parse(readFileSync45(resolvedPath, "utf8")) : {};
+        const raw = existsSync50(resolvedPath) ? JSON.parse(readFileSync46(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
         mkdirSync38(dirOf2(resolvedPath), { recursive: true });
         writeFileSync38(resolvedPath, `${JSON.stringify(raw, null, 2)}
@@ -26792,7 +26841,7 @@ ${cu.tail.trimEnd()}
         throw e;
       }
       const oldName = cfg.ship.name;
-      writeFileSync38(cfg.configFile, setShipNameInYaml(readFileSync45(cfg.configFile, "utf8"), newName));
+      writeFileSync38(cfg.configFile, setShipNameInYaml(readFileSync46(cfg.configFile, "utf8"), newName));
       cfg.ship.name = newName;
       let renameMachineId;
       try {
@@ -26839,7 +26888,7 @@ ${cu.tail.trimEnd()}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list" && sub !== "clone" && sub !== "hooks" && sub !== "check") usage2();
-      const configText = readFileSync45(cfg.configFile, "utf8");
+      const configText = readFileSync46(cfg.configFile, "utf8");
       if (sub === "check") {
         try {
           const routeArg = value("route") ?? positional[2];
@@ -26854,7 +26903,8 @@ ${cu.tail.trimEnd()}
             labels: { ...found.labels, ...o?.labels },
             release: mergeRouteRelease(found.release, o?.release),
             branch: { ...found.branch, ...o?.branch },
-            worktrees: { prefix: shipWorktreePrefixFor(found), nameOverride: o?.worktreeName }
+            worktrees: { prefix: shipWorktreePrefixFor(found), nameOverride: o?.worktreeName },
+            mapTokenBudget: cfg.ship.mapTokenBudget
           });
         } catch (e) {
           if (e instanceof ReposError) {
@@ -26879,7 +26929,7 @@ ${cu.tail.trimEnd()}
             }
           }, read: (r) => {
             try {
-              return readFileSync45(resolvePath(dir, r), "utf8");
+              return readFileSync46(resolvePath(dir, r), "utf8");
             } catch {
               return void 0;
             }
@@ -27030,7 +27080,7 @@ ${cu.tail.trimEnd()}
       let resolvedRemotes;
       if (existsSync50(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync45(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync46(resolvedFile, "utf8"));
         } catch {
         }
       }
@@ -27051,7 +27101,7 @@ ${cu.tail.trimEnd()}
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
-                  return Object.keys(parseRepoConfig(readFileSync45(resolvePath(d, f), "utf8"), f).hooks).length > 0;
+                  return Object.keys(parseRepoConfig(readFileSync46(resolvePath(d, f), "utf8"), f).hooks).length > 0;
                 } catch {
                   return false;
                 }
@@ -27160,7 +27210,7 @@ ${cu.tail.trimEnd()}
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
           if (existsSync50(resolvedFile)) {
-            const raw = JSON.parse(readFileSync45(resolvedFile, "utf8"));
+            const raw = JSON.parse(readFileSync46(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
             writeFileSync38(resolvedFile, `${JSON.stringify(raw, null, 2)}
@@ -27538,7 +27588,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.exit(2);
         }
         if (found.shipNameAdopted && !dryRun) {
-          writeFileSync38(cfg.configFile, setShipNameInYaml(readFileSync45(cfg.configFile, "utf8"), found.shipNameAdopted));
+          writeFileSync38(cfg.configFile, setShipNameInYaml(readFileSync46(cfg.configFile, "utf8"), found.shipNameAdopted));
           cfg.ship.name = found.shipNameAdopted;
         }
         if (found.shipRow) {
@@ -27584,7 +27634,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         const hadPreviousFile = existsSync50(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync45(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync46(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -28458,10 +28508,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           startupSeconds: cfg.ship.intelStartupSeconds,
           prepare: async (path) => {
             for (const f of repoWt.config.worktrees.copy) {
-              const src = join54(repoWt.dir, f);
-              if (!existsSync50(src) || existsSync50(join54(path, f))) continue;
-              mkdirSync38(dirOf2(join54(path, f)), { recursive: true });
-              copyFileSync2(src, join54(path, f));
+              const src = join55(repoWt.dir, f);
+              if (!existsSync50(src) || existsSync50(join55(path, f))) continue;
+              mkdirSync38(dirOf2(join55(path, f)), { recursive: true });
+              copyFileSync2(src, join55(path, f));
             }
             const setup = repoWt.config.hooks.setup;
             return setup ? runScript(setup, { cwd: path, shell: shellWt }) : null;
@@ -28768,10 +28818,10 @@ ${where.join("\n")}`);
           },
           prepare: async (path) => {
             for (const f of repoP.config.worktrees.copy) {
-              const src = join54(repoP.dir, f);
+              const src = join55(repoP.dir, f);
               if (!existsSync50(src)) continue;
-              mkdirSync38(dirOf2(join54(path, f)), { recursive: true });
-              copyFileSync2(src, join54(path, f));
+              mkdirSync38(dirOf2(join55(path, f)), { recursive: true });
+              copyFileSync2(src, join55(path, f));
             }
             const setup = repoP.config.hooks.setup;
             return setup ? runScript(setup, { cwd: path, shell: shellP, onLine: (l) => {
@@ -29081,7 +29131,7 @@ ${where.join("\n")}`);
       };
       const droppedRoutes = [];
       try {
-        const rawCfg = parseYaml2(readFileSync45(cfg.configFile, "utf8"));
+        const rawCfg = parseYaml2(readFileSync46(cfg.configFile, "utf8"));
         for (const r of rawCfg?.routes ?? []) {
           if (typeof r?.route !== "string" || cfg.routes.some((x) => x.route === r.route)) continue;
           try {
@@ -29200,7 +29250,7 @@ ${where.join("\n")}`);
     }
     case "log": {
       try {
-        const text2 = readFileSync45(cfg.ship.logFile, "utf8").split("\n");
+        const text2 = readFileSync46(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text2.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -29223,7 +29273,7 @@ ${where.join("\n")}`);
       };
       if (!route2.resolved) fail2(`route ${route2.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route2, cfg.ship);
-      const configText = readFileSync45(cfg.configFile, "utf8");
+      const configText = readFileSync46(cfg.configFile, "utf8");
       const cfgBase = dirname33(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]);
@@ -29261,19 +29311,19 @@ ${where.join("\n")}`);
         if (row) {
           await tracker.deleteRepoRow(row.id);
           if (existsSync50(resolvedFile)) {
-            const raw = JSON.parse(readFileSync45(resolvedFile, "utf8"));
+            const raw = JSON.parse(readFileSync46(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
             writeFileSync38(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        if (existsSync50(join54(dir, ".git")) && basename16(dir) === SAMPLE_REPO) rmSync25(dir, { recursive: true, force: true });
+        if (existsSync50(join55(dir, ".git")) && basename16(dir) === SAMPLE_REPO) rmSync25(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 = !existsSync50(join54(dir, ".git"));
+      const fresh = !existsSync50(join55(dir, ".git"));
       if (existsSync50(dir) && fresh && readdirSync20(dir).length > 0) fail2(`${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`);
@@ -29281,8 +29331,8 @@ ${where.join("\n")}`);
       }
       if (fresh) {
         mkdirSync38(dir, { recursive: true });
-        writeFileSync38(join54(dir, "README.md"), SAMPLE_README);
-        writeFileSync38(join54(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        writeFileSync38(join55(dir, "README.md"), SAMPLE_README);
+        writeFileSync38(join55(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync11("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail2(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -29301,7 +29351,7 @@ ${where.join("\n")}`);
         });
         repoId = (await tracker.createRepoRow(payload)).id;
         if (existsSync50(resolvedFile)) {
-          const raw = JSON.parse(readFileSync45(resolvedFile, "utf8"));
+          const raw = JSON.parse(readFileSync46(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
           writeFileSync38(resolvedFile, `${JSON.stringify(raw, null, 2)}
@@ -29695,6 +29745,7 @@ watermark:  ${state.watermark()}
               base: doctorBaseReport(r, r.config.branch.base, baseHealth),
               hooks: r.config.hooks,
               onPath: (cmd) => !!findOnPath(cmd, doctorSchedulerPath),
+              mapFile: mapFilePath(r.config.hooks.map) ? inspectMapFile(r.dir, mapFilePath(r.config.hooks.map)) : void 0,
               intelSyntax: r.config.hooks.intel && !intelFlavor(r.config.hooks.intel) ? checkHookSyntax(r.config.hooks.intel, r.config.shell) : void 0,
               intelFlavor: intelFlavor(r.config.hooks.intel) ? { name: intelFlavor(r.config.hooks.intel), missing: [
                 ...missingPrerequisites(intelFlavor(r.config.hooks.intel), (bin) => !!findOnPath(bin, doctorSchedulerPath)),
@@ -29762,7 +29813,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 readFileSync45(p, "utf8");
+            return readFileSync46(p, "utf8");
           } catch {
             return null;
           }