@tablation/crew 0.115.0 → 0.117.0

package/dist/cli.js

@@ -125,19 +125,20 @@ function excludeFile(worktree) {
     return void 0;
   }
 }
+function excludeFromGit(worktree, entry) {
+  const ex = excludeFile(worktree);
+  if (!ex) return;
+  mkdirSync(dirname(ex), { recursive: true });
+  const have = existsSync2(ex) ? readFileSync(ex, "utf8") : "";
+  if (have.split("\n").some((l) => l.trim() === entry)) return;
+  appendFileSync(ex, `${have === "" || have.endsWith("\n") ? "" : "\n"}${entry}
+`);
+}
 function prepareDropFile(worktree) {
   const file = pointedAtFile(worktree);
   mkdirSync(dirname(file), { recursive: true });
   if (!existsSync2(file)) writeFileSync(file, "");
-  const ex = excludeFile(worktree);
-  if (ex) {
-    mkdirSync(dirname(ex), { recursive: true });
-    const have = existsSync2(ex) ? readFileSync(ex, "utf8") : "";
-    if (!have.split("\n").some((l) => l.trim() === `${POINTED_AT_DIR}/`)) {
-      appendFileSync(ex, `${have === "" || have.endsWith("\n") ? "" : "\n"}${POINTED_AT_DIR}/
-`);
-    }
-  }
+  excludeFromGit(worktree, `${POINTED_AT_DIR}/`);
   return file;
 }
 function parseLine(raw) {
@@ -180,15 +181,160 @@ function dropFileMtime(worktree) {
   }
 }
 
+// src/intel-register.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/intel.ts
+var INTEL_MINIMUM_TOOLS = [
+  "find symbols by name",
+  "references to a symbol",
+  "a symbol's definition",
+  "a file's symbol outline"
+];
+var INTEL_SERVER_NAME = "code";
+var lastUrl = (output) => {
+  const last = output.split("\n").map((l) => l.trim()).filter(Boolean).pop();
+  return last && /^https?:\/\/\S+$/i.test(last) ? last : void 0;
+};
+var oneLine = (s) => s.replace(/\s+/g, " ").trim().slice(0, 200);
+async function rpcResult(res) {
+  const text2 = await res.text();
+  const body = (res.headers.get("content-type") ?? "").includes("text/event-stream") ? text2.split("\n").find((l) => l.startsWith("data:"))?.slice(5).trim() ?? "" : text2;
+  const msg = JSON.parse(body);
+  if (msg.error) throw new Error(msg.error.message ?? "MCP error");
+  return msg.result;
+}
+async function initializeAndList(url, f, signal) {
+  const headers = { "content-type": "application/json", accept: "application/json, text/event-stream" };
+  const init = await f(url, {
+    method: "POST",
+    headers,
+    signal,
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "initialize",
+      params: { protocolVersion: "2025-03-26", capabilities: {}, clientInfo: { name: "crew", version: "0" } }
+    })
+  });
+  if (!init.ok) throw new Error(`initialize answered ${init.status}`);
+  await rpcResult(init);
+  const session = init.headers.get("mcp-session-id");
+  const sessionHeaders = session ? { ...headers, "mcp-session-id": session } : headers;
+  await f(url, { method: "POST", headers: sessionHeaders, signal, body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) }).then((r) => r.body?.cancel()).catch(() => {
+  });
+  const list = await f(url, { method: "POST", headers: sessionHeaders, signal, body: JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list" }) });
+  if (!list.ok) throw new Error(`tools/list answered ${list.status}`);
+  const result = await rpcResult(list);
+  return (result?.tools ?? []).map((t) => String(t.name)).filter(Boolean);
+}
+async function probeIntel(deps, env, startupSeconds) {
+  let ran;
+  try {
+    ran = await deps.runHook(env);
+  } catch (e) {
+    return { state: "failed", reason: `the intel hook could not run: ${oneLine(e.message)}` };
+  }
+  if (!ran) return { state: "absent" };
+  if (ran.code !== 0) return { state: "failed", reason: `the intel hook exited ${ran.code}${ran.output.trim() ? `: ${oneLine(ran.output.trim().split("\n").pop() ?? "")}` : ""}` };
+  const url = lastUrl(ran.output);
+  if (!url) return { state: "failed", reason: "the intel hook printed no URL as its last line" };
+  const f = deps.fetch ?? fetch;
+  const sleep = deps.sleep ?? ((ms3) => new Promise((r) => setTimeout(r, ms3)));
+  const now = deps.now ?? Date.now;
+  const deadline = now() + startupSeconds * 1e3;
+  let last = "no answer";
+  for (; ; ) {
+    try {
+      const tools = await initializeAndList(url, f, AbortSignal.timeout(Math.max(1, deadline - now())));
+      return { state: "ready", url, tools };
+    } catch (e) {
+      last = oneLine(e.message);
+    }
+    if (now() >= deadline) break;
+    await sleep(500);
+  }
+  return { state: "failed", reason: `${url} did not answer an MCP initialize within ${startupSeconds}s (${last})` };
+}
+function codeToolsParagraph(outcome, server = INTEL_SERVER_NAME) {
+  if (outcome.state === "absent") return "No symbol service is available for this repository.";
+  if (outcome.state === "failed") return `The symbol service did not start (${outcome.reason}), so none is available for this run.`;
+  return [
+    `The \`${server}\` MCP server serves this repository's symbols from its language server. It offers at least: ${INTEL_MINIMUM_TOOLS.join("; ")}.`,
+    `Tools it advertised: ${outcome.tools.length ? outcome.tools.map((t) => `\`${t}\``).join(", ") : "(none listed)"}.`
+  ].join(" ");
+}
+
+// src/intel-register.ts
+function mergeJsonServer(existing, entry, server) {
+  let doc = {};
+  if (existing !== void 0 && existing.trim() !== "") {
+    const parsed = JSON.parse(existing);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("is not a JSON object");
+    doc = parsed;
+  }
+  const servers = doc.mcpServers;
+  if (servers !== void 0 && (!servers || typeof servers !== "object" || Array.isArray(servers))) throw new Error("has an mcpServers that is not an object");
+  doc.mcpServers = { ...servers, [server]: entry };
+  return `${JSON.stringify(doc, null, 2)}
+`;
+}
+function mergeTomlServer(existing, url, server) {
+  const table2 = `[mcp_servers.${server}]
+url = ${JSON.stringify(url)}
+`;
+  const text2 = existing ?? "";
+  const lines2 = text2.split("\n");
+  const start = lines2.findIndex((l) => l.trim() === `[mcp_servers.${server}]`);
+  if (start < 0) return text2 === "" ? table2 : `${text2}${text2.endsWith("\n") ? "" : "\n"}
+${table2}`;
+  let end = lines2.findIndex((l, i) => i > start && /^\s*\[/.test(l));
+  if (end < 0) end = lines2.length;
+  const keepTail = lines2.slice(end);
+  return [...lines2.slice(0, start), ...table2.trimEnd().split("\n"), ...keepTail.length && keepTail[0] !== "" ? [""] : [], ...keepTail].join("\n");
+}
+function tracked(worktree, rel) {
+  try {
+    execFileSync2("git", ["ls-files", "--error-unmatch", "--", rel], { cwd: worktree, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function registerCodeServer(worktree, url, server = INTEL_SERVER_NAME) {
+  const out = { written: [], skipped: [] };
+  const plans = [
+    [".mcp.json", (old) => mergeJsonServer(old, { type: "http", url }, server)],
+    [".codex/config.toml", (old) => mergeTomlServer(old, url, server)],
+    [".gemini/settings.json", (old) => mergeJsonServer(old, { httpUrl: url }, server)]
+  ];
+  for (const [rel, merge] of plans) {
+    const file = join2(worktree, rel);
+    try {
+      const next = merge(existsSync3(file) ? readFileSync2(file, "utf8") : void 0);
+      mkdirSync2(dirname2(file), { recursive: true });
+      writeFileSync2(file, next);
+      if (tracked(worktree, rel)) execFileSync2("git", ["update-index", "--skip-worktree", "--", rel], { cwd: worktree, stdio: "ignore" });
+      else excludeFromGit(worktree, rel);
+      out.written.push(rel);
+    } catch (e) {
+      out.skipped.push(`${rel} left alone: ${e.message}`);
+    }
+  }
+  return out;
+}
+
 // src/periscope-state.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import { connect } from "net";
-import { join as join2 } from "path";
-var dirOf = (stateDir) => join2(stateDir, "periscopes");
-var fileOf = (stateDir, ticketRecordId) => join2(dirOf(stateDir), `${ticketRecordId}.json`);
+import { join as join3 } from "path";
+var dirOf = (stateDir) => join3(stateDir, "periscopes");
+var fileOf = (stateDir, ticketRecordId) => join3(dirOf(stateDir), `${ticketRecordId}.json`);
 function writePeriscopeSidecar(stateDir, sc) {
-  mkdirSync2(dirOf(stateDir), { recursive: true });
-  writeFileSync2(fileOf(stateDir, sc.ticketRecordId), `${JSON.stringify(sc, null, 2)}
+  mkdirSync3(dirOf(stateDir), { recursive: true });
+  writeFileSync3(fileOf(stateDir, sc.ticketRecordId), `${JSON.stringify(sc, null, 2)}
 `);
 }
 function removePeriscopeSidecar(stateDir, ticketRecordId) {
@@ -196,12 +342,12 @@ function removePeriscopeSidecar(stateDir, ticketRecordId) {
 }
 function readPeriscopeSidecars(stateDir) {
   const dir = dirOf(stateDir);
-  if (!existsSync3(dir)) return [];
+  if (!existsSync4(dir)) return [];
   const out = [];
   for (const name of readdirSync(dir)) {
     if (!name.endsWith(".json")) continue;
     try {
-      const sc = JSON.parse(readFileSync2(join2(dir, name), "utf8"));
+      const sc = JSON.parse(readFileSync3(join3(dir, name), "utf8"));
       if (sc && typeof sc.ticketRecordId === "string" && typeof sc.url === "string") out.push(sc);
     } catch {
     }
@@ -319,23 +465,23 @@ function shellInitScript(shell) {
 }
 
 // src/config.ts
-import { readFileSync as readFileSync12, existsSync as existsSync11 } from "fs";
-import { resolve as resolve2, dirname as dirname5, isAbsolute as isAbsolute2, join as join13, basename as basename4 } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync12 } from "fs";
+import { resolve as resolve2, dirname as dirname6, isAbsolute as isAbsolute2, join as join14, basename as basename4 } from "path";
 import { homedir as homedir6, tmpdir } from "os";
 import { parse as parse2 } from "yaml";
 
 // src/events.ts
 import {
   appendFileSync as appendFileSync2,
-  mkdirSync as mkdirSync3,
-  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  existsSync as existsSync5,
   statSync as statSync2,
   renameSync,
   openSync,
   closeSync,
   rmSync as rmSync2
 } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
+import { join as join4, dirname as dirname3 } from "path";
 function render(e) {
   const scope = e.role ? `${e.step}[${e.role}]` : e.step;
   const ticket = e.ticket ? ` ${e.ticket}` : "";
@@ -347,7 +493,7 @@ var ROTATED_EVENTS_RE = /^events\.\d{8}T\d{6}Z(?:-\d+)?\.jsonl$/;
 var ROTATE_LOCK_STALE_MS = 6e4;
 function rotateEventsFile(file, maxBytes, now = /* @__PURE__ */ new Date()) {
   try {
-    if (!existsSync4(file) || statSync2(file).size <= maxBytes) return void 0;
+    if (!existsSync5(file) || statSync2(file).size <= maxBytes) return void 0;
   } catch {
     return void 0;
   }
@@ -367,8 +513,8 @@ function rotateEventsFile(file, maxBytes, now = /* @__PURE__ */ new Date()) {
     try {
       if (statSync2(file).size <= maxBytes) return void 0;
       const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
-      let dest = join3(dirname2(file), `events.${stamp}.jsonl`);
-      for (let n = 1; existsSync4(dest); n++) dest = join3(dirname2(file), `events.${stamp}-${n}.jsonl`);
+      let dest = join4(dirname3(file), `events.${stamp}.jsonl`);
+      for (let n = 1; existsSync5(dest); n++) dest = join4(dirname3(file), `events.${stamp}-${n}.jsonl`);
       renameSync(file, dest);
       return dest;
     } finally {
@@ -391,7 +537,7 @@ var Emitter = class _Emitter {
     for (const f of [opts.eventFile, opts.logFile]) {
       if (!f) continue;
       try {
-        mkdirSync3(dirname2(f), { recursive: true });
+        mkdirSync4(dirname3(f), { recursive: true });
       } catch {
       }
     }
@@ -467,18 +613,18 @@ var Emitter = class _Emitter {
     }
   }
 };
-var eventFileFor = (stateDir) => join3(stateDir, "events.jsonl");
+var eventFileFor = (stateDir) => join4(stateDir, "events.jsonl");
 
 // src/pair-install.ts
-import { existsSync as existsSync7, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync8, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
 import { homedir as homedir5 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/adapters/claude.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/stream.ts
 function toolTarget(name, input) {
@@ -537,19 +683,19 @@ function extractResult(line) {
 
 // src/claude-mcp.ts
 import { spawnSync } from "child_process";
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { homedir } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/mcp-registrations.ts
 import { createHash } from "crypto";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
-var fileFor = (stateDir) => join4(stateDir, "mcp-registrations.json");
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
+var fileFor = (stateDir) => join5(stateDir, "mcp-registrations.json");
 var keyFingerprint = (key) => createHash("sha256").update(key).digest("hex").slice(0, 8);
 function readMcpRegistrations(stateDir) {
   try {
-    const j = JSON.parse(readFileSync4(fileFor(stateDir), "utf8"));
+    const j = JSON.parse(readFileSync5(fileFor(stateDir), "utf8"));
     return Array.isArray(j) ? j : [];
   } catch {
     return [];
@@ -557,8 +703,8 @@ function readMcpRegistrations(stateDir) {
 }
 function recordMcpRegistration(stateDir, r, now = /* @__PURE__ */ new Date()) {
   const rest = readMcpRegistrations(stateDir).filter((x) => !(x.harness === r.harness && x.scope === r.scope && x.name === r.name));
-  mkdirSync4(stateDir, { recursive: true });
-  writeFileSync3(fileFor(stateDir), `${JSON.stringify([...rest, { ...r, at: now.toISOString() }], null, 2)}
+  mkdirSync5(stateDir, { recursive: true });
+  writeFileSync4(fileFor(stateDir), `${JSON.stringify([...rest, { ...r, at: now.toISOString() }], null, 2)}
 `, { mode: 384 });
 }
 function findMcpRegistration(stateDir, r) {
@@ -581,7 +727,7 @@ function runClaude(bin, args) {
 }
 function userScopeEntry(home) {
   try {
-    const j = JSON.parse(readFileSync5(join5(home, ".claude.json"), "utf8"));
+    const j = JSON.parse(readFileSync6(join6(home, ".claude.json"), "utf8"));
     return j.mcpServers?.[MCP_SERVER_NAME];
   } catch {
     return void 0;
@@ -665,8 +811,8 @@ function removeClaudeMcp(o) {
 }
 
 // src/launcher.ts
-import { basename, join as join6 } from "path";
-import { existsSync as existsSync5, readFileSync as readFileSync6, readdirSync as readdirSync2 } from "fs";
+import { basename, join as join7 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7, readdirSync as readdirSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 function isOriLauncher(spec) {
   return !!spec.launcher && basename(spec.launcher) === "ori";
@@ -675,7 +821,7 @@ function isOmlxLauncher(spec) {
   return !!spec.launcher && basename(spec.launcher) === "omlx";
 }
 function defaultOmlxBin(home = homedir2()) {
-  return join6(home, ".omlx", "bin", "omlx");
+  return join7(home, ".omlx", "bin", "omlx");
 }
 function launcherExecutable(spec, home) {
   if (!spec.launcher) return void 0;
@@ -728,8 +874,8 @@ function omlxModelPresent(model, dirs) {
   });
 }
 function readOmlxSettings(home = homedir2()) {
-  const p = join6(home, ".omlx", "settings.json");
-  return existsSync5(p) ? parseOmlxSettings(readFileSync6(p, "utf8")) : void 0;
+  const p = join7(home, ".omlx", "settings.json");
+  return existsSync6(p) ? parseOmlxSettings(readFileSync7(p, "utf8")) : void 0;
 }
 
 // src/capability.ts
@@ -793,7 +939,7 @@ function describeClaudeAuth(spec, env = process.env, home = homedir3()) {
   if (spec.auth === "workspace") return `workspace${spec.inference ? ` (${new URL(spec.inference.baseUrl).host})` : " (endpoint resolved per route at run time)"}`;
   let fromSettings;
   try {
-    const parsed = JSON.parse(readFileSync7(join7(home, ".claude", "settings.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync8(join8(home, ".claude", "settings.json"), "utf8"));
     const e = parsed.env ?? {};
     const on = (k) => e[k] !== void 0 && e[k] !== "" && e[k] !== "0";
     if (on("CLAUDE_CODE_USE_VERTEX")) fromSettings = "vertex from ~/.claude/settings.json";
@@ -897,12 +1043,12 @@ var claudeAdapter = {
 // src/adapters/codex.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { homedir as homedir4 } from "os";
-import { join as join8 } from "path";
-import { rmSync as rmSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join9 } from "path";
+import { rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
 
 // src/pair-files.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync4, rmSync as rmSync3 } from "fs";
-import { dirname as dirname3 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync5, rmSync as rmSync3 } from "fs";
+import { dirname as dirname4 } from "path";
 var PAIR_BLOCK_START = "<!-- crew:pair start -->";
 var PAIR_BLOCK_END = "<!-- crew:pair end -->";
 var PAIR_KEY_VAR = "CREW_API_KEY";
@@ -942,11 +1088,11 @@ function removePairBlock(text2) {
   return text2.replace(new RegExp(`\\n*${BLOCK_RE.source}`), "\n").replace(/^\n+/, "").replace(/\n{3,}/g, "\n\n");
 }
 function readIfExists(path) {
-  return existsSync6(path) ? readFileSync8(path, "utf8") : void 0;
+  return existsSync7(path) ? readFileSync9(path, "utf8") : void 0;
 }
 function writeFileMkdir(path, text2) {
-  mkdirSync5(dirname3(path), { recursive: true });
-  writeFileSync4(path, text2);
+  mkdirSync6(dirname4(path), { recursive: true });
+  writeFileSync5(path, text2);
 }
 function installBlockFile(path, harness, dryRun) {
   const before = readIfExists(path) ?? "";
@@ -962,7 +1108,7 @@ function removeBlockFile(path, dryRun) {
   if (dryRun) return true;
   const after = removePairBlock(before);
   if (after.trim() === "") rmSync3(path);
-  else writeFileSync4(path, after);
+  else writeFileSync5(path, after);
   return true;
 }
 function blockVerdict(path, harness) {
@@ -1089,8 +1235,8 @@ function codexTable(url) {
   return [`[mcp_servers.${SERVER}]`, `url = ${tomlString(url)}`, `bearer_token_env_var = ${tomlString(PAIR_KEY_VAR)}`];
 }
 var codexPaths = (home) => ({
-  instructions: join8(home, ".codex", "AGENTS.md"),
-  config: join8(home, ".codex", "config.toml")
+  instructions: join9(home, ".codex", "AGENTS.md"),
+  config: join9(home, ".codex", "config.toml")
 });
 function codexMcpState(config, url) {
   const lines2 = config.split("\n");
@@ -1141,7 +1287,7 @@ var codexPair = {
     if (hadMcp && !o.dryRun) {
       const after = removeTomlTable(config, `mcp_servers.${SERVER}`);
       if (after === "") rmSync4(p.config);
-      else writeFileSync5(p.config, after);
+      else writeFileSync6(p.config, after);
     }
     const what = hadBlock && hadMcp ? `the Pair block and ${SERVER} server` : hadBlock ? "the Pair block" : `the ${SERVER} server`;
     return hadBlock || hadMcp ? `pair(codex): ${o.dryRun ? "(dry run) would remove" : "removed"} ${what}${kept}` : `pair(codex): nothing to remove${kept}`;
@@ -1237,8 +1383,8 @@ var codexAdapter = {
 
 // src/pair-install.ts
 var geminiPaths = (home) => ({
-  instructions: join9(home, ".gemini", "GEMINI.md"),
-  config: join9(home, ".gemini", "settings.json")
+  instructions: join10(home, ".gemini", "GEMINI.md"),
+  config: join10(home, ".gemini", "settings.json")
 });
 function readGeminiSettings(path) {
   const text2 = readIfExists(path);
@@ -1326,7 +1472,7 @@ var geminiPair = {
       if (Object.keys(rest).length > 0) next.mcpServers = rest;
       else delete next.mcpServers;
       if (Object.keys(next).length === 0) rmSync5(p.config);
-      else writeFileSync6(p.config, `${JSON.stringify(next, null, 2)}
+      else writeFileSync7(p.config, `${JSON.stringify(next, null, 2)}
 `);
     }
     const what = hadBlock && hadMcp ? `the Pair block and ${SERVER} server` : hadBlock ? "the Pair block" : `the ${SERVER} server`;
@@ -1337,9 +1483,9 @@ var VSCODE_FLAVOURS = ["Code", "Code - Insiders"];
 function vscodeUserDirs(o) {
   const home = o.home ?? homedir5();
   const platform2 = o.platform ?? process.platform;
-  const root = platform2 === "darwin" ? join9(home, "Library", "Application Support") : platform2 === "win32" ? process.env.APPDATA ?? join9(home, "AppData", "Roaming") : join9(home, ".config");
-  const all = VSCODE_FLAVOURS.map((f) => join9(root, f, "User"));
-  const present = all.filter((d) => existsSync7(d));
+  const root = platform2 === "darwin" ? join10(home, "Library", "Application Support") : platform2 === "win32" ? process.env.APPDATA ?? join10(home, "AppData", "Roaming") : join10(home, ".config");
+  const all = VSCODE_FLAVOURS.map((f) => join10(root, f, "User"));
+  const present = all.filter((d) => existsSync8(d));
   return present.length > 0 ? present : [all[0]];
 }
 var COPILOT_FRONTMATTER = '---\napplyTo: "**"\n---\n\n';
@@ -1377,7 +1523,7 @@ function removeCopilotInstructions(path, dryRun) {
   if (dryRun) return true;
   const after = removePairBlock(before);
   if (after.trim() === "" || after.trim() === COPILOT_FRONTMATTER.trim()) rmSync5(path);
-  else writeFileSync6(path, after);
+  else writeFileSync7(path, after);
   return true;
 }
 var copilotPair = {
@@ -1386,8 +1532,8 @@ var copilotPair = {
   installPair(o) {
     const lines2 = [];
     for (const dir of vscodeUserDirs(o)) {
-      const mcpPath = join9(dir, "mcp.json");
-      const instrPath = join9(dir, "prompts", "crew-pair.instructions.md");
+      const mcpPath = join10(dir, "mcp.json");
+      const instrPath = join10(dir, "prompts", "crew-pair.instructions.md");
       const settings = readVscodeMcp(mcpPath);
       if (!settings) {
         lines2.push(`pair(copilot): ${mcpPath} is not a plain JSON object (comments are not supported) \u2014 fix it by hand; nothing was written there`);
@@ -1415,8 +1561,8 @@ var copilotPair = {
   },
   verifyPair(o) {
     const verdicts = vscodeUserDirs(o).map((dir) => {
-      const instrPath = join9(dir, "prompts", "crew-pair.instructions.md");
-      const mcpPath = join9(dir, "mcp.json");
+      const instrPath = join10(dir, "prompts", "crew-pair.instructions.md");
+      const mcpPath = join10(dir, "mcp.json");
       const b = blockVerdict(instrPath, "copilot");
       if (!b.ok) return b;
       const settings = readVscodeMcp(mcpPath);
@@ -1431,8 +1577,8 @@ var copilotPair = {
   removePair(o) {
     const lines2 = [];
     for (const dir of vscodeUserDirs(o)) {
-      const mcpPath = join9(dir, "mcp.json");
-      const hadBlock = removeCopilotInstructions(join9(dir, "prompts", "crew-pair.instructions.md"), o.dryRun);
+      const mcpPath = join10(dir, "mcp.json");
+      const hadBlock = removeCopilotInstructions(join10(dir, "prompts", "crew-pair.instructions.md"), o.dryRun);
       const settings = readVscodeMcp(mcpPath);
       const st = settings ? copilotMcpState(settings, o.url) : { state: "missing" };
       const hadMcp = st.state === "registered";
@@ -1443,7 +1589,7 @@ var copilotPair = {
         if (Object.keys(rest).length > 0) next.servers = rest;
         else delete next.servers;
         if (Object.keys(next).length === 0) rmSync5(mcpPath);
-        else writeFileSync6(mcpPath, `${JSON.stringify(next, null, 2)}
+        else writeFileSync7(mcpPath, `${JSON.stringify(next, null, 2)}
 `);
       }
       const what = hadBlock && hadMcp ? `the Pair instructions and ${SERVER} server` : hadBlock ? "the Pair instructions" : `the ${SERVER} server`;
@@ -1692,9 +1838,9 @@ function resolveSeat(ship, route2, role, persona = {}, repo) {
 }
 
 // src/forges.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync9, rmSync as rmSync6, statSync as statSync3, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname4, join as join10 } from "path";
+import { execFileSync as execFileSync3 } from "child_process";
+import { chmodSync, existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync10, rmSync as rmSync6, statSync as statSync3, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname5, join as join11 } from "path";
 var ForgeError = class extends Error {
 };
 var DEFAULT_FORGE_USERNAME = "x-access-token";
@@ -1722,7 +1868,7 @@ function forgeDescriptorFor(host) {
 }
 var DEFAULT_KEYCHAIN_SERVICE = "crew-forge";
 function defaultTokenFilePath(stateDir, host) {
-  return join10(stateDir, "forges", `${host.replace(/[^a-z0-9.-]/gi, "_")}.token`);
+  return join11(stateDir, "forges", `${host.replace(/[^a-z0-9.-]/gi, "_")}.token`);
 }
 var envSource = {
   read: (s, c) => c.env[s.var]?.trim() || null,
@@ -1731,19 +1877,19 @@ var envSource = {
 var fileSource = {
   read(s, c) {
     const path = s.path ?? defaultTokenFilePath(c.stateDir, c.host);
-    if (!existsSync8(path)) return null;
+    if (!existsSync9(path)) return null;
     const mode = statSync3(path).mode & 511;
     if (mode & 63) {
       throw new ForgeError(
         `${path} is mode ${mode.toString(8).padStart(3, "0")}; a forge token file must be owner-only (chmod 600 ${path})`
       );
     }
-    return readFileSync9(path, "utf8").trim() || null;
+    return readFileSync10(path, "utf8").trim() || null;
   },
   write(s, token, c) {
     const path = s.path ?? defaultTokenFilePath(c.stateDir, c.host);
-    mkdirSync6(dirname4(path), { recursive: true, mode: 448 });
-    writeFileSync7(path, `${token}
+    mkdirSync7(dirname5(path), { recursive: true, mode: 448 });
+    writeFileSync8(path, `${token}
 `, { mode: 384 });
     chmodSync(path, 384);
   },
@@ -1757,13 +1903,13 @@ var keychainSource = {
   read(s, c) {
     try {
       if (process.platform === "darwin") {
-        return execFileSync2(
+        return execFileSync3(
           "security",
           ["find-generic-password", "-s", keychainService(s), "-a", c.host, "-w"],
           { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
         ).trim() || null;
       }
-      return execFileSync2(
+      return execFileSync3(
         "secret-tool",
         ["lookup", "service", keychainService(s), "account", c.host],
         { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
@@ -1776,13 +1922,13 @@ var keychainSource = {
     try {
       if (process.platform === "darwin") {
         const q2 = (v) => `"${v.replace(/(["\\])/g, "\\$1")}"`;
-        execFileSync2("security", ["-i"], {
+        execFileSync3("security", ["-i"], {
           input: `add-generic-password -U -s ${q2(keychainService(s))} -a ${q2(c.host)} -w ${q2(token)}
 `,
           stdio: ["pipe", "ignore", "pipe"]
         });
       } else {
-        execFileSync2(
+        execFileSync3(
           "secret-tool",
           ["store", "--label", `crew ${c.host}`, "service", keychainService(s), "account", c.host],
           { input: token, stdio: ["pipe", "ignore", "pipe"] }
@@ -1795,9 +1941,9 @@ var keychainSource = {
   erase(s, c) {
     try {
       if (process.platform === "darwin") {
-        execFileSync2("security", ["delete-generic-password", "-s", keychainService(s), "-a", c.host], { stdio: "ignore" });
+        execFileSync3("security", ["delete-generic-password", "-s", keychainService(s), "-a", c.host], { stdio: "ignore" });
       } else {
-        execFileSync2("secret-tool", ["clear", "service", keychainService(s), "account", c.host], { stdio: "ignore" });
+        execFileSync3("secret-tool", ["clear", "service", keychainService(s), "account", c.host], { stdio: "ignore" });
       }
     } catch {
     }
@@ -1877,10 +2023,10 @@ function answerCredential(action, input, forges, stateDir, env = process.env) {
 password=${token}
 `;
 }
-var missesPath = (stateDir) => join10(stateDir, "forge-misses.json");
+var missesPath = (stateDir) => join11(stateDir, "forge-misses.json");
 function readForgeMisses(stateDir) {
   try {
-    const raw = JSON.parse(readFileSync9(missesPath(stateDir), "utf8"));
+    const raw = JSON.parse(readFileSync10(missesPath(stateDir), "utf8"));
     return Object.entries(raw).filter(([, t]) => typeof t === "string").map(([host, lastMissAt]) => ({ host, lastMissAt })).sort((a, b) => a.host.localeCompare(b.host));
   } catch {
     return [];
@@ -1895,8 +2041,8 @@ function noteForgeMiss(stateDir, host, at) {
       if (!(bare in cur)) return;
       delete cur[bare];
     } else cur[bare] = at;
-    mkdirSync6(stateDir, { recursive: true });
-    writeFileSync7(missesPath(stateDir), JSON.stringify(cur), { mode: 384 });
+    mkdirSync7(stateDir, { recursive: true });
+    writeFileSync8(missesPath(stateDir), JSON.stringify(cur), { mode: 384 });
   } catch {
   }
 }
@@ -1998,8 +2144,8 @@ import { hostFromUrl } from "@tablation/client";
 
 // src/secret-store.ts
 import { createHash as createHash2 } from "crypto";
-import { accessSync, constants, existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync10, renameSync as renameSync2, rmSync as rmSync7, statSync as statSync4, writeFileSync as writeFileSync8, chmodSync as chmodSync2 } from "fs";
-import { join as join11 } from "path";
+import { accessSync, constants, existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync11, renameSync as renameSync2, rmSync as rmSync7, statSync as statSync4, writeFileSync as writeFileSync9, chmodSync as chmodSync2 } from "fs";
+import { join as join12 } from "path";
 import { getSessionStore as getOsSessionStore } from "@tablation/client";
 var SECRET_STORE_MODES = ["auto", "os", "file"];
 function isSecretStoreMode(v) {
@@ -2010,7 +2156,7 @@ function configureSecretStore(c) {
   configured = c;
 }
 function keysDir(stateDir) {
-  return join11(stateDir, "keys");
+  return join12(stateDir, "keys");
 }
 function entryName(host, slug2) {
   return `${createHash2("sha256").update(`${host}\0${slug2}`).digest("hex")}.json`;
@@ -2021,34 +2167,34 @@ var FileSessionStore = class {
     this.dir = dir;
   }
   ensureDir() {
-    mkdirSync7(this.dir, { recursive: true, mode: 448 });
+    mkdirSync8(this.dir, { recursive: true, mode: 448 });
     if ((statSync4(this.dir).mode & 63) !== 0) chmodSync2(this.dir, 448);
   }
   async get(host, slug2) {
-    const file = join11(this.dir, entryName(host, slug2));
-    if (!existsSync9(this.dir)) return void 0;
+    const file = join12(this.dir, entryName(host, slug2));
+    if (!existsSync10(this.dir)) return void 0;
     accessSync(this.dir, constants.R_OK | constants.X_OK);
-    if (!existsSync9(file)) return void 0;
-    return JSON.parse(readFileSync10(file, "utf8"));
+    if (!existsSync10(file)) return void 0;
+    return JSON.parse(readFileSync11(file, "utf8"));
   }
   async set(host, slug2, session) {
     this.ensureDir();
-    const file = join11(this.dir, entryName(host, slug2));
+    const file = join12(this.dir, entryName(host, slug2));
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync8(tmp, JSON.stringify(session), { mode: 384 });
+    writeFileSync9(tmp, JSON.stringify(session), { mode: 384 });
     renameSync2(tmp, file);
   }
   async clear(host, slug2) {
-    if (!existsSync9(this.dir)) return;
-    rmSync7(join11(this.dir, entryName(host, slug2)), { force: true });
+    if (!existsSync10(this.dir)) return;
+    rmSync7(join12(this.dir, entryName(host, slug2)), { force: true });
   }
   /** Whether a key could be written here right now, without leaving anything behind. */
   writable() {
     try {
       this.ensureDir();
       accessSync(this.dir, constants.R_OK | constants.W_OK | constants.X_OK);
-      const probe = join11(this.dir, `.probe.${process.pid}`);
-      writeFileSync8(probe, "", { mode: 384 });
+      const probe = join12(this.dir, `.probe.${process.pid}`);
+      writeFileSync9(probe, "", { mode: 384 });
       rmSync7(probe, { force: true });
       return { ok: true };
     } catch (e) {
@@ -2099,11 +2245,11 @@ function osStoreReachable(env = process.env, platform2 = process.platform, hasBi
   if (platform2 !== "linux") return true;
   if (!hasBinary("secret-tool")) return false;
   if (env.DBUS_SESSION_BUS_ADDRESS) return true;
-  return !!env.XDG_RUNTIME_DIR && existsSync9(join11(env.XDG_RUNTIME_DIR, "bus"));
+  return !!env.XDG_RUNTIME_DIR && existsSync10(join12(env.XDG_RUNTIME_DIR, "bus"));
 }
 function onPath(name) {
   for (const dir of (process.env.PATH ?? "").split(":")) {
-    if (dir && existsSync9(join11(dir, name))) return true;
+    if (dir && existsSync10(join12(dir, name))) return true;
   }
   return false;
 }
@@ -2170,8 +2316,8 @@ function explain(ship, required) {
 }
 
 // src/repo-config.ts
-import { readFileSync as readFileSync11, existsSync as existsSync10 } from "fs";
-import { join as join12, basename as basename3 } from "path";
+import { readFileSync as readFileSync12, existsSync as existsSync11 } from "fs";
+import { join as join13, basename as basename3 } from "path";
 import { parse } from "yaml";
 
 // src/sandbox-policy.ts
@@ -2382,6 +2528,8 @@ var HOOK_NAMES = [
   "isolate",
   "handoff",
   "preview",
+  "intel",
+  "map",
   "ci_status",
   "version",
   "bump",
@@ -2452,8 +2600,8 @@ var MODES = ["local", "integrate", "ci_manual", "ci_auto", "external"];
 var PROVIDERS = ["github", "buildkite", "other", "none"];
 function findRepoConfig(dir) {
   for (const name of REPO_CONFIG_FILENAMES) {
-    const p = join12(dir, name);
-    if (existsSync10(p)) return p;
+    const p = join13(dir, name);
+    if (existsSync11(p)) return p;
   }
   return null;
 }
@@ -2733,7 +2881,7 @@ function parseRepoConfig(text2, file) {
 function loadRepoConfig(dir) {
   const file = findRepoConfig(dir);
   if (!file) return null;
-  return parseRepoConfig(readFileSync11(file, "utf8"), file);
+  return parseRepoConfig(readFileSync12(file, "utf8"), file);
 }
 function hookLabel(cfg, hook2) {
   return cfg.labels[hook2] ?? cfg.hooks[hook2] ?? hook2;
@@ -3014,6 +3162,8 @@ var ConfigError = class extends Error {
 };
 var DEFAULT_MAX_PERISCOPES = 3;
 var DEFAULT_PERISCOPE_IDLE_MINUTES = 120;
+var DEFAULT_INTEL_STARTUP_SECONDS = 20;
+var DEFAULT_MAP_TOKEN_BUDGET = 1e3;
 function parseCloneScheme(v) {
   if (v === void 0 || v === null || v === "") return void 0;
   if (v === "ssh" || v === "https") return v;
@@ -3106,6 +3256,8 @@ var SHIP_KEYS = /* @__PURE__ */ new Set([
   "previewHost",
   "maxPeriscopes",
   "periscopeIdleMinutes",
+  "intelStartupSeconds",
+  "mapTokenBudget",
   "secretStore",
   "env",
   "runner",
@@ -3258,11 +3410,11 @@ function expand(p, base) {
   return isAbsolute2(out) ? out : resolve2(base, out);
 }
 function resolvePromptsDir(promptSet, crewHome, base) {
-  if (!promptSet) return join13(crewHome, "prompts", "default");
+  if (!promptSet) return join14(crewHome, "prompts", "default");
   if (promptSet.includes("/") || promptSet.startsWith(".") || promptSet.startsWith("~")) {
     return expand(promptSet, base);
   }
-  return join13(crewHome, "prompts", promptSet);
+  return join14(crewHome, "prompts", promptSet);
 }
 var Missing = class {
   paths = [];
@@ -3286,7 +3438,7 @@ var Missing = class {
 };
 function crewVersion(crewHome) {
   try {
-    const pkg = JSON.parse(readFileSync12(join13(crewHome, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync13(join14(crewHome, "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -3296,26 +3448,26 @@ function configSearchPath(crewHome) {
   if (process.env.CREW_CONFIG) return [resolve2(process.env.CREW_CONFIG)];
   const xdg = process.env.XDG_CONFIG_HOME;
   return [
-    ...xdg ? [join13(xdg, "crew", "crew.yaml")] : [],
-    join13(homedir6(), ".config", "crew", "crew.yaml"),
+    ...xdg ? [join14(xdg, "crew", "crew.yaml")] : [],
+    join14(homedir6(), ".config", "crew", "crew.yaml"),
     resolve2(crewHome, "crew.yaml")
   ];
 }
 function findConfigFile(crewHome) {
   const candidates2 = configSearchPath(crewHome);
-  return candidates2.find((c) => existsSync11(c)) ?? candidates2[candidates2.length - 1];
+  return candidates2.find((c) => existsSync12(c)) ?? candidates2[candidates2.length - 1];
 }
-var defaultConfigPath = () => join13(process.env.XDG_CONFIG_HOME ?? join13(homedir6(), ".config"), "crew", "crew.yaml");
+var defaultConfigPath = () => join14(process.env.XDG_CONFIG_HOME ?? join14(homedir6(), ".config"), "crew", "crew.yaml");
 function routeSlug(route2) {
   return route2.replace(/\//g, "-");
 }
 function resolvedPathFor(stateDir, route2) {
   const [workspace, project] = splitRoute(route2);
-  return join13(stateDir, "resolved", workspace, `${project}.json`);
+  return join14(stateDir, "resolved", workspace, `${project}.json`);
 }
 function apiKeyPathFor(stateDir, route2) {
   const [workspace, project] = splitRoute(route2);
-  return join13(stateDir, "keys", workspace, `${project}.env`);
+  return join14(stateDir, "keys", workspace, `${project}.env`);
 }
 function splitRoute(route2) {
   const parts = route2.split("/");
@@ -3326,9 +3478,9 @@ function splitRoute(route2) {
 }
 function readResolvedFile(stateDir, route2) {
   const path = resolvedPathFor(stateDir, route2);
-  if (!existsSync11(path)) return void 0;
+  if (!existsSync12(path)) return void 0;
   try {
-    return JSON.parse(readFileSync12(path, "utf8"));
+    return JSON.parse(readFileSync13(path, "utf8"));
   } catch (e) {
     throw new ConfigError(`${path}: not valid JSON \u2014 ${e.message}`);
   }
@@ -3389,23 +3541,23 @@ function parseResolved(raw, m, where) {
 }
 function loadConfig(crewHome, configFile, opts = {}) {
   const file = configFile ?? findConfigFile(crewHome);
-  if (opts.text === void 0 && !existsSync11(file)) {
+  if (opts.text === void 0 && !existsSync12(file)) {
     throw new ConfigError(
       `no config found. Looked in:
 ` + configSearchPath(crewHome).map((c) => `  - ${c}`).join("\n") + `
 
 Create the first of those:
-  mkdir -p ${dirname5(defaultConfigPath())} && cp ${join13(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
+  mkdir -p ${dirname6(defaultConfigPath())} && cp ${join14(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
     );
   }
   let raw;
   try {
-    raw = parse2(opts.text ?? readFileSync12(file, "utf8"));
+    raw = parse2(opts.text ?? readFileSync13(file, "utf8"));
   } catch (e) {
     throw new ConfigError(`${file}: not valid YAML \u2014 ${e.message}`);
   }
   if (!raw || typeof raw !== "object") throw new ConfigError(`${file} is empty or not a mapping`);
-  const base = dirname5(file);
+  const base = dirname6(file);
   const missing = new Missing();
   rejectUnknownKeys(raw, /* @__PURE__ */ new Set(["ship", "routes"]), "top-level", file);
   const shipRaw = raw.ship ?? {};
@@ -3454,6 +3606,14 @@ Create the first of those:
   if (!Number.isInteger(periscopeIdleMinutes) || periscopeIdleMinutes < 1) {
     missing.add(`ship.periscopeIdleMinutes must be a positive integer (got "${shipRaw.periscopeIdleMinutes}")`);
   }
+  const intelStartupSeconds = shipRaw.intelStartupSeconds === void 0 ? DEFAULT_INTEL_STARTUP_SECONDS : Number(shipRaw.intelStartupSeconds);
+  if (!Number.isInteger(intelStartupSeconds) || intelStartupSeconds < 1) {
+    missing.add(`ship.intelStartupSeconds must be a positive integer (got "${shipRaw.intelStartupSeconds}")`);
+  }
+  const mapTokenBudget = shipRaw.mapTokenBudget === void 0 ? DEFAULT_MAP_TOKEN_BUDGET : Number(shipRaw.mapTokenBudget);
+  if (!Number.isInteger(mapTokenBudget) || mapTokenBudget < 1) {
+    missing.add(`ship.mapTokenBudget must be a positive integer (got "${shipRaw.mapTokenBudget}")`);
+  }
   const secretStoreRaw = shipRaw.secretStore === void 0 ? "auto" : shipRaw.secretStore;
   if (!isSecretStoreMode(secretStoreRaw)) {
     missing.add(`ship.secretStore must be one of ${SECRET_STORE_MODES.join(" | ")} (got "${String(shipRaw.secretStore)}")`);
@@ -3519,7 +3679,7 @@ Create the first of those:
       useNvm: shipRaw.useNvm !== false,
       nvmSh: shipRaw.nvmSh,
       stateDir,
-      logFile: expand(shipRaw.logFile ?? join13(tmpdir(), "crew.log"), base),
+      logFile: expand(shipRaw.logFile ?? join14(tmpdir(), "crew.log"), base),
       userAgent: shipRaw.userAgent ?? `Mozilla/5.0 CrewAgent/${crewVersion(crewHome)}`,
       maxConcurrentAgents,
       maxConcurrentAgentsSet,
@@ -3537,6 +3697,8 @@ Create the first of those:
       previewHost: shipRaw.previewHost ? String(shipRaw.previewHost).trim() || void 0 : void 0,
       maxPeriscopes,
       periscopeIdleMinutes,
+      intelStartupSeconds,
+      mapTokenBudget,
       secretStore,
       env: parseShipEnv(shipRaw.env)
     },
@@ -3699,7 +3861,7 @@ function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, t
   const hasRepos = Object.keys(repoDirs).length > 0;
   const reposBasePath = expand(String(c?.reposBasePath ?? raw.ship?.reposBasePath ?? DEFAULT_REPOS_BASE_PATH), base);
   const dirIsCloneBase = !c?.dir && !hasRepos && !Array.isArray(c?.repos);
-  const dir = c?.dir ? expand(String(c.dir), base) : hasRepos ? Object.values(repoDirs)[0] : dirIsCloneBase ? join13(reposBasePath, splitRoute(route2)[0]) : "";
+  const dir = c?.dir ? expand(String(c.dir), base) : hasRepos ? Object.values(repoDirs)[0] : dirIsCloneBase ? join14(reposBasePath, splitRoute(route2)[0]) : "";
   const weight = c?.weight === void 0 ? void 0 : Number(c.weight);
   if (weight !== void 0 && !(Number.isFinite(weight) && weight > 0)) {
     missing.add(`${where}.weight must be a positive number (got "${c?.weight}")`);
@@ -3762,7 +3924,7 @@ function locateDir(cfg, dir, commonDirOf) {
   const direct = find(target);
   if (direct) return direct;
   const common = commonDirOf?.(target);
-  return common ? find(dirname5(resolve2(target, common))) : void 0;
+  return common ? find(dirname6(resolve2(target, common))) : void 0;
 }
 function findRoute(cfg, route2) {
   if (!route2) {
@@ -3797,8 +3959,8 @@ function repoIdForName(r, name) {
 }
 function resolveApiKey(r) {
   if (r.apiKey) return r.apiKey;
-  if (r.apiKeyFile && r.apiKeyVar && existsSync11(r.apiKeyFile)) {
-    for (const line of readFileSync12(r.apiKeyFile, "utf8").split("\n")) {
+  if (r.apiKeyFile && r.apiKeyVar && existsSync12(r.apiKeyFile)) {
+    for (const line of readFileSync13(r.apiKeyFile, "utf8").split("\n")) {
       const m = line.match(new RegExp(`^${r.apiKeyVar}=(.*)$`));
       if (m) return (m[1] ?? "").trim().replace(/^["']|["']$/g, "");
     }
@@ -3811,9 +3973,9 @@ function resolveApiKey(r) {
 }
 function credentialSource(r) {
   if (r.apiKey) return KEYCHAIN_ELIGIBLE_ROUTES.has(r) ? "keychain" : "inline";
-  if (r.apiKeyFile && r.apiKeyVar && existsSync11(r.apiKeyFile)) {
+  if (r.apiKeyFile && r.apiKeyVar && existsSync12(r.apiKeyFile)) {
     const re = new RegExp(`^${r.apiKeyVar}=`);
-    if (readFileSync12(r.apiKeyFile, "utf8").split("\n").some((l) => re.test(l))) return "apiKeyFile";
+    if (readFileSync13(r.apiKeyFile, "utf8").split("\n").some((l) => re.test(l))) return "apiKeyFile";
   }
   return process.env.CREW_API_KEY?.trim() ? "CREW_API_KEY" : "none";
 }
@@ -3869,7 +4031,7 @@ function configuredMembers(rt) {
   return out;
 }
 function defaultRepoDir(basePath, workspace, repoName) {
-  return join13(basePath, workspace, repoName);
+  return join14(basePath, workspace, repoName);
 }
 function reposOf(r) {
   const named = Object.entries(r.repos);
@@ -3908,10 +4070,10 @@ function passengerRepoTargets(r) {
   return reposOf(r).filter((t) => r.repoOverrides[t.name]?.hostPassengers !== false);
 }
 function passengerCheckoutDir(basePath, workspace, repoName) {
-  return join13(basePath, workspace, ".passenger-checkouts", repoName);
+  return join14(basePath, workspace, ".passenger-checkouts", repoName);
 }
 function passengerMirrorArea(ship) {
-  return ship.runner === "sandbox" ? join13(ship.stateDir, "passenger-sources") : void 0;
+  return ship.runner === "sandbox" ? join14(ship.stateDir, "passenger-sources") : void 0;
 }
 function passengerCheckoutTargets(r, mirrorArea) {
   if (!r.hostPassengers) return [];
@@ -3922,7 +4084,7 @@ function passengerCheckoutTargets(r, mirrorArea) {
     const forgeHost = t.forgeHost ?? (id ? r.resolved?.repoForgeHosts?.[id] : void 0);
     return {
       name: t.name,
-      dir: mirrorArea ? join13(mirrorArea, workspace, t.name) : passengerCheckoutDir(r.reposBasePath, workspace, t.name),
+      dir: mirrorArea ? join14(mirrorArea, workspace, t.name) : passengerCheckoutDir(r.reposBasePath, workspace, t.name),
       remote: t.remote ?? (id ? remotes[id] : void 0),
       ...forgeHost ? { forgeHost } : {}
     };
@@ -4039,6 +4201,7 @@ function runScript(script, opts) {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let output = "";
+    let stdout = "";
     let pending = "";
     const absorb = (buf) => {
       const text2 = buf.toString();
@@ -4049,18 +4212,21 @@ function runScript(script, opts) {
       pending = lines2.pop() ?? "";
       for (const l of lines2) opts.onLine(l);
     };
-    child.stdout.on("data", absorb);
+    child.stdout.on("data", (buf) => {
+      stdout += buf.toString();
+      absorb(buf);
+    });
     child.stderr.on("data", absorb);
     const timer = opts.timeoutMs ? setTimeout(() => child.kill("SIGKILL"), opts.timeoutMs) : void 0;
     child.on("error", (err3) => {
       if (timer) clearTimeout(timer);
       resolvePromise({ code: 127, output: `${output}
-crew: cannot run ${shell.bin}: ${err3.message}` });
+crew: cannot run ${shell.bin}: ${err3.message}`, stdout });
     });
     child.on("close", (code) => {
       if (timer) clearTimeout(timer);
       if (pending && opts.onLine) opts.onLine(pending);
-      resolvePromise({ code: code ?? 1, output });
+      resolvePromise({ code: code ?? 1, output, stdout });
     });
   });
 }
@@ -4200,9 +4366,9 @@ function recoveredFailureHeadlines(o, route2) {
 }
 
 // src/install.ts
-import { dirname as dirname6, join as join14, extname } from "path";
+import { dirname as dirname7, join as join15, extname } from "path";
 import { homedir as homedir7, userInfo } from "os";
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync3, readFileSync as readFileSync13, statSync as statSync5, writeFileSync as writeFileSync9, unlinkSync, realpathSync } from "fs";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync13, mkdirSync as mkdirSync9, readdirSync as readdirSync3, readFileSync as readFileSync14, statSync as statSync5, writeFileSync as writeFileSync10, unlinkSync, realpathSync } from "fs";
 import { spawnSync as spawnSync4 } from "child_process";
 import { createHash as createHash3 } from "crypto";
 
@@ -4214,7 +4380,7 @@ function isCompiledBinary(moduleUrl) {
 // src/install.ts
 function crewInvocation(crewHome) {
   if (isCompiledBinary(import.meta.url)) return [process.execPath];
-  return [process.execPath, join14(crewHome, "bin", "crew")];
+  return [process.execPath, join15(crewHome, "bin", "crew")];
 }
 var INTERVAL_SECONDS = 120;
 function labelFor(crewHome, job) {
@@ -4245,14 +4411,14 @@ function schedulerLogFor(crewLog, job) {
   return `${stem}.${suffix}${ext || ".log"}`;
 }
 function pathFor(ship) {
-  const nodeBinDir = dirname6(process.execPath);
+  const nodeBinDir = dirname7(process.execPath);
   const parts = [nodeBinDir];
   if (ship.extraPath) parts.push(ship.extraPath);
   parts.push("/usr/bin", "/bin", "/usr/sbin", "/sbin");
   return parts.join(":");
 }
 function findOnPath(bin, searchPath) {
-  const candidates2 = bin.includes("/") ? [bin] : searchPath.split(":").filter(Boolean).map((dir) => join14(dir, bin));
+  const candidates2 = bin.includes("/") ? [bin] : searchPath.split(":").filter(Boolean).map((dir) => join15(dir, bin));
   for (const candidate of candidates2) {
     try {
       accessSync2(candidate, constants2.X_OK);
@@ -4262,12 +4428,12 @@ function findOnPath(bin, searchPath) {
   }
   return void 0;
 }
-var COMMON_DOCKER_DIRS = ["/usr/local/bin", "/opt/homebrew/bin", join14(homedir7(), ".docker", "bin")].join(":");
+var COMMON_DOCKER_DIRS = ["/usr/local/bin", "/opt/homebrew/bin", join15(homedir7(), ".docker", "bin")].join(":");
 function dockerPathProblem(ship, shellPath = process.env.PATH ?? "") {
   const schedulerPath = pathFor(ship);
   if (findOnPath("docker", schedulerPath)) return void 0;
   const inShell = findOnPath("docker", shellPath);
-  return inShell ? `\`docker\` is not on the scheduler PATH (${schedulerPath}) but is at ${inShell} in your shell; add ${dirname6(inShell)} to ship.extraPath in crew.yaml and run \`crew install\`` : `\`docker\` is not on the scheduler PATH (${schedulerPath}) or your shell PATH; install Docker, then add its directory to ship.extraPath in crew.yaml and run \`crew install\``;
+  return inShell ? `\`docker\` is not on the scheduler PATH (${schedulerPath}) but is at ${inShell} in your shell; add ${dirname7(inShell)} to ship.extraPath in crew.yaml and run \`crew install\`` : `\`docker\` is not on the scheduler PATH (${schedulerPath}) or your shell PATH; install Docker, then add its directory to ship.extraPath in crew.yaml and run \`crew install\``;
 }
 var USER_INSTALL = { root: false, user: "" };
 function installContext(env = process.env) {
@@ -4277,7 +4443,7 @@ function installContext(env = process.env) {
 }
 var SYSTEM_UNIT_DIR = "/etc/systemd/system";
 function systemUnitPathFor(label, suffix = "service") {
-  return join14(SYSTEM_UNIT_DIR, `${label}.${suffix}`);
+  return join15(SYSTEM_UNIT_DIR, `${label}.${suffix}`);
 }
 function unitEnvironment(ship) {
   return [["PATH", pathFor(ship)], ...Object.entries(ship.env ?? {})];
@@ -4298,7 +4464,7 @@ function xmlEscape(s) {
 }
 function planLaunchd(ship, crewHome, job) {
   const label = labelFor(crewHome, job);
-  const unitPath = join14(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
+  const unitPath = join15(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
   const crewLog = ship.logFile;
   const schedulerLog = schedulerLogFor(crewLog, job);
   const persistent = job === "run";
@@ -4352,7 +4518,7 @@ ${scheduleKeys}
 }
 function planSystemd(ship, crewHome, job, ctx) {
   const label = labelFor(crewHome, job);
-  const unitDir = ctx.root ? SYSTEM_UNIT_DIR : join14(homedir7(), ".config", "systemd", "user");
+  const unitDir = ctx.root ? SYSTEM_UNIT_DIR : join15(homedir7(), ".config", "systemd", "user");
   const ctl = ctx.root ? ["systemctl"] : ["systemctl", "--user"];
   const userLine = ctx.root && ctx.user && ctx.user !== "root" ? `User=${ctx.user}
 ` : "";
@@ -4361,7 +4527,7 @@ function planSystemd(ship, crewHome, job, ctx) {
     lingerCommand: ["loginctl", "enable-linger", ctx.user],
     lingerHint: `the daemon will stop when ${ctx.user} logs out; run \`sudo loginctl enable-linger ${ctx.user}\` once, or run \`crew install\` as root for a system unit`
   };
-  const servicePath = join14(unitDir, `${label}.service`);
+  const servicePath = join15(unitDir, `${label}.service`);
   const crewLog = ship.logFile;
   const schedulerLog = schedulerLogFor(crewLog, job);
   const description = job === "release" ? "Tablation crew \u2014 release" : job === "passengers" ? "Tablation crew \u2014 Host Passengers sync" : "Tablation crew \u2014 persistent supervisor loop";
@@ -4402,7 +4568,7 @@ WantedBy=${wantedBy}
       ...linger
     };
   }
-  const timerPath = join14(unitDir, `${label}.timer`);
+  const timerPath = join15(unitDir, `${label}.timer`);
   const service = `# Written by \`crew install\` \u2014 re-run it rather than hand-editing this file.
 [Unit]
 Description=${description}
@@ -4477,7 +4643,7 @@ function planInstall(ship, crewHome, hostShip, hasSystemd, job = "run", ctx = US
 function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
   const label = labelFor(crewHome, job);
   if (hostShip === "macos") {
-    const unitPath = join14(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
+    const unitPath = join15(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
     return {
       mechanism: "launchd",
       unitPaths: [unitPath],
@@ -4487,20 +4653,20 @@ function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
     };
   }
   if (hostShip === "linux" && hasSystemd) {
-    const system = existsSync12(systemUnitPathFor(label));
-    const unitDir = system ? SYSTEM_UNIT_DIR : join14(homedir7(), ".config", "systemd", "user");
+    const system = existsSync13(systemUnitPathFor(label));
+    const unitDir = system ? SYSTEM_UNIT_DIR : join15(homedir7(), ".config", "systemd", "user");
     const ctl = system ? ["systemctl"] : ["systemctl", "--user"];
     if (job === "run") {
       return {
         mechanism: "systemd",
-        unitPaths: [join14(unitDir, `${label}.service`)],
+        unitPaths: [join15(unitDir, `${label}.service`)],
         crontabLine: null,
         unloadCommands: [[...ctl, "disable", "--now", `${label}.service`]]
       };
     }
     return {
       mechanism: "systemd",
-      unitPaths: [join14(unitDir, `${label}.service`), join14(unitDir, `${label}.timer`)],
+      unitPaths: [join15(unitDir, `${label}.service`), join15(unitDir, `${label}.timer`)],
       crontabLine: null,
       unloadCommands: [[...ctl, "disable", "--now", `${label}.timer`]]
     };
@@ -4518,7 +4684,7 @@ function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
 function planDaemonControl(crewHome, hostShip, hasSystemd) {
   const label = labelFor(crewHome, "run");
   if (hostShip === "macos") {
-    const unitPath = join14(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
+    const unitPath = join15(homedir7(), "Library", "LaunchAgents", `${label}.plist`);
     return {
       mechanism: "launchd",
       startCommand: ["launchctl", "load", unitPath],
@@ -4528,7 +4694,7 @@ function planDaemonControl(crewHome, hostShip, hasSystemd) {
   }
   if (hostShip === "linux" && hasSystemd) {
     const unit = `${label}.service`;
-    const ctl = existsSync12(systemUnitPathFor(label)) ? ["systemctl"] : ["systemctl", "--user"];
+    const ctl = existsSync13(systemUnitPathFor(label)) ? ["systemctl"] : ["systemctl", "--user"];
     return {
       mechanism: "systemd",
       startCommand: [...ctl, "start", unit],
@@ -4560,10 +4726,10 @@ async function applyInstall(plan, crewHome, dryRun, log) {
       log.emit(`would write ${path}`);
       continue;
     }
-    const before = existsSync12(path) ? readFileSync13(path, "utf8") : null;
+    const before = existsSync13(path) ? readFileSync14(path, "utf8") : null;
     if (before !== plan.unitContent[path]) changed2 = true;
-    mkdirSync8(dirname6(path), { recursive: true });
-    writeFileSync9(path, plan.unitContent[path]);
+    mkdirSync9(dirname7(path), { recursive: true });
+    writeFileSync10(path, plan.unitContent[path]);
     log.emit(`wrote ${path}`);
   }
   if (plan.crontabLine) {
@@ -4627,7 +4793,7 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
     }
   }
   for (const path of plan.unitPaths) {
-    if (!existsSync12(path)) continue;
+    if (!existsSync13(path)) continue;
     if (dryRun) {
       log.emit(`would remove ${path}`);
       continue;
@@ -4646,7 +4812,7 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
 }
 var CREW_LAUNCHD_PREFIX = "com.tablation.crew";
 function launchAgentsDir() {
-  return join14(homedir7(), "Library", "LaunchAgents");
+  return join15(homedir7(), "Library", "LaunchAgents");
 }
 function xmlUnescape(s) {
   return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
@@ -4663,25 +4829,25 @@ function loadedCrewLabels() {
   return [...parseLaunchctlList(list.stdout ?? "").keys()].filter((l) => l.startsWith(CREW_LAUNCHD_PREFIX));
 }
 function listLaunchdUnits(dir = launchAgentsDir(), loaded = []) {
-  const files = existsSync12(dir) ? readdirSync3(dir) : [];
+  const files = existsSync13(dir) ? readdirSync3(dir) : [];
   const units = files.filter((f) => f.startsWith(CREW_LAUNCHD_PREFIX) && f.endsWith(".plist")).sort().map((f) => {
-    const plistPath = join14(dir, f);
+    const plistPath = join15(dir, f);
     let program = null;
     try {
-      program = programFromPlist(readFileSync13(plistPath, "utf8"));
+      program = programFromPlist(readFileSync14(plistPath, "utf8"));
     } catch {
     }
     return {
       label: f.slice(0, -".plist".length),
       plistPath,
       program,
-      programExists: program !== null && existsSync12(program)
+      programExists: program !== null && existsSync13(program)
     };
   });
   const seen = new Set(units.map((u) => u.label));
   for (const label of [...loaded].sort()) {
     if (!label.startsWith(CREW_LAUNCHD_PREFIX) || seen.has(label)) continue;
-    units.push({ label, plistPath: join14(dir, `${label}.plist`), program: null, programExists: false, orphan: true });
+    units.push({ label, plistPath: join15(dir, `${label}.plist`), program: null, programExists: false, orphan: true });
   }
   return units;
 }
@@ -4694,9 +4860,9 @@ function removeLaunchdUnit(unit, dryRun, log) {
     log.emit(`would unload and remove ${unit.label}`);
     return;
   }
-  if (existsSync12(unit.plistPath)) spawnSync4("launchctl", ["unload", unit.plistPath], { encoding: "utf8" });
+  if (existsSync13(unit.plistPath)) spawnSync4("launchctl", ["unload", unit.plistPath], { encoding: "utf8" });
   spawnSync4("launchctl", ["remove", unit.label], { encoding: "utf8" });
-  if (existsSync12(unit.plistPath)) unlinkSync(unit.plistPath);
+  if (existsSync13(unit.plistPath)) unlinkSync(unit.plistPath);
   log.emit(`removed ${unit.label} (${unit.plistPath})`);
 }
 function clearForeignLaunchdUnits(crewHome, replace, dryRun, log, dir, loaded) {
@@ -4774,24 +4940,24 @@ function detectSystemd() {
 }
 
 // src/ship-attention.ts
-import { existsSync as existsSync14, statfsSync } from "fs";
+import { existsSync as existsSync15, statfsSync } from "fs";
 
 // src/git.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 import {
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync9,
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync10,
   openSync as openSync2,
   closeSync as closeSync2,
   writeSync,
   statSync as statSync6,
   unlinkSync as unlinkSync2,
-  readFileSync as readFileSync14,
-  writeFileSync as writeFileSync10,
+  readFileSync as readFileSync15,
+  writeFileSync as writeFileSync11,
   readdirSync as readdirSync4,
   rmSync as rmSync8
 } from "fs";
-import { dirname as dirname7, basename as basename5, join as join15 } from "path";
+import { dirname as dirname8, basename as basename5, join as join16 } from "path";
 var GitError = class extends Error {
 };
 function streamText(x) {
@@ -4799,7 +4965,7 @@ function streamText(x) {
 }
 function gitRaw(cwd, args) {
   try {
-    return execFileSync3("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return execFileSync4("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
   } catch (e) {
     const err3 = e;
     const why = [err3.stderr, err3.stdout].map(streamText).filter(Boolean).join(" / ");
@@ -4808,7 +4974,7 @@ function gitRaw(cwd, args) {
 }
 function git(cwd, args) {
   try {
-    return execFileSync3("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    return execFileSync4("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
   } catch (e) {
     const err3 = e;
     const why = [err3.stderr, err3.stdout].map(streamText).filter(Boolean).join(" / ");
@@ -4979,9 +5145,9 @@ function keyCommitsInRange(cwd, key, range) {
 }
 function patchIdOf(cwd, from, to) {
   try {
-    const diff = execFileSync3("git", ["diff", from, to], { cwd, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+    const diff = execFileSync4("git", ["diff", from, to], { cwd, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
     if (!diff) return null;
-    const out = execFileSync3("git", ["patch-id", "--stable"], { cwd, encoding: "utf8", input: diff });
+    const out = execFileSync4("git", ["patch-id", "--stable"], { cwd, encoding: "utf8", input: diff });
     return out.split(" ")[0]?.trim() || null;
   } catch {
     return null;
@@ -5171,7 +5337,7 @@ function recoverStrandedReleaseCheckouts(cwd) {
     if (line.startsWith("worktree ")) path = line.slice("worktree ".length);
     else if (line.startsWith("branch refs/heads/crew/release-") && path) {
       gitOk(cwd, ["worktree", "remove", "--force", path]);
-      const root = dirname7(path);
+      const root = dirname8(path);
       if (basename5(root).startsWith("crew-release-")) rmSync8(root, { recursive: true, force: true });
     }
   }
@@ -5189,11 +5355,11 @@ function sweepStaleReleaseRoots(tmp, now = Date.now(), maxAgeMs = 60 * 60 * 1e3)
   }
   for (const name of names) {
     if (!name.startsWith("crew-release-")) continue;
-    const root = join15(tmp, name);
+    const root = join16(tmp, name);
     try {
       const st = statSync6(root);
       if (!st.isDirectory() || now - st.mtimeMs < maxAgeMs) continue;
-      if (existsSync13(join15(root, "checkout"))) continue;
+      if (existsSync14(join16(root, "checkout"))) continue;
       rmSync8(root, { recursive: true, force: true });
       removed.push(name);
     } catch {
@@ -5245,16 +5411,16 @@ function originUrlOf(dir, remoteName) {
   }
 }
 function ensureRepoCheckout(dir, remote, opts = {}) {
-  if (existsSync13(`${dir}/.git`)) return false;
+  if (existsSync14(`${dir}/.git`)) return false;
   if (!remote) {
     throw new GitError(
       `${dir} does not exist and this repo has no discovered remote to clone from \u2014 re-run \`crew connect\`, or check out the repository yourself and point \`repos:\` at it`
     );
   }
-  mkdirSync9(dirname7(dir), { recursive: true });
+  mkdirSync10(dirname8(dir), { recursive: true });
   const url = cloneUrlFor(remote, opts);
   try {
-    execFileSync3("git", ["clone", url, dir], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync4("git", ["clone", url, dir], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
   } catch (e) {
     const err3 = e;
     const why = [err3.stderr, err3.stdout].map(streamText).filter(Boolean).join(" / ");
@@ -5276,7 +5442,7 @@ function sleepSync(ms3) {
 }
 function acquireCheckoutLock(dir, timeoutMs = 3e4) {
   const lockPath = checkoutLockPath(dir);
-  mkdirSync9(dirname7(lockPath), { recursive: true });
+  mkdirSync10(dirname8(lockPath), { recursive: true });
   const deadline = Date.now() + timeoutMs;
   for (; ; ) {
     try {
@@ -5313,17 +5479,17 @@ function acquireCheckoutLock(dir, timeoutMs = 3e4) {
 function syncPassengerCheckout(dir, githubRemote, gitRemoteName, base, clone = {}) {
   const release = acquireCheckoutLock(dir);
   try {
-    if (!existsSync13(`${dir}/.git`) && githubRemote) {
+    if (!existsSync14(`${dir}/.git`) && githubRemote) {
       const url = cloneUrlFor(githubRemote, clone);
       const marker = cloneFailureMarker(dir);
-      if (existsSync13(marker) && readFileSync14(marker, "utf8").split("\n")[0] === url) {
-        return { action: "clone-failed", detail: readFileSync14(marker, "utf8").split("\n").slice(1).join("\n"), repeat: true };
+      if (existsSync14(marker) && readFileSync15(marker, "utf8").split("\n")[0] === url) {
+        return { action: "clone-failed", detail: readFileSync15(marker, "utf8").split("\n").slice(1).join("\n"), repeat: true };
       }
       try {
         ensureRepoCheckout(dir, githubRemote, clone);
       } catch (e) {
         if (!(e instanceof GitError)) throw e;
-        writeFileSync10(marker, `${url}
+        writeFileSync11(marker, `${url}
 ${e.message}`);
         return { action: "clone-failed", detail: e.message, repeat: false };
       }
@@ -5549,7 +5715,7 @@ function noteHeldWorktree(state, h, nowMs = Date.now()) {
 function reconcileHeldWorktrees(state, repo, log, stillRefused) {
   for (const i of state.shipAttention().previous()) {
     if (i.kind !== "worktree_held" || !i.held || i.held.repo !== repo) continue;
-    const gone = !existsSync14(i.held.path);
+    const gone = !existsSync15(i.held.path);
     if (!gone && !(stillRefused && !stillRefused.has(i.held.path))) continue;
     clearShipAttention(state, i.key);
     log.emit(
@@ -5667,6 +5833,18 @@ function repoFindings(o) {
       remedy: "add the directory holding it to ship.extraPath in crew.yaml"
     });
   }
+  if (o.intelSyntax) {
+    if (o.intelSyntax.status === "error") {
+      problems.push({
+        severity: "attention",
+        kind: "intel_hook_syntax",
+        ...at,
+        hook: "intel",
+        message: `${o.route}/${o.repo}: the intel hook fails its syntax check, so no symbol service will start: ${(o.intelSyntax.message ?? "").split("\n")[0]}`,
+        remedy: "fix hooks.intel in the repository's .crew.yaml (`crew repos check` prints the full error)"
+      });
+    } else passed++;
+  }
   return { problems, passed };
 }
 function attentionProblems(items, already) {
@@ -5677,13 +5855,13 @@ function attentionProblems(items, already) {
 // src/sandbox-image.ts
 import { createHash as createHash6 } from "crypto";
 import { spawn as spawn4 } from "child_process";
-import { execFileSync as execFileSync7 } from "child_process";
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync22, renameSync as renameSync3, writeFileSync as writeFileSync16, rmSync as rmSync13 } from "fs";
-import { dirname as dirname11, join as join27 } from "path";
+import { execFileSync as execFileSync8 } from "child_process";
+import { mkdirSync as mkdirSync16, readFileSync as readFileSync23, renameSync as renameSync3, writeFileSync as writeFileSync17, rmSync as rmSync13 } from "fs";
+import { dirname as dirname12, join as join28 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 
 // src/passenger-containers.ts
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 import { createHash as createHash5 } from "crypto";
 
 // src/sandbox-cache.ts
@@ -5692,32 +5870,32 @@ import { promisify as promisify2 } from "util";
 
 // src/deprovision-host.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync25, readdirSync as readdirSync11 } from "fs";
+import { existsSync as existsSync26, readdirSync as readdirSync11 } from "fs";
 
 // src/interrupted.ts
-import { existsSync as existsSync23, readdirSync as readdirSync9, readFileSync as readFileSync21 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync24, readdirSync as readdirSync9, readFileSync as readFileSync22 } from "fs";
+import { join as join26 } from "path";
 
 // src/agent.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { readFileSync as readFileSync20, existsSync as existsSync22, statSync as statSync8, mkdirSync as mkdirSync14, writeFileSync as writeFileSync15, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
+import { readFileSync as readFileSync21, existsSync as existsSync23, statSync as statSync8, mkdirSync as mkdirSync15, writeFileSync as writeFileSync16, createWriteStream, openSync as openSync3, closeSync as closeSync3, readSync } from "fs";
 import { StringDecoder } from "string_decoder";
 import { finished } from "stream/promises";
-import { join as join24, dirname as dirname10, basename as basename9 } from "path";
+import { join as join25, dirname as dirname11, basename as basename9 } from "path";
 import { createHash as createHash4 } from "crypto";
 
 // src/state.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, existsSync as existsSync15, mkdirSync as mkdirSync10, rmSync as rmSync9, statSync as statSync7, readdirSync as readdirSync5 } from "fs";
-import { join as join16 } from "path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, existsSync as existsSync16, mkdirSync as mkdirSync11, rmSync as rmSync9, statSync as statSync7, readdirSync as readdirSync5 } from "fs";
+import { join as join17 } from "path";
 var EPOCH = "1970-01-01T00:00:00.000Z";
 var State = class _State {
   dir;
   constructor(dir) {
     this.dir = dir;
-    mkdirSync10(dir, { recursive: true });
+    mkdirSync11(dir, { recursive: true });
   }
   path(...parts) {
-    return join16(this.dir, ...parts);
+    return join17(this.dir, ...parts);
   }
   /**
    * The timestamp every "new since last poll" check is measured against.
@@ -5728,14 +5906,14 @@ var State = class _State {
    */
   watermark() {
     try {
-      const v = readFileSync15(this.path(".poll-watermark"), "utf8").trim();
+      const v = readFileSync16(this.path(".poll-watermark"), "utf8").trim();
       return v || EPOCH;
     } catch {
       return EPOCH;
     }
   }
   setWatermark(at) {
-    writeFileSync11(this.path(".poll-watermark"), `${at}
+    writeFileSync12(this.path(".poll-watermark"), `${at}
 `);
   }
   /**
@@ -5753,16 +5931,16 @@ var State = class _State {
   }
   /** Whole-crew pause, and the per-role sentinels one level down. */
   isPaused() {
-    return existsSync15(this.path(".crew-paused"));
+    return existsSync16(this.path(".crew-paused"));
   }
   isRolePaused(role) {
-    return existsSync15(this.path(`.role-paused-${role}`));
+    return existsSync16(this.path(`.role-paused-${role}`));
   }
   pausedRoles(roles) {
     return new Set(roles.filter((r) => this.isRolePaused(r)));
   }
   pause(role) {
-    writeFileSync11(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
+    writeFileSync12(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
   }
   resume(role) {
     rmSync9(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
@@ -5773,10 +5951,10 @@ var State = class _State {
    * while agents keep working.
    */
   isReleasePaused() {
-    return existsSync15(this.path(".release-paused"));
+    return existsSync16(this.path(".release-paused"));
   }
   setReleasePaused(paused) {
-    if (paused) writeFileSync11(this.path(".release-paused"), "");
+    if (paused) writeFileSync12(this.path(".release-paused"), "");
     else rmSync9(this.path(".release-paused"), { force: true });
   }
   /**
@@ -5814,7 +5992,7 @@ var State = class _State {
     const name = _State.safe(rawName);
     const file = this.path(`.${name}.lock`);
     try {
-      const existing = Number.parseInt(readFileSync15(file, "utf8").trim(), 10);
+      const existing = Number.parseInt(readFileSync16(file, "utf8").trim(), 10);
       if (Number.isFinite(existing) && existing > 0) {
         try {
           process.kill(existing, 0);
@@ -5824,7 +6002,7 @@ var State = class _State {
       }
     } catch {
     }
-    writeFileSync11(file, `${process.pid}
+    writeFileSync12(file, `${process.pid}
 `);
     return {
       ok: true,
@@ -5852,7 +6030,7 @@ var State = class _State {
       if (!/^\.release-.+\.lock$/.test(n)) continue;
       let pid = 0;
       try {
-        pid = Number.parseInt(readFileSync15(this.path(n), "utf8").trim(), 10);
+        pid = Number.parseInt(readFileSync16(this.path(n), "utf8").trim(), 10);
       } catch {
         continue;
       }
@@ -5938,7 +6116,7 @@ var State = class _State {
   ticketInFlight(recordId) {
     const file = this.path(`.${_State.safe(`crew-ticket-${recordId}`)}.lock`);
     try {
-      const pid = Number.parseInt(readFileSync15(file, "utf8").trim(), 10);
+      const pid = Number.parseInt(readFileSync16(file, "utf8").trim(), 10);
       if (!Number.isFinite(pid) || pid <= 0) return false;
       process.kill(pid, 0);
       return true;
@@ -5972,7 +6150,7 @@ var State = class _State {
     const heldReported = `.release-held-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync15(this.path(f), "utf8").trim() || null;
+        return readFileSync16(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -5981,7 +6159,7 @@ var State = class _State {
       blockedCount: () => Number.parseInt(read(blocked) ?? "", 10) || 0,
       noteBlocked: () => {
         const n = (Number.parseInt(read(blocked) ?? "", 10) || 0) + 1;
-        writeFileSync11(this.path(blocked), `${n}
+        writeFileSync12(this.path(blocked), `${n}
 `);
         return n;
       },
@@ -5998,7 +6176,7 @@ var State = class _State {
        */
       deployFailedSha: () => read(failed),
       noteDeployFailed: (sha) => {
-        writeFileSync11(this.path(failed), `${sha}
+        writeFileSync12(this.path(failed), `${sha}
 `);
       },
       clearDeployFailed: () => {
@@ -6012,7 +6190,7 @@ var State = class _State {
       noteTestGateFailed: (sha) => {
         const [prev, n] = (read(gateFailed) ?? "").split(" ");
         const next = prev === sha ? (Number.parseInt(n ?? "", 10) || 0) + 1 : 1;
-        writeFileSync11(this.path(gateFailed), `${sha} ${next}
+        writeFileSync12(this.path(gateFailed), `${sha} ${next}
 `);
         return next;
       },
@@ -6022,13 +6200,13 @@ var State = class _State {
       /** Whether the board was already told about this head's red gate. */
       heldReported: () => {
         try {
-          return readFileSync15(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
+          return readFileSync16(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
         } catch {
           return null;
         }
       },
       noteHeldReported: (signature) => {
-        writeFileSync11(this.path(heldReported), `${signature}
+        writeFileSync12(this.path(heldReported), `${signature}
 `);
       },
       clearHeldReported: () => {
@@ -6036,7 +6214,7 @@ var State = class _State {
       },
       testGateReported: (sha) => read(gateReported) === sha,
       noteTestGateReported: (sha) => {
-        writeFileSync11(this.path(gateReported), `${sha}
+        writeFileSync12(this.path(gateReported), `${sha}
 `);
       }
     };
@@ -6059,7 +6237,7 @@ var State = class _State {
     const ticketStreakFile = `.fairness-ticket-streak-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync15(this.path(f), "utf8").trim() || null;
+        return readFileSync16(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -6092,18 +6270,18 @@ var State = class _State {
           clear2();
           return;
         }
-        writeFileSync11(this.path(streakFile), `${this.readInt(streakFile) + 1}
+        writeFileSync12(this.path(streakFile), `${this.readInt(streakFile) + 1}
 `);
         const prior = read(ticketFile);
         if (topTicket && topTicket === prior) {
-          writeFileSync11(this.path(ticketStreakFile), `${this.readInt(ticketStreakFile) + 1}
+          writeFileSync12(this.path(ticketStreakFile), `${this.readInt(ticketStreakFile) + 1}
 `);
         } else if (topTicket) {
-          writeFileSync11(this.path(ticketFile), `${topTicket}
+          writeFileSync12(this.path(ticketFile), `${topTicket}
 `);
-          writeFileSync11(this.path(sinceFile), `${(/* @__PURE__ */ new Date()).toISOString()}
+          writeFileSync12(this.path(sinceFile), `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
-          writeFileSync11(this.path(ticketStreakFile), "1\n");
+          writeFileSync12(this.path(ticketStreakFile), "1\n");
         }
       }
     };
@@ -6124,14 +6302,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync15(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync16(this.path(file), "utf8"));
           return parsed && typeof parsed === "object" ? parsed : {};
         } catch {
           return {};
         }
       },
       persist: (next) => {
-        writeFileSync11(this.path(file), JSON.stringify(next));
+        writeFileSync12(this.path(file), JSON.stringify(next));
       }
     };
   }
@@ -6147,14 +6325,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync15(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync16(this.path(file), "utf8"));
           return Array.isArray(parsed) ? parsed.filter((x) => typeof x === "string") : [];
         } catch {
           return [];
         }
       },
       persist: (next) => {
-        writeFileSync11(this.path(file), JSON.stringify(next));
+        writeFileSync12(this.path(file), JSON.stringify(next));
       }
     };
   }
@@ -6168,14 +6346,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync15(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync16(this.path(file), "utf8"));
           return Array.isArray(parsed) ? parsed : [];
         } catch {
           return [];
         }
       },
       persist: (next) => {
-        writeFileSync11(this.path(file), JSON.stringify(next));
+        writeFileSync12(this.path(file), JSON.stringify(next));
       }
     };
   }
@@ -6188,7 +6366,7 @@ var State = class _State {
     const file = ".release-last-run";
     return {
       touch: () => {
-        writeFileSync11(this.path(file), (/* @__PURE__ */ new Date()).toISOString());
+        writeFileSync12(this.path(file), (/* @__PURE__ */ new Date()).toISOString());
       },
       at: () => {
         try {
@@ -6201,7 +6379,7 @@ var State = class _State {
   }
   readInt(file) {
     try {
-      return Number.parseInt(readFileSync15(this.path(file), "utf8").trim(), 10) || 0;
+      return Number.parseInt(readFileSync16(this.path(file), "utf8").trim(), 10) || 0;
     } catch {
       return 0;
     }
@@ -6280,6 +6458,8 @@ var HOOK_PURPOSE = [
   ["ports", "this worktree's port assignments; prints KEY=value overrides to export"],
   ["handoff", "leave the operator able to open what you built; put its output in your progress comment"],
   ["preview", "start this worktree's dev server for a viewer, bound to CREW_PREVIEW_HOST, detached; its last stdout line is the URL"],
+  ["intel", "start this worktree's symbol service, loopback only, detached; its last stdout line is the URL of an MCP endpoint"],
+  ["map", 'prints an outline of the repository; the crew places it under "Repository map" below'],
   ["test", "run the suite"],
   ["build", "build it"],
   ["ci_status", "after you push and before you hand off: exit 0 means CI is green for your branch; on failure fix and push again, and say in your progress comment if it is still pending"]
@@ -6376,6 +6556,13 @@ function repoSection(r, key, heading) {
   }
   return lines2;
 }
+function mapSection(r, heading) {
+  if (r.map) return ["", heading, "", r.map, ""];
+  if (r.mapSkipped) {
+    return ["", `Note: ${r.mapSkipped}. Say so in one line of your progress comment; it does not block the work.`, ""];
+  }
+  return [];
+}
 function renderEnvironment(i) {
   const { route: route2, contract } = i;
   const repos = i.repos;
@@ -6567,12 +6754,16 @@ function renderEnvironment(i) {
     for (const r of repos) {
       lines2.push(...i.sandbox ? ["", `### ${r.name}`] : repoSection(r, key, `### ${r.name} \u2014 \`${r.dir}\``));
       lines2.push("", `Hooks for ${r.name} \u2014 the only commands you should run here:`, "", hookTable(r.config));
+      lines2.push(...mapSection(r, `#### Repository map \u2014 ${r.name}`));
     }
   }
   if (i.repoDir) {
     lines2.push("", `This ticket's work happens in \`${i.repoDir}\`.`);
   }
-  if (only) lines2.push("", "## Hooks \u2014 the only commands you should run", "", hookTable(only.config));
+  if (only) {
+    lines2.push("", "## Hooks \u2014 the only commands you should run", "", hookTable(only.config));
+    lines2.push(...mapSection(only, "## Repository map"));
+  }
   return lines2.join("\n");
 }
 
@@ -6742,8 +6933,8 @@ var PERISCOPE_COLUMNS = [
 ];
 
 // src/agent-log.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync10, writeFileSync as writeFileSync12 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync12, readdirSync as readdirSync6, readFileSync as readFileSync17, rmSync as rmSync10, writeFileSync as writeFileSync13 } from "fs";
+import { join as join18 } from "path";
 
 // src/pending-backoff.ts
 var sleepBackoff = (attempts) => Math.min(6e4 * 2 ** Math.max(0, attempts - 1), 30 * 6e4);
@@ -6915,20 +7106,20 @@ async function addRunToTicket(target, t, recordId, run3) {
     };
   }
 }
-var queueDir = (stateDir) => join17(stateDir, "pending-agent-logs");
+var queueDir = (stateDir) => join18(stateDir, "pending-agent-logs");
 function queueAgentRun(stateDir, name, q2) {
-  mkdirSync11(queueDir(stateDir), { recursive: true });
-  writeFileSync12(join17(queueDir(stateDir), `${name}.json`), JSON.stringify(q2));
+  mkdirSync12(queueDir(stateDir), { recursive: true });
+  writeFileSync13(join18(queueDir(stateDir), `${name}.json`), JSON.stringify(q2));
 }
 async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = queueDir(stateDir);
-  if (!existsSync16(dir)) return 0;
+  if (!existsSync17(dir)) return 0;
   let sent = 0;
   for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join17(dir, f);
+    const path = join18(dir, f);
     let q2;
     try {
-      q2 = JSON.parse(readFileSync16(path, "utf8"));
+      q2 = JSON.parse(readFileSync17(path, "utf8"));
     } catch {
       continue;
     }
@@ -6957,7 +7148,7 @@ async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__
         continue;
       }
       const attempts = q2.attempts + 1;
-      writeFileSync12(path, JSON.stringify({
+      writeFileSync13(path, JSON.stringify({
         ...q2,
         attempts,
         warned: true,
@@ -6968,20 +7159,20 @@ async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__
   }
   return sent;
 }
-var countersDir = (stateDir) => join17(stateDir, "pending-ticket-counters");
+var countersDir = (stateDir) => join18(stateDir, "pending-ticket-counters");
 function queueTicketCounters(stateDir, name, q2) {
-  mkdirSync11(countersDir(stateDir), { recursive: true });
-  writeFileSync12(join17(countersDir(stateDir), `${name}.json`), JSON.stringify(q2));
+  mkdirSync12(countersDir(stateDir), { recursive: true });
+  writeFileSync13(join18(countersDir(stateDir), `${name}.json`), JSON.stringify(q2));
 }
 async function replayQueuedTicketCounters(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = countersDir(stateDir);
-  if (!existsSync16(dir)) return 0;
+  if (!existsSync17(dir)) return 0;
   let sent = 0;
   for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join17(dir, f);
+    const path = join18(dir, f);
     let q2;
     try {
-      q2 = JSON.parse(readFileSync16(path, "utf8"));
+      q2 = JSON.parse(readFileSync17(path, "utf8"));
     } catch {
       continue;
     }
@@ -7000,7 +7191,7 @@ async function replayQueuedTicketCounters(stateDir, route2, keyFor, log, now = /
         continue;
       }
       const attempts = q2.attempts + 1;
-      writeFileSync12(path, JSON.stringify({
+      writeFileSync13(path, JSON.stringify({
         ...q2,
         attempts,
         warned: true,
@@ -7203,8 +7394,8 @@ var HandoffTranscriptTracker = class {
 };
 
 // src/pending-handoff.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync12, readdirSync as readdirSync7, readFileSync as readFileSync17, rmSync as rmSync11, writeFileSync as writeFileSync13 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync13, readdirSync as readdirSync7, readFileSync as readFileSync18, rmSync as rmSync11, writeFileSync as writeFileSync14 } from "fs";
+import { join as join21 } from "path";
 
 // src/ticket-branch.ts
 import { basename as basename7 } from "path";
@@ -8370,16 +8561,16 @@ function holdWarnings(tickets, ships, contract, humanHolds, now = Date.now()) {
 }
 
 // src/run-worktree.ts
-import { existsSync as existsSync18 } from "fs";
-import { dirname as dirname8, join as join19 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { dirname as dirname9, join as join20 } from "path";
 
 // src/ports.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import { existsSync as existsSync17 } from "fs";
-import { join as join18 } from "path";
+import { execFileSync as execFileSync5 } from "child_process";
+import { existsSync as existsSync18 } from "fs";
+import { join as join19 } from "path";
 var run = (cmd, args) => {
   try {
-    return execFileSync4(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return execFileSync5(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
   } catch {
     return "";
   }
@@ -8421,7 +8612,7 @@ function ticketForPort(port, s = DEFAULT_PORTS) {
 }
 function worktreeExists(parent, prefix, n) {
   for (const name of [`${prefix}${n}`, `${prefix}${String(n).padStart(3, "0")}`]) {
-    if (existsSync17(join18(parent, name, ".git"))) return true;
+    if (existsSync18(join19(parent, name, ".git"))) return true;
   }
   return false;
 }
@@ -8504,7 +8695,7 @@ function planRunWorktree(dir, cfg, t, role, opts = {}) {
   const existing = worktreeForNumber(dir, num);
   const located = locateBranchForTicket(dir, cfg, t, role);
   const baseRef = hasRemote ? `${remote}/${base}` : base;
-  if (existing && !existing.prunable && existsSync18(existing.path)) {
+  if (existing && !existing.prunable && existsSync19(existing.path)) {
     const branch = existing.branch;
     if (status(existing.path).length > 0) {
       return { action: opts.resumeInterrupted ? "resume-dirty" : "leave-dirty", path: existing.path, branch };
@@ -8520,7 +8711,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 = join19(dirname8(dir), worktreeForTicket(dir, cfg, t, role));
+  const path = join20(dirname9(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 };
   }
@@ -8574,7 +8765,7 @@ function dropEmptyRunBranch(dir, cfg, branch) {
   if (remoteConfigured(dir, remote) && remoteBranchExists(dir, remote, branch)) return false;
   if (countCommits(dir, `${baseRef}..${branch}`) !== 0) return false;
   const wt = worktrees(dir).find((w) => w.branch === branch && !w.prunable && w.path !== dir);
-  if (wt && existsSync18(wt.path)) {
+  if (wt && existsSync19(wt.path)) {
     if (status(wt.path).length > 0) return false;
     if (gitOk(dir, ["worktree", "remove", wt.path]) === null) return false;
   }
@@ -8582,7 +8773,7 @@ function dropEmptyRunBranch(dir, cfg, branch) {
 }
 async function finishRunWorktree(dir, cfg, branch) {
   const wt = worktrees(dir).find((w) => w.branch === branch && !w.prunable && w.path !== dir);
-  if (!wt || !existsSync18(wt.path)) return { kind: "none" };
+  if (!wt || !existsSync19(wt.path)) return { kind: "none" };
   if (cfg.hooks.handoff) return { kind: "kept-handoff", path: wt.path };
   if (status(wt.path).length > 0) return { kind: "kept-dirty", path: wt.path };
   if (remoteConfigured(dir, cfg.branch.remote) && worktreeHoldsUnpushed(wt.path, cfg.branch.remote)) {
@@ -8594,7 +8785,7 @@ async function finishRunWorktree(dir, cfg, branch) {
     if (pids.length) await killGently(pids);
   }
   gitOk(dir, ["worktree", "remove", wt.path]);
-  return existsSync18(wt.path) ? { kind: "kept-dirty", path: wt.path } : { kind: "removed", path: wt.path };
+  return existsSync19(wt.path) ? { kind: "kept-dirty", path: wt.path } : { kind: "removed", path: wt.path };
 }
 
 // src/handoff-guard.ts
@@ -8977,20 +9168,20 @@ async function guardRunStrays(route2, ship, tracker, role, workingId, since2, lo
 
 // src/pending-handoff.ts
 var PENDING_MAX_AGE_MS = 48 * 36e5;
-var pendingDirFor = (stateDir) => join20(stateDir, "pending-handoffs");
-var stateDirOfStream = (streamPath) => join20(streamPath, "..", "..");
+var pendingDirFor = (stateDir) => join21(stateDir, "pending-handoffs");
+var stateDirOfStream = (streamPath) => join21(streamPath, "..", "..");
 function writePendingHandoff(stateDir, rec) {
   const dir = pendingDirFor(stateDir);
-  mkdirSync12(dir, { recursive: true });
-  writeFileSync13(join20(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
+  mkdirSync13(dir, { recursive: true });
+  writeFileSync14(join21(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
 }
 function listPendingHandoffs(stateDir, route2) {
   const dir = pendingDirFor(stateDir);
-  if (!existsSync19(dir)) return [];
+  if (!existsSync20(dir)) return [];
   const out = [];
   for (const f of readdirSync7(dir).filter((n) => n.endsWith(".json")).sort()) {
     try {
-      const rec = JSON.parse(readFileSync17(join20(dir, f), "utf8"));
+      const rec = JSON.parse(readFileSync18(join21(dir, f), "utf8"));
       if (rec.version === 1 && rec.ticketRecordId && (!route2 || rec.route === route2)) out.push(rec);
     } catch {
     }
@@ -8998,7 +9189,7 @@ function listPendingHandoffs(stateDir, route2) {
   return out;
 }
 function removePendingHandoff(stateDir, ticketRecordId) {
-  rmSync11(join20(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
+  rmSync11(join21(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
 }
 function pendingHandoffFor(stateDir, ticketRecordId) {
   return listPendingHandoffs(stateDir).find((r) => r.ticketRecordId === ticketRecordId);
@@ -9108,8 +9299,8 @@ function expandSkillMarkers(text2, lookup2, opts = {}) {
 }
 
 // src/skills.ts
-import { readFileSync as readFileSync19, readdirSync as readdirSync8, existsSync as existsSync21 } from "fs";
-import { join as join22 } from "path";
+import { readFileSync as readFileSync20, readdirSync as readdirSync8, existsSync as existsSync22 } from "fs";
+import { join as join23 } from "path";
 import { parse as parseYaml } from "yaml";
 import { TablationClient as TablationClient3, StaleWriteError as StaleWriteError3, TablationApiError as TablationApiError2 } from "@tablation/client";
 
@@ -9125,8 +9316,8 @@ ${additions}`;
 }
 
 // src/agents.ts
-import { readFileSync as readFileSync18, existsSync as existsSync20 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync19, existsSync as existsSync21 } from "fs";
+import { join as join22 } from "path";
 import { TablationClient as TablationClient2, StaleWriteError as StaleWriteError2, TablationApiError } from "@tablation/client";
 var PERSONA_NAME = {
   dev: "Developer",
@@ -9140,12 +9331,12 @@ var CREW_AGENT_COLUMN = "agent_id";
 var AgentsSyncError = class extends Error {
 };
 function personaDefaultPrompt(promptsDir, role) {
-  const briefPath = join21(promptsDir, "personas", `lane-${role}.md`);
-  if (!existsSync20(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
-  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync18(briefPath, "utf8");
-  const commonPath = join21(promptsDir, "personas", "common.md");
-  if (!existsSync20(commonPath)) return readFileSync18(briefPath, "utf8");
-  return `${readFileSync18(commonPath, "utf8")}${readFileSync18(briefPath, "utf8")}`;
+  const briefPath = join22(promptsDir, "personas", `lane-${role}.md`);
+  if (!existsSync21(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
+  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync19(briefPath, "utf8");
+  const commonPath = join22(promptsDir, "personas", "common.md");
+  if (!existsSync21(commonPath)) return readFileSync19(briefPath, "utf8");
+  return `${readFileSync19(commonPath, "utf8")}${readFileSync19(briefPath, "utf8")}`;
 }
 async function resolveAgentId(route2, role, opts) {
   const cached = route2.resolved?.agentPersonas?.[role]?.agentId;
@@ -9592,7 +9783,7 @@ function describeCrewLink(o) {
 var SkillSyncError = class extends Error {
 };
 function parseSkillFile(path) {
-  const text2 = readFileSync19(path, "utf8");
+  const text2 = readFileSync20(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];
@@ -9605,9 +9796,9 @@ function parseSkillFile(path) {
   return { name: meta.name, description: meta.description, prompt: body, file: path };
 }
 function listLocalSkills(promptsDir) {
-  const dir = join22(promptsDir, "skills");
-  if (!existsSync21(dir)) return [];
-  return readdirSync8(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join22(dir, f)));
+  const dir = join23(promptsDir, "skills");
+  if (!existsSync22(dir)) return [];
+  return readdirSync8(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join23(dir, f)));
 }
 async function syncSkills(route2, opts) {
   if (!route2.resolved) {
@@ -9791,10 +9982,10 @@ function skillMarkerWarnings(promptsDir, personaPrompts) {
 }
 
 // src/runner.ts
-import { spawn as spawn2, execFile, execFileSync as execFileSync5 } from "child_process";
-import { mkdtempSync, mkdirSync as mkdirSync13, writeFileSync as writeFileSync14, rmSync as rmSync12 } from "fs";
+import { spawn as spawn2, execFile, execFileSync as execFileSync6 } from "child_process";
+import { mkdtempSync, mkdirSync as mkdirSync14, writeFileSync as writeFileSync15, rmSync as rmSync12 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename8, dirname as dirname9, join as join23 } from "path";
+import { basename as basename8, dirname as dirname10, join as join24 } from "path";
 import { promisify } from "util";
 
 // src/run-limit.ts
@@ -9923,8 +10114,8 @@ var SandboxRunner = class {
         throw new Error(`cannot generate the sandbox policy: ${e.message}`);
       }
       policyFile = policyPathFor(plan.streamPath);
-      mkdirSync13(dirname9(policyFile), { recursive: true });
-      writeFileSync14(policyFile, generated.yaml, { mode: 384 });
+      mkdirSync14(dirname10(policyFile), { recursive: true });
+      writeFileSync15(policyFile, generated.yaml, { mode: 384 });
     }
     const create2 = ["sandbox", "create", "--name", name, "--detach"];
     if (policyFile) create2.push("--policy", policyFile);
@@ -9967,10 +10158,10 @@ var SandboxRunner = class {
       const harness = cfg.agentBin ?? basename8(plan.bin);
       const viaUpload = Buffer.byteLength(plan.prompt) > SANDBOX_STDIN_LIMIT;
       if (viaUpload) {
-        const tmp = mkdtempSync(join23(tmpdir2(), "crew-prompt-"));
+        const tmp = mkdtempSync(join24(tmpdir2(), "crew-prompt-"));
         try {
-          const file = join23(tmp, "prompt.txt");
-          writeFileSync14(file, plan.prompt, { mode: 384 });
+          const file = join24(tmp, "prompt.txt");
+          writeFileSync15(file, plan.prompt, { mode: 384 });
           await this.os(["sandbox", "upload", name, file, SANDBOX_PROMPT_PATH]);
         } finally {
           rmSync12(tmp, { recursive: true, force: true });
@@ -10036,7 +10227,7 @@ function describeExecError(e) {
 }
 function gitOrigin(cwd) {
   try {
-    return execFileSync5("git", ["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    return execFileSync6("git", ["-C", cwd, "remote", "get-url", "origin"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
   } catch {
     return null;
   }
@@ -10047,7 +10238,7 @@ function runnerFor(kind, sandbox) {
 function runnerOfSidecar(sc) {
   return sc.runner === "sandbox" ? new SandboxRunner(sc.sandboxBin ? { bin: sc.sandboxBin } : {}) : new HostRunner();
 }
-function checkSandboxRunner(cfg = {}, run3 = (b, a) => execFileSync5(b, a, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 15e3 })) {
+function checkSandboxRunner(cfg = {}, run3 = (b, a) => execFileSync6(b, a, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 15e3 })) {
   const bin = cfg.bin ?? DEFAULT_SANDBOX_CONFIG.bin;
   let version;
   try {
@@ -10114,7 +10305,7 @@ var ALLOWANCE_REFUSAL_MARKER = "AI_ALLOWANCE_EXCEEDED";
 function streamShowsAllowanceRefusal(streamPath) {
   let raw;
   try {
-    raw = readFileSync20(streamPath, "utf8");
+    raw = readFileSync21(streamPath, "utf8");
   } catch {
     return false;
   }
@@ -10137,26 +10328,26 @@ function streamShowsAllowanceRefusal(streamPath) {
   }
   return false;
 }
-var digestPathFor = (stateDir, routeLabel, role, runId) => join24(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPathFor = (stateDir, routeLabel, role, runId) => join25(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
 function planAgentRun(o) {
-  const briefPath = join24(o.route.promptsDir, "personas", `lane-${o.role}.md`);
-  if (!existsSync22(briefPath)) {
+  const briefPath = join25(o.route.promptsDir, "personas", `lane-${o.role}.md`);
+  if (!existsSync23(briefPath)) {
     throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
   }
-  const commonPath = join24(o.route.promptsDir, "personas", "common.md");
-  const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync22(commonPath);
+  const commonPath = join25(o.route.promptsDir, "personas", "common.md");
+  const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync23(commonPath);
   const now = o.now ?? (() => Date.now());
   const routeLabel = routeSlug(o.route.route);
   const ownDigest = o.runId ? digestPathFor(o.stateDir, routeLabel, o.role, o.runId) : void 0;
-  const digestPath2 = ownDigest && existsSync22(ownDigest) ? ownDigest : digestPathFor(o.stateDir, routeLabel, o.role);
+  const digestPath2 = ownDigest && existsSync23(ownDigest) ? ownDigest : digestPathFor(o.stateDir, routeLabel, o.role);
   let digest;
   let ageSeconds;
-  if (existsSync22(digestPath2)) {
+  if (existsSync23(digestPath2)) {
     ageSeconds = Math.floor((now() - statSync8(digestPath2).mtimeMs) / 1e3);
-    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync20(digestPath2, "utf8");
+    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync21(digestPath2, "utf8");
   }
-  const common = usesCommon ? readFileSync20(commonPath, "utf8") : "";
-  const brief = readFileSync20(briefPath, "utf8");
+  const common = usesCommon ? readFileSync21(commonPath, "utf8") : "";
+  const brief = readFileSync21(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]));
@@ -10179,7 +10370,7 @@ function planAgentRun(o) {
     digest
   });
   const promptSha = createHash4("sha256").update(expanded.text).digest("hex");
-  const streamsDir = join24(o.stateDir, "streams");
+  const streamsDir = join25(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;
@@ -10269,8 +10460,8 @@ function planAgentRun(o) {
     digestAttached: digest !== void 0,
     digestAgeSeconds: ageSeconds,
     model,
-    streamPath: join24(streamsDir, `${base}.jsonl`),
-    eventsPath: join24(streamsDir, `${base}.events.jsonl`),
+    streamPath: join25(streamsDir, `${base}.jsonl`),
+    eventsPath: join25(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
     ticketRecordId: o.ticketRecordId ?? null,
     repo: o.repo ?? null,
@@ -10301,7 +10492,7 @@ function describePlan(p) {
 var pidPathFor = (streamPath) => `${streamPath}.pid`;
 function readRunSidecar(streamPath) {
   try {
-    const sc = JSON.parse(readFileSync20(pidPathFor(streamPath), "utf8"));
+    const sc = JSON.parse(readFileSync21(pidPathFor(streamPath), "utf8"));
     return typeof sc.pid === "number" && typeof sc.spawnedAt === "string" && typeof sc.role === "string" ? sc : null;
   } catch {
     return null;
@@ -10348,7 +10539,7 @@ async function killForDeadline(kill, pid, emit, role, ticket, spawnedAt, limitMi
 var withoutKey = ({ apiKey: _apiKey, ...rest }) => rest;
 function openSink(path) {
   try {
-    mkdirSync14(dirname10(path), { recursive: true });
+    mkdirSync15(dirname11(path), { recursive: true });
     return createWriteStream(path, { flags: "a" });
   } catch {
     return void 0;
@@ -10530,7 +10721,7 @@ var RunObserver = class {
 };
 function writeRunMeta(id, startedAt, liveTicket, extra) {
   try {
-    writeFileSync15(`${id.streamPath}.meta.json`, JSON.stringify({
+    writeFileSync16(`${id.streamPath}.meta.json`, JSON.stringify({
       route: id.route,
       role: id.role,
       hint: id.ticket,
@@ -10690,7 +10881,7 @@ function spawnAgent(plan, emit, hintMoved) {
   const id = identityOf(plan, adapter.harness);
   let streamFd;
   try {
-    mkdirSync14(dirname10(plan.streamPath), { recursive: true });
+    mkdirSync15(dirname11(plan.streamPath), { recursive: true });
     streamFd = openSync3(plan.streamPath, "a");
   } catch (e) {
     void endSink(eventsSink);
@@ -10748,7 +10939,7 @@ function spawnAgent(plan, emit, hintMoved) {
           promptSha: plan.promptSha
         };
         try {
-          writeFileSync15(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
+          writeFileSync16(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
         } catch {
         }
       }
@@ -10862,21 +11053,21 @@ var pidAlive = (pid) => {
 };
 function runFinished(streamPath) {
   const path = `${streamPath}.meta.json`;
-  if (!existsSync23(path)) return false;
+  if (!existsSync24(path)) return false;
   try {
-    return JSON.parse(readFileSync21(path, "utf8")).running !== true;
+    return JSON.parse(readFileSync22(path, "utf8")).running !== true;
   } catch {
     return true;
   }
 }
 function orphanedStreams(o) {
-  const dir = join25(o.stateDir, "streams");
-  if (!existsSync23(dir)) return [];
+  const dir = join26(o.stateDir, "streams");
+  if (!existsSync24(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 = join25(dir, name);
+    const streamPath = join26(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || sidecar.route !== o.routeLabel) continue;
@@ -10929,15 +11120,15 @@ async function reconcileRuns(o) {
 }
 
 // src/live-runs.ts
-import { existsSync as existsSync24, readdirSync as readdirSync10, statSync as statSync9 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync10, statSync as statSync9 } from "fs";
+import { join as join27 } from "path";
 function liveRuns(stateDir, isAlive = runIsAlive) {
-  const dir = join26(stateDir, "streams");
-  if (!existsSync24(dir)) return [];
+  const dir = join27(stateDir, "streams");
+  if (!existsSync25(dir)) return [];
   const out = [];
   for (const name of readdirSync10(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join26(dir, name);
+    const streamPath = join27(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || !isAlive(sidecar)) continue;
@@ -10947,12 +11138,12 @@ function liveRuns(stateDir, isAlive = runIsAlive) {
 }
 function runActivity(stateDir, isAlive = runIsAlive) {
   const activeRuns = liveRuns(stateDir, isAlive).length;
-  const dir = join26(stateDir, "streams");
+  const dir = join27(stateDir, "streams");
   let newest = 0;
-  if (existsSync24(dir)) {
+  if (existsSync25(dir)) {
     for (const name of readdirSync10(dir)) {
       if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-      const streamPath = join26(dir, name);
+      const streamPath = join27(dir, name);
       if (!runFinished(streamPath)) continue;
       try {
         newest = Math.max(newest, statSync9(`${streamPath}.meta.json`).mtimeMs);
@@ -11323,7 +11514,7 @@ function realDeprovisionDeps(cfg, emit, crewHome, getStore) {
     if (host === "windows") return [];
     const ctx = installContext();
     const systemd = detectSystemd();
-    return ["run", "release", "passengers"].flatMap((job) => planInstall(cfg.ship, crewHome, host, systemd, job, ctx).unitPaths).filter((p) => existsSync25(p));
+    return ["run", "release", "passengers"].flatMap((job) => planInstall(cfg.ship, crewHome, host, systemd, job, ctx).unitPaths).filter((p) => existsSync26(p));
   };
   return {
     liveRuns: () => liveRuns(stateDir).map((r) => ({ role: r.role, route: r.route, pid: r.pid, ticketRecordId: r.ticketRecordId ?? void 0, streamPath: r.streamPath })),
@@ -11384,7 +11575,7 @@ function realDeprovisionDeps(cfg, emit, crewHome, getStore) {
     },
     remaining() {
       const left = [];
-      if (existsSync25(cfg.configFile)) left.push(`config ${cfg.configFile}`);
+      if (existsSync26(cfg.configFile)) left.push(`config ${cfg.configFile}`);
       for (const h of forgeHosts()) if (hasForgeToken(cfg.ship.forges, h, stateDir)) left.push(`forge token for ${h}`);
       try {
         for (const k of readdirSync11(keysDir(stateDir))) left.push(`seat key ${k}`);
@@ -11659,7 +11850,7 @@ function makeCachePass(o) {
 // src/passenger-containers.ts
 var realExec2 = (cmd, args, opts) => {
   try {
-    return execFileSync6(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: opts?.timeoutMs });
+    return execFileSync7(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: opts?.timeoutMs });
   } catch (e) {
     const err3 = e;
     const why = [err3.stderr, err3.stdout].map((x) => (x ?? "").trim()).filter(Boolean).join(" / ");
@@ -11939,7 +12130,7 @@ var WARM_MAX_BYTES = 64 * 1024 * 1024;
 var globToRegExp = (glob) => new RegExp(`^${glob.split("*").map((p) => p.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*")}$`);
 function readWarmFiles(dir, ref, patterns) {
   if (patterns.length === 0) return {};
-  const git2 = (args) => execFileSync7("git", ["-C", dir, ...args], { encoding: "utf8", maxBuffer: WARM_MAX_BYTES, stdio: ["ignore", "pipe", "pipe"] });
+  const git2 = (args) => execFileSync8("git", ["-C", dir, ...args], { encoding: "utf8", maxBuffer: WARM_MAX_BYTES, stdio: ["ignore", "pipe", "pipe"] });
   const all = git2(["ls-tree", "-r", "--name-only", ref]).split("\n").filter(Boolean);
   const res = patterns.map(globToRegExp);
   const out = {};
@@ -11992,19 +12183,19 @@ 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) => join27(stateDir, "sandbox-images.json");
+var sandboxStatePath = (stateDir) => join28(stateDir, "sandbox-images.json");
 function readSandboxState(stateDir) {
   try {
-    const v = JSON.parse(readFileSync22(sandboxStatePath(stateDir), "utf8"));
+    const v = JSON.parse(readFileSync23(sandboxStatePath(stateDir), "utf8"));
     return v && typeof v === "object" && !Array.isArray(v) ? v : {};
   } catch {
     return {};
   }
 }
 function writeSandboxState(stateDir, state) {
-  mkdirSync15(stateDir, { recursive: true });
+  mkdirSync16(stateDir, { recursive: true });
   const file = sandboxStatePath(stateDir);
-  writeFileSync16(`${file}.tmp`, `${JSON.stringify(state, null, 2)}
+  writeFileSync17(`${file}.tmp`, `${JSON.stringify(state, null, 2)}
 `);
   renameSync3(`${file}.tmp`, file);
 }
@@ -12024,7 +12215,7 @@ var spawnBuildRunner = (engine = "docker") => (args, logPath) => new Promise((re
   child.stdout.on("data", (d) => chunks.push(d));
   child.stderr.on("data", (d) => chunks.push(d));
   const done = (code, extra = "") => {
-    writeFileSync16(logPath, `$ ${engine} ${args.join(" ")}
+    writeFileSync17(logPath, `$ ${engine} ${args.join(" ")}
 ${Buffer.concat(chunks).toString("utf8")}${extra}`, { flag: "a" });
     resolve8(code);
   };
@@ -12046,7 +12237,7 @@ var engineRemoveImage = (engine = "docker", exec = realExec2) => (tag) => {
   } catch {
   }
 };
-var sandboxLogDir = (stateDir) => join27(stateDir, "sandbox-logs");
+var sandboxLogDir = (stateDir) => join28(stateDir, "sandbox-logs");
 async function buildSandboxImage(plan, deps) {
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const state = readSandboxState(deps.stateDir);
@@ -12055,20 +12246,20 @@ async function buildSandboxImage(plan, deps) {
     return { kind: "reused", tag: plan.tag };
   }
   const logDir = sandboxLogDir(deps.stateDir);
-  mkdirSync15(logDir, { recursive: true });
-  const logPath = join27(logDir, `${slug(plan.repo)}-${now().toISOString().replace(/[:.]/g, "-")}.log`);
+  mkdirSync16(logDir, { recursive: true });
+  const logPath = join28(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 = join27(tmpdir3(), `crew-sandbox-${hash([layer.tag, process.pid, Date.now()])}`);
-    mkdirSync15(ctx, { recursive: true });
+    const ctx = join28(tmpdir3(), `crew-sandbox-${hash([layer.tag, process.pid, Date.now()])}`);
+    mkdirSync16(ctx, { recursive: true });
     try {
-      writeFileSync16(join27(ctx, "Dockerfile"), layer.dockerfile);
+      writeFileSync17(join28(ctx, "Dockerfile"), layer.dockerfile);
       for (const [name, content] of Object.entries(layer.files)) {
-        mkdirSync15(dirname11(join27(ctx, name)), { recursive: true });
-        writeFileSync16(join27(ctx, name), content);
+        mkdirSync16(dirname12(join28(ctx, name)), { recursive: true });
+        writeFileSync17(join28(ctx, name), content);
       }
-      const code = await deps.run(["build", "--tag", layer.tag, "--file", join27(ctx, "Dockerfile"), ctx], logPath);
+      const code = await deps.run(["build", "--tag", layer.tag, "--file", join28(ctx, "Dockerfile"), ctx], logPath);
       if (code !== 0) {
         state[plan.repo] = { ...entry, failure: { tag: plan.tag, at: now().toISOString(), logPath } };
         writeSandboxState(deps.stateDir, state);
@@ -12121,10 +12312,10 @@ async function sandboxBuildTick(repos, deps, force = false) {
 }
 
 // src/doctor-checks.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 var PROBE_BRANCH = "crew-probe-branch";
 var realGit = (cwd, args, env) => {
-  execFileSync8("git", args, { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
+  execFileSync9("git", args, { cwd, env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4 });
 };
 function isSshRemote(url) {
   return /^ssh:\/\//.test(url) || /^[\w.-]+@[\w.-]+:/.test(url);
@@ -12257,9 +12448,9 @@ function managedRuntimeWarnings(kind, ship) {
 
 // src/selftest.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync26, mkdirSync as mkdirSync16, mkdtempSync as mkdtempSync2, readFileSync as readFileSync23, rmSync as rmSync14, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync17, mkdtempSync as mkdtempSync2, readFileSync as readFileSync24, rmSync as rmSync14, writeFileSync as writeFileSync18 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join28 } from "path";
+import { join as join29 } 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: ";
@@ -12420,7 +12611,7 @@ async function runSelftest(i, deps = realDeps) {
     ...adapter.runEnv(spec),
     [KEY_VAR]: i.apiKey
   };
-  const cwd = mkdtempSync2(join28(tmpdir4(), "crew-selftest-"));
+  const cwd = mkdtempSync2(join29(tmpdir4(), "crew-selftest-"));
   try {
     const run3 = await deps.run({
       bin: invocation.bin,
@@ -12453,11 +12644,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) => join28(stateDir, "selftest.json");
+var fileFor2 = (stateDir) => join29(stateDir, "selftest.json");
 function readSelftest(stateDir) {
   try {
     const p = fileFor2(stateDir);
-    return existsSync26(p) ? JSON.parse(readFileSync23(p, "utf8")) : {};
+    return existsSync27(p) ? JSON.parse(readFileSync24(p, "utf8")) : {};
   } catch {
     return {};
   }
@@ -12465,8 +12656,8 @@ function readSelftest(stateDir) {
 function recordSelftest(stateDir, results) {
   const all = readSelftest(stateDir);
   for (const r of results) all[r.toolchain] = r;
-  mkdirSync16(stateDir, { recursive: true });
-  writeFileSync17(fileFor2(stateDir), `${JSON.stringify(all, null, 2)}
+  mkdirSync17(stateDir, { recursive: true });
+  writeFileSync18(fileFor2(stateDir), `${JSON.stringify(all, null, 2)}
 `);
 }
 function doctorSelftestLines(stored, toolchains) {
@@ -12478,7 +12669,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve7, dirname as dirname29, join as join50, basename as basename16 } from "path";
+import { resolve as resolve7, dirname as dirname30, join as join51, basename as basename16 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname4, homedir as homedir11 } from "os";
 import { spawnSync as spawnSync10 } from "child_process";
@@ -12675,14 +12866,14 @@ function rosterMarkdown(roster, meId) {
 }
 
 // src/connect-resume.ts
-import { mkdirSync as mkdirSync17, readFileSync as readFileSync24, rmSync as rmSync15, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname12, join as join29 } from "path";
+import { mkdirSync as mkdirSync18, readFileSync as readFileSync25, rmSync as rmSync15, writeFileSync as writeFileSync19 } from "fs";
+import { dirname as dirname13, join as join30 } from "path";
 function lastSessionFile(stateDir) {
-  return join29(stateDir, "connect-session.json");
+  return join30(stateDir, "connect-session.json");
 }
 function readPointers(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync24(lastSessionFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync25(lastSessionFile(stateDir), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     const out = {};
     for (const [host, v] of Object.entries(parsed)) {
@@ -12696,8 +12887,8 @@ function readPointers(stateDir) {
 }
 function writePointers(stateDir, pointers) {
   const file = lastSessionFile(stateDir);
-  mkdirSync17(dirname12(file), { recursive: true });
-  writeFileSync18(file, `${JSON.stringify(pointers, null, 2)}
+  mkdirSync18(dirname13(file), { recursive: true });
+  writeFileSync19(file, `${JSON.stringify(pointers, null, 2)}
 `, { mode: 384 });
 }
 function rememberSession(stateDir, host, workspaceSlug) {
@@ -12782,15 +12973,15 @@ async function signOutSessions(o) {
 }
 
 // src/reset.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync18, readFileSync as readFileSync25, readdirSync as readdirSync12, rmSync as rmSync16, statSync as statSync10, writeFileSync as writeFileSync19 } from "fs";
-import { dirname as dirname13, join as join30 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync19, readFileSync as readFileSync26, readdirSync as readdirSync12, rmSync as rmSync16, statSync as statSync10, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname14, join as join31 } from "path";
 import { hostFromUrl as hostFromUrl3 } from "@tablation/client";
 function clonedCheckoutsFile(stateDir) {
-  return join30(stateDir, "cloned-checkouts.json");
+  return join31(stateDir, "cloned-checkouts.json");
 }
 function readClonedCheckouts(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync25(clonedCheckoutsFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync26(clonedCheckoutsFile(stateDir), "utf8"));
     return Array.isArray(parsed) ? parsed.filter((d) => typeof d === "string") : [];
   } catch {
     return [];
@@ -12800,8 +12991,8 @@ function recordClonedCheckout(stateDir, dir) {
   const known = readClonedCheckouts(stateDir);
   if (known.includes(dir)) return;
   const file = clonedCheckoutsFile(stateDir);
-  mkdirSync18(dirname13(file), { recursive: true });
-  writeFileSync19(file, `${JSON.stringify([...known, dir], null, 2)}
+  mkdirSync19(dirname14(file), { recursive: true });
+  writeFileSync20(file, `${JSON.stringify([...known, dir], null, 2)}
 `);
 }
 var mark = (dryRun) => dryRun ? "would-remove" : "removed";
@@ -12855,7 +13046,7 @@ async function runReset(o, fx) {
   }
   if (o.beforeState) steps.push(...await o.beforeState());
   steps.push(...o.wipeState ? wipeStateDir(o.stateDir, o.dryRun) : removeState(o.stateDir, o.dryRun));
-  if (existsSync27(o.configFile)) {
+  if (existsSync28(o.configFile)) {
     if (!o.dryRun) rmSync16(o.configFile, { force: true });
     steps.push({ step: "config", target: o.configFile, action: mark(o.dryRun) });
   } else {
@@ -12864,7 +13055,7 @@ async function runReset(o, fx) {
   return steps;
 }
 function removeCheckout(dir, dryRun, fx) {
-  if (!existsSync27(dir)) return { step: "checkout", target: dir, action: "absent", detail: "already gone" };
+  if (!existsSync28(dir)) return { step: "checkout", target: dir, action: "absent", detail: "already gone" };
   const { dirty, linkedWorktrees } = fx.inspectCheckout(dir);
   if (dirty.length) {
     return { step: "checkout", target: dir, action: "kept", detail: `has uncommitted changes (${dirty.length} path${dirty.length === 1 ? "" : "s"}: ${dirty.slice(0, 5).join(", ")}${dirty.length > 5 ? ", \u2026" : ""})` };
@@ -12877,15 +13068,15 @@ function removeCheckout(dir, dryRun, fx) {
 }
 function removeState(stateDir, dryRun) {
   const out = [];
-  const targets = [join30(stateDir, "resolved"), join30(stateDir, "keys"), clonedCheckoutsFile(stateDir), join30(stateDir, "connect-session.json"), join30(stateDir, "reload-requested"), join30(stateDir, "daemon.started")];
+  const targets = [join31(stateDir, "resolved"), join31(stateDir, "keys"), clonedCheckoutsFile(stateDir), join31(stateDir, "connect-session.json"), join31(stateDir, "reload-requested"), join31(stateDir, "daemon.started")];
   try {
     for (const name of readdirSync12(stateDir)) {
-      if (name.startsWith(".") && statSync10(join30(stateDir, name)).isFile()) targets.push(join30(stateDir, name));
+      if (name.startsWith(".") && statSync10(join31(stateDir, name)).isFile()) targets.push(join31(stateDir, name));
     }
   } catch {
   }
   for (const t of targets) {
-    if (!existsSync27(t)) continue;
+    if (!existsSync28(t)) continue;
     if (!dryRun) rmSync16(t, { recursive: true, force: true });
     out.push({ step: "state", target: t, action: mark(dryRun) });
   }
@@ -12900,7 +13091,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) rmSync16(join30(stateDir, n), { recursive: true, force: true });
+  if (!dryRun) for (const n of names) rmSync16(join31(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) {
@@ -12981,9 +13172,9 @@ async function runDeprovision(o, fx, deps) {
 }
 
 // src/pool-member.ts
-import { mkdirSync as mkdirSync19, readFileSync as readFileSync26, renameSync as renameSync4, writeFileSync as writeFileSync20 } from "fs";
+import { mkdirSync as mkdirSync20, readFileSync as readFileSync27, renameSync as renameSync4, writeFileSync as writeFileSync21 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname14, join as join31 } from "path";
+import { dirname as dirname15, join as join32 } from "path";
 var POOL_EXIT = { ok: 0, failed: 1, credential: 2 };
 function backoffMs(attempt) {
   return Math.min(6e4, 5e3 * 2 ** Math.max(0, attempt));
@@ -13214,22 +13405,22 @@ async function runPoolMember(deps) {
   }
 }
 function defaultMemberDir(env = process.env) {
-  return env.CREW_POOL_DIR ?? join31(env.XDG_STATE_HOME ?? join31(homedir8(), ".local", "state"), "crew-pool-member");
+  return env.CREW_POOL_DIR ?? join32(env.XDG_STATE_HOME ?? join32(homedir8(), ".local", "state"), "crew-pool-member");
 }
 function fileMemberStore(dir) {
-  const file = join31(dir, "member.json");
+  const file = join32(dir, "member.json");
   return {
     read() {
       try {
-        return JSON.parse(readFileSync26(file, "utf8"));
+        return JSON.parse(readFileSync27(file, "utf8"));
       } catch {
         return {};
       }
     },
     write(f) {
-      mkdirSync19(dirname14(file), { recursive: true, mode: 448 });
+      mkdirSync20(dirname15(file), { recursive: true, mode: 448 });
       const tmp = `${file}.tmp`;
-      writeFileSync20(tmp, `${JSON.stringify(f)}
+      writeFileSync21(tmp, `${JSON.stringify(f)}
 `, { mode: 384 });
       renameSync4(tmp, file);
     }
@@ -13281,30 +13472,30 @@ function hostArchitecture(arch = process.arch) {
 
 // src/pool-member-host.ts
 import "child_process";
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 import { hostname as hostname3 } from "os";
 
 // src/machine-id.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync28, mkdirSync as mkdirSync20, readFileSync as readFileSync27, writeFileSync as writeFileSync21 } from "fs";
-import { dirname as dirname15, join as join32 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync21, readFileSync as readFileSync28, writeFileSync as writeFileSync22 } from "fs";
+import { dirname as dirname16, join as join33 } from "path";
 function machineIdPathFor(stateDir) {
-  return join32(stateDir, "machine-id");
+  return join33(stateDir, "machine-id");
 }
 var sha256 = (s) => createHash7("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
   try {
     if (platform2 === "darwin") {
-      const out = execFileSync9("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
+      const out = execFileSync10("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"]
       });
       return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(out)?.[1];
     }
     for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
-      if (existsSync28(p)) {
-        const id = readFileSync27(p, "utf8").trim();
+      if (existsSync29(p)) {
+        const id = readFileSync28(p, "utf8").trim();
         if (id) return id;
       }
     }
@@ -13315,15 +13506,15 @@ function readRawMachineId(platform2 = process.platform) {
 function ensureMachineId(stateDir, opts = {}) {
   if (opts.override?.trim()) return sha256(opts.override.trim());
   const path = machineIdPathFor(stateDir);
-  if (existsSync28(path)) {
-    const cached = readFileSync27(path, "utf8").trim();
+  if (existsSync29(path)) {
+    const cached = readFileSync28(path, "utf8").trim();
     if (/^[0-9a-f]{64}$/.test(cached)) return cached;
   }
   const raw = (opts.read ?? readRawMachineId)();
   if (!raw) return void 0;
   const hashed = sha256(raw);
-  mkdirSync20(dirname15(path), { recursive: true });
-  writeFileSync21(path, `${hashed}
+  mkdirSync21(dirname16(path), { recursive: true });
+  writeFileSync22(path, `${hashed}
 `, { mode: 384 });
   return hashed;
 }
@@ -13336,7 +13527,7 @@ function matchShipRows(ships, shipName2, machineId) {
 
 // src/provision.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import { existsSync as existsSync29, readFileSync as readFileSync28, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync29, writeFileSync as writeFileSync23 } from "fs";
 import { hostname as hostname2 } from "os";
 import { parseDocument as parseDocument3, isMap as isMap2, isScalar } from "yaml";
 
@@ -13345,7 +13536,7 @@ import { parseDocument as parseDocument2 } from "yaml";
 
 // src/repos-cmd.ts
 import { homedir as homedir9 } from "os";
-import { basename as basename10, join as join33, resolve as resolve4 } from "path";
+import { basename as basename10, join as join34, resolve as resolve4 } from "path";
 import { isMap, isSeq, parseDocument, stringify as stringify2 } from "yaml";
 var ReposError = class extends Error {
 };
@@ -13623,7 +13814,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) : join33(expandDir(basePath, i.base), i.route.split("/")[0], name);
+  const target = i.dir ? expandDir(i.dir, i.base) : join34(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 } : {} };
@@ -13930,7 +14121,7 @@ function realProvisionDeps(crewHome) {
   };
   const configFile = () => {
     const f = findConfigFile(crewHome);
-    return existsSync29(f) ? f : null;
+    return existsSync30(f) ? f : null;
   };
   return {
     crew: spawnCrew,
@@ -13938,13 +14129,13 @@ function realProvisionDeps(crewHome) {
     enableRoute(route2) {
       const file = configFile();
       if (!file) return false;
-      const text2 = readFileSync28(file, "utf8");
+      const text2 = readFileSync29(file, "utf8");
       const doc = parseDocument3(text2);
       const routes = doc.get("routes");
       const entry = routes?.items?.find((r) => r.get("route") === route2);
       if (!entry) throw new Error(`route ${route2} is not in ${file}`);
       if (entry.get("enabled") === true) return false;
-      writeFileSync22(file, planEnable(text2, route2));
+      writeFileSync23(file, planEnable(text2, route2));
       return true;
     },
     installState() {
@@ -13964,14 +14155,14 @@ function realProvisionDeps(crewHome) {
           continue;
         }
         for (const p of plan.unitPaths) {
-          if (!existsSync29(p) || readFileSync28(p, "utf8") !== plan.unitContent[p]) unitsStale = true;
+          if (!existsSync30(p) || readFileSync29(p, "utf8") !== plan.unitContent[p]) unitsStale = true;
         }
       }
       const label = labelFor(crewHome, "run");
       let running = false;
       let lingering = true;
       if (mechanism === "systemd") {
-        const system = ctx.root || existsSync29(systemUnitPathFor(label));
+        const system = ctx.root || existsSync30(systemUnitPathFor(label));
         const ctl = system ? ["systemctl"] : ["systemctl", "--user"];
         running = spawnSync7(ctl[0], [...ctl.slice(1), "is-active", "--quiet", `${label}.service`]).status === 0;
         if (!system) {
@@ -13988,18 +14179,18 @@ function realProvisionDeps(crewHome) {
     setShipSetting(key, value2) {
       const file = configFile();
       if (!file) return false;
-      const doc = parseDocument3(readFileSync28(file, "utf8"));
+      const doc = parseDocument3(readFileSync29(file, "utf8"));
       if (doc.getIn(["ship", key]) === value2) return false;
       doc.setIn(["ship", key], value2);
-      writeFileSync22(file, doc.toString());
+      writeFileSync23(file, doc.toString());
       return true;
     },
     applyManagedDefaults() {
       const file = configFile();
       if (!file) return [];
-      const doc = parseDocument3(readFileSync28(file, "utf8"));
+      const doc = parseDocument3(readFileSync29(file, "utf8"));
       const wrote = applyManagedDefaultsToDoc(doc);
-      if (wrote.length) writeFileSync22(file, doc.toString());
+      if (wrote.length) writeFileSync23(file, doc.toString());
       return wrote;
     },
     storedToken(host) {
@@ -14016,9 +14207,9 @@ host=${host}
 
 // src/tunnel.ts
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync30, mkdirSync as mkdirSync21, readFileSync as readFileSync29, writeFileSync as writeFileSync23, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync22, readFileSync as readFileSync30, writeFileSync as writeFileSync24, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
 import { randomInt } from "crypto";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn6(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -14090,21 +14281,21 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join34(stateDir, "passengers", `${workspaceId}.json`);
+  return join35(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
-  if (!existsSync30(path)) return void 0;
+  if (!existsSync31(path)) return void 0;
   try {
-    return JSON.parse(readFileSync29(path, "utf8"));
+    return JSON.parse(readFileSync30(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync21(join34(stateDir, "passengers"), { recursive: true });
-  writeFileSync23(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync22(join35(stateDir, "passengers"), { recursive: true });
+  writeFileSync24(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function updatePersistedTunnel(stateDir, workspaceId, patch2) {
@@ -14206,8 +14397,8 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join34(stateDir, "passengers");
-  if (!existsSync30(dir)) return [];
+  const dir = join35(stateDir, "passengers");
+  if (!existsSync31(dir)) return [];
   return readdirSync13(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
@@ -14232,7 +14423,7 @@ function realPoolMemberDeps(o) {
       crewVersion: crewVersion(o.crewHome),
       hostname: hostname3()
     },
-    hasShipConfig: () => existsSync31(findConfigFile(o.crewHome)),
+    hasShipConfig: () => existsSync32(findConfigFile(o.crewHome)),
     async provision(lease, instanceClass, shipKind) {
       const hosts = lease.forges.map((f) => f.host.toLowerCase());
       const lines2 = [];
@@ -15108,8 +15299,8 @@ ${waiting.map((t) => `| ${displayKey2(t)} | ${t.status} | ${blockers(t, i)} |`).
 }
 
 // src/poll.ts
-import { writeFileSync as writeFileSync24 } from "fs";
-import { join as join35 } from "path";
+import { writeFileSync as writeFileSync25 } from "fs";
+import { join as join36 } from "path";
 
 // src/stalled.ts
 var STALLED_AFTER_CYCLES = 30;
@@ -15416,7 +15607,7 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route2, role, runId) => join35(stateDir, `digest-${route2}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPath = (stateDir, route2, role, runId) => join36(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));
@@ -15494,7 +15685,7 @@ function writeDigest(o, d, role, stateDir, runId, own) {
 
 ${body}` : body;
     const path = digestPath(stateDir, routeSlug(o.route.route), role, runId);
-    writeFileSync24(path, text2);
+    writeFileSync25(path, text2);
     o.emit.emit(`queue digest written for ${role} (${Buffer.byteLength(text2)} bytes)`, {
       data: { role, bytes: Buffer.byteLength(text2) }
     });
@@ -15602,8 +15793,8 @@ async function resolveOne(tracker, t, seat, approvedStatus, buildingStatus, affi
 }
 
 // src/repo-refresh.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync22, readFileSync as readFileSync30, writeFileSync as writeFileSync25 } from "fs";
-import { dirname as dirname17 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync23, readFileSync as readFileSync31, writeFileSync as writeFileSync26 } from "fs";
+import { dirname as dirname18 } from "path";
 var REFRESH_COOLDOWN_MS = 2 * 6e4;
 var UNSERVABLE_PASSES_BEFORE_ATTENTION = 3;
 var lastAsked = /* @__PURE__ */ new Map();
@@ -15632,11 +15823,11 @@ function applyRepoRows(resolved, rows) {
 }
 function persistRepoRows(stateDir, routeName, rows) {
   const path = resolvedPathFor(stateDir, routeName);
-  if (!existsSync32(path)) return;
-  const raw = JSON.parse(readFileSync30(path, "utf8"));
+  if (!existsSync33(path)) return;
+  const raw = JSON.parse(readFileSync31(path, "utf8"));
   applyRepoRows(raw, rows);
-  mkdirSync22(dirname17(path), { recursive: true });
-  writeFileSync25(path, `${JSON.stringify(raw, null, 2)}
+  mkdirSync23(dirname18(path), { recursive: true });
+  writeFileSync26(path, `${JSON.stringify(raw, null, 2)}
 `);
 }
 async function refreshUnknownRepos(o) {
@@ -16086,13 +16277,13 @@ Ship ${shipName2} found: ${problem}. The release refuses to squash a ref nobody
 var localRefSkipReported = (ticket, problem, events) => events.some((e) => e.record_id === ticket.id && e.event_type === "local_ref_skip" && (e.message ?? "").includes(problem));
 
 // src/connect-wizard.ts
-import { delimiter, dirname as dirname18, join as join36 } from "path";
-import { accessSync as accessSync3, constants as constants3, existsSync as existsSync33, mkdirSync as mkdirSync23, writeFileSync as writeFileSync26 } from "fs";
+import { delimiter, dirname as dirname19, join as join37 } from "path";
+import { accessSync as accessSync3, constants as constants3, existsSync as existsSync34, mkdirSync as mkdirSync24, writeFileSync as writeFileSync27 } from "fs";
 import { stringify as stringify3 } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
 function shouldRunWizard(opts) {
   if (!opts.isTTY) return false;
-  const exists = opts.configExists ?? existsSync33;
+  const exists = opts.configExists ?? existsSync34;
   return !configSearchPath(opts.crewHome).some((p) => exists(p));
 }
 function firstRunConfigPath() {
@@ -16109,7 +16300,7 @@ function defaultIsExecutable(p) {
 function findOnPath2(name, pathEnv, isExecutable = defaultIsExecutable) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join36(dir, name);
+    const candidate = join37(dir, name);
     if (isExecutable(candidate)) return candidate;
   }
   return void 0;
@@ -16135,9 +16326,9 @@ async function runWizard(p, env) {
     if (entered && isExec(entered)) agentBin = entered;
     else p.say(entered ? `${entered} is not an executable file.` : "A path is required.");
   }
-  const nodeDir = dirname18(env.nodePath);
+  const nodeDir = dirname19(env.nodePath);
   const pnpmPath = findOnPath2("pnpm", env.pathEnv, isExec);
-  const baseDirs = [nodeDir, pnpmPath ? dirname18(pnpmPath) : void 0];
+  const baseDirs = [nodeDir, pnpmPath ? dirname19(pnpmPath) : void 0];
   p.say(
     `
 Host Passengers lets this machine run the agent sessions that other people's
@@ -16148,7 +16339,7 @@ Tablation workspaces ask for, in a container. More: ${HOST_PASSENGERS_DOCS_URL}`
     p.say("Docker is not available here, so nothing will be hosted until it is. Your answer is recorded anyway.");
   }
   const dockerPath = hostPassengers ? findOnPath2("docker", env.pathEnv, isExec) : void 0;
-  const extraPath = deriveExtraPath([...baseDirs, dockerPath ? dirname18(dockerPath) : void 0]);
+  const extraPath = deriveExtraPath([...baseDirs, dockerPath ? dirname19(dockerPath) : void 0]);
   if (extraPath) {
     p.say(`Hooks will get ${extraPath} on their PATH (where node, pnpm${dockerPath ? " and docker" : ""} live).`);
   }
@@ -16170,9 +16361,9 @@ routes:
 ${routeBlock}`;
 }
 function writeNewConfig(path, text2) {
-  mkdirSync23(dirname18(path), { recursive: true });
+  mkdirSync24(dirname19(path), { recursive: true });
   try {
-    writeFileSync26(path, text2, { mode: 384, flag: "wx" });
+    writeFileSync27(path, text2, { mode: 384, flag: "wx" });
     return true;
   } catch (e) {
     if (e.code === "EEXIST") return false;
@@ -16206,7 +16397,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 dirname19, join as join37 } from "path";
+import { dirname as dirname20, join as join38 } from "path";
 import { delimiter as delimiter2 } from "path";
 var CHOICE_EXIT_CODE = 3;
 function createEmitter(json2, write) {
@@ -16245,12 +16436,12 @@ function agentBinSearchDirs(home, pathEnv, extraPath) {
   const dirs = [
     ...pathEnv.split(delimiter2),
     ...(extraPath ?? "").split(delimiter2),
-    join37(home, ".local/bin"),
-    join37(home, ".claude/local"),
+    join38(home, ".local/bin"),
+    join38(home, ".claude/local"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
-    join37(home, ".npm-global/bin"),
-    join37(home, ".volta/bin")
+    join38(home, ".npm-global/bin"),
+    join38(home, ".volta/bin")
   ];
   return [...new Set(dirs.filter(Boolean))];
 }
@@ -16272,7 +16463,7 @@ function flagWizardAnswers(f, env) {
   const agentBin = f.agentBin ?? found?.bin;
   const pnpmPath = findOnPath2("pnpm", env.pathEnv, isExec);
   const dockerPath = f.hostPassengers ? findOnPath2("docker", env.pathEnv, isExec) : void 0;
-  const extraPath = f.extraPath ?? deriveExtraPath([dirname19(env.nodePath), pnpmPath ? dirname19(pnpmPath) : void 0, dockerPath ? dirname19(dockerPath) : void 0]);
+  const extraPath = f.extraPath ?? deriveExtraPath([dirname20(env.nodePath), pnpmPath ? dirname20(pnpmPath) : void 0, dockerPath ? dirname20(dockerPath) : void 0]);
   return {
     answers: {
       name: f.shipName?.trim() || env.hostname,
@@ -16286,8 +16477,8 @@ function flagWizardAnswers(f, env) {
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync27, existsSync as existsSync34, copyFileSync, mkdirSync as mkdirSync24, mkdtempSync as mkdtempSync3, rmSync as rmSync17 } from "fs";
-import { dirname as dirname20, join as join38 } from "path";
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync28, existsSync as existsSync35, copyFileSync, mkdirSync as mkdirSync25, mkdtempSync as mkdtempSync3, rmSync as rmSync17 } from "fs";
+import { dirname as dirname21, join as join39 } from "path";
 import { tmpdir as tmpdir5 } from "os";
 
 // src/release.ts
@@ -17028,13 +17219,13 @@ async function bump(o, size) {
     }
     return printed;
   }
-  const files = o.repo.release.versionFiles.map((f) => join38(o.cwd, f));
+  const files = o.repo.release.versionFiles.map((f) => join39(o.cwd, f));
   const first = files[0];
-  if (!existsSync34(first)) {
+  if (!existsSync35(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
     return null;
   }
-  const current = JSON.parse(readFileSync31(first, "utf8")).version;
+  const current = JSON.parse(readFileSync32(first, "utf8")).version;
   if (!current) {
     o.emit.error(`no version field in ${o.repo.release.versionFiles[0]}`);
     return null;
@@ -17047,27 +17238,27 @@ async function bump(o, size) {
     return version;
   }
   for (const f of files) {
-    const src = readFileSync31(f, "utf8");
+    const src = readFileSync32(f, "utf8");
     const out = src.replace(/("version"\s*:\s*")[^"]*(")/, `$1${version}$2`);
     if (out === src) {
       o.emit.error(`no version field in ${f}`);
       return null;
     }
-    writeFileSync27(f, out);
+    writeFileSync28(f, out);
   }
   return version;
 }
 function writeChangelog(o, version, entries) {
   const file = o.repo.release.changelog;
   if (!file || entries.length === 0) return;
-  const path = join38(o.cwd, file);
+  const path = join39(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 = existsSync34(path) ? readFileSync31(path, "utf8") : "# Changelog\n";
-  writeFileSync27(path, insertChangelogSection(existing, section));
+  const existing = existsSync35(path) ? readFileSync32(path, "utf8") : "# Changelog\n";
+  writeFileSync28(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
   if (!o.repo.hooks.released) return void 0;
@@ -17160,8 +17351,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(join38(tmpdir5(), "crew-release-"));
-  const dir = join38(root, "checkout");
+  const root = mkdtempSync3(join39(tmpdir5(), "crew-release-"));
+  const dir = join39(root, "checkout");
   o.emit.emit(`release checkout: ${dir}`, { step: "release" });
   const close = () => closeReleaseCheckout(o.cwd, root, dir, branch);
   try {
@@ -17171,10 +17362,10 @@ function openReleaseCheckout(o) {
     throw e;
   }
   for (const f of o.repo.worktrees.copy) {
-    const src = join38(o.cwd, f);
-    if (!existsSync34(src)) continue;
-    mkdirSync24(dirname20(join38(dir, f)), { recursive: true });
-    copyFileSync(src, join38(dir, f));
+    const src = join39(o.cwd, f);
+    if (!existsSync35(src)) continue;
+    mkdirSync25(dirname21(join39(dir, f)), { recursive: true });
+    copyFileSync(src, join39(dir, f));
   }
   return { dir, branch, close };
 }
@@ -17764,6 +17955,49 @@ 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) {
@@ -18153,7 +18387,7 @@ function missingReleaserWarning(repo, release, ships, now = Date.now()) {
 }
 
 // src/watch.ts
-import { watch as watchFile, existsSync as existsSync35, statSync as statSync11, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
+import { watch as watchFile, existsSync as existsSync36, statSync as statSync11, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
 var E = "\x1B[";
 var dim = (s) => `${E}2m${s}${E}0m`;
 var bold = (s) => `${E}1m${s}${E}0m`;
@@ -18254,7 +18488,7 @@ function renderHeaders(states, now = Date.now()) {
   return states.map((s) => renderHeader(s, now)).join("");
 }
 function readFrom(file, from) {
-  if (!existsSync35(file)) return { events: [], offset: from };
+  if (!existsSync36(file)) return { events: [], offset: from };
   const size = statSync11(file).size;
   if (size < from) return readFrom(file, 0);
   if (size === from) return { events: [], offset: from };
@@ -18497,8 +18731,8 @@ function nextRoles(decision, ran) {
 }
 
 // src/ship-name.ts
-import { existsSync as existsSync36, mkdirSync as mkdirSync25, readFileSync as readFileSync32, renameSync as renameSync5, writeFileSync as writeFileSync28 } from "fs";
-import { dirname as dirname21 } from "path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync26, readFileSync as readFileSync33, renameSync as renameSync5, writeFileSync as writeFileSync29 } from "fs";
+import { dirname as dirname22 } from "path";
 import { parseDocument as parseDocument5 } from "yaml";
 var ShipNameError = class extends Error {
 };
@@ -18559,34 +18793,34 @@ async function syncRouteName(i) {
   return { status: "ok", ...base, action, name: i.local };
 }
 function readSyncedName(resolvedFile) {
-  if (!existsSync36(resolvedFile)) return void 0;
+  if (!existsSync37(resolvedFile)) return void 0;
   try {
-    const v = JSON.parse(readFileSync32(resolvedFile, "utf8")).shipName;
+    const v = JSON.parse(readFileSync33(resolvedFile, "utf8")).shipName;
     return typeof v === "string" ? v : void 0;
   } catch {
     return void 0;
   }
 }
 function writeSyncedName(resolvedFile, name) {
-  if (!existsSync36(resolvedFile)) return;
+  if (!existsSync37(resolvedFile)) return;
   let raw;
   try {
-    raw = JSON.parse(readFileSync32(resolvedFile, "utf8"));
+    raw = JSON.parse(readFileSync33(resolvedFile, "utf8"));
   } catch {
     return;
   }
   if (raw.shipName === name) return;
   raw.shipName = name;
-  mkdirSync25(dirname21(resolvedFile), { recursive: true });
+  mkdirSync26(dirname22(resolvedFile), { recursive: true });
   const tmp = `${resolvedFile}.tmp${process.pid}`;
-  writeFileSync28(tmp, `${JSON.stringify(raw, null, 2)}
+  writeFileSync29(tmp, `${JSON.stringify(raw, null, 2)}
 `);
   renameSync5(tmp, resolvedFile);
 }
 async function reconcileShipName(i) {
   let local = i.ship.name;
   try {
-    local = shipNameOfYaml(readFileSync32(i.configFile, "utf8")) ?? local;
+    local = shipNameOfYaml(readFileSync33(i.configFile, "utf8")) ?? local;
   } catch {
   }
   const resolvedFile = resolvedPathFor(i.stateDir, i.route);
@@ -18610,8 +18844,8 @@ async function reconcileShipName(i) {
   }
   if (result.status !== "ok") return result;
   if (result.action === "adopt" || result.action === "row-wins") {
-    const text2 = readFileSync32(i.configFile, "utf8");
-    writeFileSync28(i.configFile, setShipNameInYaml(text2, result.name));
+    const text2 = readFileSync33(i.configFile, "utf8");
+    writeFileSync29(i.configFile, setShipNameInYaml(text2, result.name));
     i.ship.name = result.name;
     if (result.action === "row-wins") {
       i.emit?.warn(
@@ -19270,8 +19504,8 @@ function describeCapability(i) {
 }
 
 // src/agents-sync-run.ts
-import { existsSync as existsSync37, mkdirSync as mkdirSync26, readFileSync as readFileSync33, writeFileSync as writeFileSync29 } from "fs";
-import { dirname as dirname22 } from "path";
+import { existsSync as existsSync38, mkdirSync as mkdirSync27, readFileSync as readFileSync34, writeFileSync as writeFileSync30 } from "fs";
+import { dirname as dirname23 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
   const force = o.force ?? false;
@@ -19304,12 +19538,12 @@ async function runAgentsSync(target, o) {
   for (const s of skillResult?.outcomes ?? []) o.say(describeSkillSyncOutcome(s));
   if (!dryRun) {
     const resolvedPath = resolvedPathFor(o.stateDir, target.route);
-    const raw = existsSync37(resolvedPath) ? JSON.parse(readFileSync33(resolvedPath, "utf8")) : {};
+    const raw = existsSync38(resolvedPath) ? JSON.parse(readFileSync34(resolvedPath, "utf8")) : {};
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
-    mkdirSync26(dirname22(resolvedPath), { recursive: true });
-    writeFileSync29(resolvedPath, `${JSON.stringify(raw, null, 2)}
+    mkdirSync27(dirname23(resolvedPath), { recursive: true });
+    writeFileSync30(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
     if (target.resolved) {
       target.resolved.agentPersonas = personaResult.agentPersonas;
@@ -19413,7 +19647,7 @@ async function showLogEntry(route2, entryId, opts = {}) {
 
 // src/repos-check.ts
 import { spawnSync as spawnSync9 } from "child_process";
-import { readFileSync as readFileSync34 } from "fs";
+import { readFileSync as readFileSync35 } from "fs";
 import { basename as basename11 } from "path";
 var POSIX_SHELL = /^(?:ba|z|da|k|a|mk)?sh$|^fish$/;
 function checkHookSyntax(script, shell) {
@@ -19454,7 +19688,7 @@ function checkRepoSpec(dir, opts = {}) {
   }
   let parsed;
   try {
-    parsed = parseRepoConfig(readFileSync34(file, "utf8"), file);
+    parsed = parseRepoConfig(readFileSync35(file, "utf8"), file);
   } catch (e) {
     if (!(e instanceof RepoConfigError)) throw e;
     return { ...empty, file, error: e.message, exitCode: 1 };
@@ -19733,7 +19967,7 @@ function existingRepoConfig(f) {
 }
 
 // src/repos-hooks-agent.ts
-import { spawn as spawn7, execFileSync as execFileSync10 } from "child_process";
+import { spawn as spawn7, execFileSync as execFileSync11 } from "child_process";
 import { realpathSync as realpathSync2 } from "fs";
 import { isAbsolute as isAbsolute3, relative } from "path";
 var AgentSuggestError = class extends Error {
@@ -19836,7 +20070,7 @@ function classifyFailure(o) {
 }
 function porcelain(dir) {
   try {
-    return execFileSync10("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: dir, encoding: "utf8" });
+    return execFileSync11("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: dir, encoding: "utf8" });
   } catch {
     return void 0;
   }
@@ -19905,7 +20139,7 @@ ${run3.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename12, dirname as dirname23, join as join39 } from "path";
+import { basename as basename12, dirname as dirname24, join as join40 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -19928,8 +20162,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 join39(dirname23(existing[0]), SAMPLE_REPO);
-  return join39(reposBase, workspace, SAMPLE_REPO);
+  if (existing.length > 0) return join40(dirname24(existing[0]), SAMPLE_REPO);
+  return join40(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
 function sampleDescription() {
@@ -19973,8 +20207,8 @@ function planSampleTicket(i) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync38, readFileSync as readFileSync35, readdirSync as readdirSync14 } from "fs";
-import { basename as basename13, dirname as dirname24, join as join40, resolve as resolve5 } from "path";
+import { existsSync as existsSync39, readFileSync as readFileSync36, readdirSync as readdirSync14 } from "fs";
+import { basename as basename13, dirname as dirname25, join as join41, 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;
@@ -20038,7 +20272,7 @@ function worktreeTicketNumbers(target) {
   return [...nums];
 }
 function siblingWorktreeDirs(target) {
-  const parent = dirname24(target.dir.replace(/[/\\]+$/, ""));
+  const parent = dirname25(target.dir.replace(/[/\\]+$/, ""));
   const stem = `${basename13(target.dir.replace(/[/\\]+$/, ""))}-`;
   const registered = new Set(worktrees(target.dir).map((w) => resolve5(w.path)));
   let names;
@@ -20051,7 +20285,7 @@ function siblingWorktreeDirs(target) {
   for (const name of names) {
     if (!name.startsWith(stem)) continue;
     const m = DIR_NUMBER_SUFFIXED.exec(name);
-    const path = join40(parent, name);
+    const path = join41(parent, name);
     if (m && !registered.has(resolve5(path))) out.push({ path, number: m[1] });
   }
   return out;
@@ -20086,7 +20320,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
   let removed = 0;
   let keptBranches = 0;
   for (const a of actions) {
-    if (!dryRun && base && !a.keepBranch && existsSync38(a.path) && isHandBackMerge(a.path, base)) {
+    if (!dryRun && base && !a.keepBranch && existsSync39(a.path) && isHandBackMerge(a.path, base)) {
       if (gitOk(a.path, ["merge", "--abort"]) !== null) {
         log.emit(
           `abandoned the hand-back merge of ${base} in ${a.path}: ${a.ticket.issue_id} deployed without it`,
@@ -20094,7 +20328,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         );
       }
     }
-    if (!dryRun && existsSync38(a.path)) {
+    if (!dryRun && existsSync39(a.path)) {
       let dirty = false;
       try {
         dirty = status(a.path).length > 0;
@@ -20105,7 +20339,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         continue;
       }
     }
-    if (!dryRun && a.requirePushed && a.branch && existsSync38(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
+    if (!dryRun && a.requirePushed && a.branch && existsSync39(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
       refuse(a, "unpushed commits", `${a.branch} has commits that are not on ${remote}`);
       continue;
     }
@@ -20154,7 +20388,7 @@ function isHandBackMerge(path, base) {
   if (!msgPath) return false;
   let first;
   try {
-    first = readFileSync35(resolve5(path, msgPath), "utf8").split("\n")[0] ?? "";
+    first = readFileSync36(resolve5(path, msgPath), "utf8").split("\n")[0] ?? "";
   } catch {
     return false;
   }
@@ -20259,14 +20493,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync39, readdirSync as readdirSync15, rmSync as rmSync18, statSync as statSync12 } from "fs";
-import { join as join41 } from "path";
+import { existsSync as existsSync40, readdirSync as readdirSync15, rmSync as rmSync18, statSync as statSync12 } from "fs";
+import { join as join42 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join41(stateDir, "streams");
-  if (!existsSync39(dir)) return [];
+  const dir = join42(stateDir, "streams");
+  if (!existsSync40(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync15(dir).map((name) => join41(dir, name)).filter((path) => {
+  return readdirSync15(dir).map((name) => join42(dir, name)).filter((path) => {
     try {
       return statSync12(path).mtimeMs < cutoff;
     } catch {
@@ -20292,9 +20526,9 @@ function applyStreamSweep(paths, dryRun, log) {
   return removed;
 }
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
-  if (!existsSync39(stateDir)) return [];
+  if (!existsSync40(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync15(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join41(stateDir, name)).filter((path) => {
+  return readdirSync15(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join42(stateDir, name)).filter((path) => {
     try {
       return statSync12(path).mtimeMs < cutoff;
     } catch {
@@ -20304,12 +20538,12 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync41, existsSync as existsSync46, mkdirSync as mkdirSync33, writeFileSync as writeFileSync34, rmSync as rmSync23, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync6, statSync as statSync16, readdirSync as readdirSync20 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync42, existsSync as existsSync47, mkdirSync as mkdirSync34, writeFileSync as writeFileSync35, rmSync as rmSync23, 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 existsSync40, mkdirSync as mkdirSync27, readFileSync as readFileSync36, rmSync as rmSync19, writeFileSync as writeFileSync30 } from "fs";
-import { join as join42 } from "path";
+import { existsSync as existsSync41, mkdirSync as mkdirSync28, readFileSync as readFileSync37, rmSync as rmSync19, writeFileSync as writeFileSync31 } from "fs";
+import { join as join43 } from "path";
 var PeriscopeError = class extends Error {
 };
 var LivePeriscopeError = class extends PeriscopeError {
@@ -20319,28 +20553,29 @@ var LivePeriscopeError = class extends PeriscopeError {
     this.data = { refused: "live_periscope_exists", ...live };
   }
 };
-var priorDir = (stateDir) => join42(stateDir, "periscope-priors");
-var priorPath = (stateDir, ticketRecordId) => join42(priorDir(stateDir), `${ticketRecordId}.json`);
+var priorDir = (stateDir) => join43(stateDir, "periscope-priors");
+var priorPath = (stateDir, ticketRecordId) => join43(priorDir(stateDir), `${ticketRecordId}.json`);
 function removePeriscopePrior(stateDir, ticketRecordId) {
   rmSync19(priorPath(stateDir, ticketRecordId), { force: true });
 }
 function writePeriscopePrior(stateDir, ticketRecordId, prior) {
   try {
-    mkdirSync27(priorDir(stateDir), { recursive: true });
-    writeFileSync30(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
+    mkdirSync28(priorDir(stateDir), { recursive: true });
+    writeFileSync31(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
   } catch {
   }
 }
 function readPeriscopePrior(stateDir, ticketRecordId) {
   try {
     const p = priorPath(stateDir, ticketRecordId);
-    return existsSync40(p) ? JSON.parse(readFileSync36(p, "utf8")) : void 0;
+    return existsSync41(p) ? JSON.parse(readFileSync37(p, "utf8")) : void 0;
   } catch {
     return void 0;
   }
 }
 var DEFAULT_MAX_PERISCOPES2 = 3;
 var DEFAULT_PERISCOPE_IDLE_MINUTES2 = 120;
+var DEFAULT_INTEL_STARTUP_SECONDS2 = 20;
 function parsePeriscopeUpArgs(positional2, flags) {
   const usage2 = "usage: crew periscope up [[route] REPO] [--topic TEXT | --issue NNN] [--isolate] [--host HOST] [--assignee CREW_ROW_ID] [--requested-by ID] [--no-open] [--json]";
   const rest = positional2.slice(2);
@@ -20408,12 +20643,15 @@ function openerFor(platform2) {
   return platform2 === "darwin" ? "open" : platform2 === "linux" ? "xdg-open" : void 0;
 }
 function upOutput(res, terminal) {
-  return terminal ? `${res.ticket}
+  const block = terminal ? `${res.ticket}
 ${res.url}
 ${res.worktree}
 ` : `${res.ticket}
 ${res.worktree}
 ${res.url}
+`;
+  return `${block}
+${res.codeTools}
 `;
 }
 function shouldOpen(f) {
@@ -20510,6 +20748,23 @@ ${tail(preview?.output ?? "")}`);
   if (!url) return abandon(`preview printed no URL as its last line
 ${tail(preview.output)}`);
   d.say("preview", `preview at ${url}`, { url });
+  const intel = await probeIntel(
+    { runHook: (e) => d.runHook("intel", wt.path, e) },
+    env,
+    d.intelStartupSeconds ?? DEFAULT_INTEL_STARTUP_SECONDS2
+  );
+  if (intel.state === "ready") d.say("intel", `symbol service at ${intel.url} (${intel.tools.length} tools)`, { intelUrl: intel.url, intelTools: intel.tools });
+  else if (intel.state === "failed") d.say("warning", `symbol service not started: ${intel.reason}`);
+  let codeOutcome = intel;
+  if (intel.state === "ready" && d.registerCode) {
+    try {
+      for (const why of d.registerCode(wt.path, intel.url).skipped) d.say("warning", why);
+    } catch (e) {
+      codeOutcome = { state: "failed", reason: `registering it failed: ${e.message}` };
+      d.say("warning", `symbol service not registered: ${e.message}`);
+    }
+  }
+  const codeTools = codeToolsParagraph(codeOutcome);
   const now = d.now();
   let row;
   try {
@@ -20541,6 +20796,7 @@ ${tail(preview.output)}`);
       host: d.host,
       state: "live",
       isolated: args.isolate,
+      ...intel.state === "ready" ? { intelUrl: intel.url, intelTools: intel.tools } : {},
       startedAt: now.toISOString(),
       lastActivityAt: now.toISOString(),
       expiresAt: new Date(now.getTime() + d.caps.idleMinutes * 6e4).toISOString()
@@ -20558,6 +20814,7 @@ ${tail(preview.output)}`);
     branch: wt.branch,
     url,
     periscopeRecordId: row.id,
+    codeTools,
     ...prior ? { existing: true, priorStatus: prior.status } : {}
   };
 }
@@ -20737,9 +20994,9 @@ ${tail2(preview.output)}`);
 }
 
 // src/periscope-idle.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 import { statSync as statSync13 } from "fs";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 var MAX_SCANNED_FILES = 2e4;
 function newestWorktreeMtime(root) {
   const a = newestTrackedMtime(root);
@@ -20749,7 +21006,7 @@ function newestWorktreeMtime(root) {
 function newestTrackedMtime(root) {
   let listing;
   try {
-    listing = execFileSync11("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+    listing = execFileSync12("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
       cwd: root,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -20764,7 +21021,7 @@ function newestTrackedMtime(root) {
     if (!rel) continue;
     if (++scanned > MAX_SCANNED_FILES) break;
     try {
-      const m = statSync13(join43(root, rel)).mtimeMs;
+      const m = statSync13(join44(root, rel)).mtimeMs;
       if (newest === null || m > newest) newest = m;
     } catch {
     }
@@ -20839,21 +21096,21 @@ async function runPeriscopeIdlePass(d) {
 import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
-import { execFileSync as execFileSync12 } from "child_process";
-import { existsSync as existsSync41, mkdirSync as mkdirSync28, readFileSync as readFileSync37, chmodSync as chmodSync3 } from "fs";
-import { dirname as dirname25, join as join44 } from "path";
+import { execFileSync as execFileSync13 } from "child_process";
+import { existsSync as existsSync42, mkdirSync as mkdirSync29, readFileSync as readFileSync38, chmodSync as chmodSync3 } from "fs";
+import { dirname as dirname26, join as join45 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join44(stateDir, "ssh", "id_ed25519");
+  return join45(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync41(privateKeyPath)) {
-    mkdirSync28(dirname25(privateKeyPath), { recursive: true });
+  if (!existsSync42(privateKeyPath)) {
+    mkdirSync29(dirname26(privateKeyPath), { recursive: true });
     try {
-      execFileSync12("ssh-keygen", [
+      execFileSync13("ssh-keygen", [
         "-t",
         "ed25519",
         "-N",
@@ -20871,15 +21128,15 @@ function ensureShipSshKeypair(stateDir) {
     }
     chmodSync3(privateKeyPath, 384);
   }
-  if (!existsSync41(publicKeyPath)) {
+  if (!existsSync42(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync37(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync38(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
   try {
-    execFileSync12("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
+    execFileSync13("ssh-keygen", ["-V"], { stdio: ["ignore", "ignore", "ignore"] });
     return true;
   } catch (e) {
     return e.code !== "ENOENT";
@@ -21038,12 +21295,12 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn8 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync42, mkdirSync as mkdirSync30, readFileSync as readFileSync38, writeFileSync as writeFileSync31, unlinkSync as unlinkSync4, readdirSync as readdirSync16 } from "fs";
-import { join as join45 } from "path";
+import { existsSync as existsSync43, mkdirSync as mkdirSync31, readFileSync as readFileSync39, writeFileSync as writeFileSync32, unlinkSync as unlinkSync4, readdirSync as readdirSync16 } from "fs";
+import { join as join46 } from "path";
 
 // src/passenger-mirror.ts
-import { mkdirSync as mkdirSync29 } from "fs";
-import { dirname as dirname26 } from "path";
+import { mkdirSync as mkdirSync30 } from "fs";
+import { dirname as dirname27 } from "path";
 function mirrorRepoOf(spec) {
   const fromOrigin = spec.originUrl ? parseRemote(spec.originUrl) : null;
   if (fromOrigin) return fromOrigin;
@@ -21061,9 +21318,9 @@ async function materializeMirrorCheckouts(specs, cacheFor = (s) => new SandboxCa
       continue;
     }
     try {
-      const parent = dirname26(spec.dir);
-      mkdirSync29(parent, { recursive: true });
-      mkdirSync29(spec.dir, { recursive: true });
+      const parent = dirname27(spec.dir);
+      mkdirSync30(parent, { recursive: true });
+      mkdirSync30(spec.dir, { recursive: true });
       const r = await cacheFor(spec).materialize(repo, spec.base, parent, spec.name);
       out.push({ ...base, action: r.changed ? "updated" : "unchanged", detail: r.tip });
     } catch (e) {
@@ -21169,21 +21426,21 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join45(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join46(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
-  if (!existsSync42(path)) return void 0;
+  if (!existsSync43(path)) return void 0;
   try {
-    return JSON.parse(readFileSync38(path, "utf8"));
+    return JSON.parse(readFileSync39(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync30(join45(stateDir, "passengers"), { recursive: true });
-  writeFileSync31(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync31(join46(stateDir, "passengers"), { recursive: true });
+  writeFileSync32(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function removePersistedSyncDaemon(stateDir, workspaceId) {
@@ -21203,8 +21460,8 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join45(stateDir, "passengers");
-  if (!existsSync42(dir)) return [];
+  const dir = join46(stateDir, "passengers");
+  if (!existsSync43(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync16(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
@@ -21292,8 +21549,8 @@ function describeCause(err3) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync43, mkdirSync as mkdirSync31, readFileSync as readFileSync39, readdirSync as readdirSync17, rmSync as rmSync20, statSync as statSync14, writeFileSync as writeFileSync32 } from "fs";
-import { join as join46 } from "path";
+import { existsSync as existsSync44, mkdirSync as mkdirSync32, readFileSync as readFileSync40, readdirSync as readdirSync17, rmSync as rmSync20, statSync as statSync14, writeFileSync as writeFileSync33 } from "fs";
+import { join as join47 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
@@ -21381,7 +21638,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(join46(path, entry.name)));
+    latest = Math.max(latest, latestMtime(join47(path, entry.name)));
   }
   return latest;
 }
@@ -21390,10 +21647,10 @@ function computeTreeSignature(paths) {
 }
 function makeStaleChecker(paths, opts = {}) {
   const initial = computeTreeSignature(paths);
-  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync43(opts.reloadSentinel);
+  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync44(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join46(stateDir, "reload-requested");
+  return join47(stateDir, "reload-requested");
 }
 function readReloadRequestedAt(stateDir) {
   try {
@@ -21403,17 +21660,17 @@ function readReloadRequestedAt(stateDir) {
   }
 }
 function daemonStampFor(stateDir) {
-  return join46(stateDir, "daemon.started");
+  return join47(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
-  mkdirSync31(stateDir, { recursive: true });
+  mkdirSync32(stateDir, { recursive: true });
   rmSync20(reloadSentinelFor(stateDir), { force: true });
-  writeFileSync32(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
+  writeFileSync33(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
 `);
 }
 function readDaemonStarted(stateDir) {
   try {
-    const v = JSON.parse(readFileSync39(daemonStampFor(stateDir), "utf8")).startedAt;
+    const v = JSON.parse(readFileSync40(daemonStampFor(stateDir), "utf8")).startedAt;
     return typeof v === "number" ? v : null;
   } catch {
     return null;
@@ -21971,7 +22228,7 @@ async function buildEnvironment(route2, ship, ticket) {
   });
   const authorship = await tracker.authorshipProbe().catch(() => null);
   const attachments = await tracker.attachmentsProbe().catch(() => null);
-  return renderEnvironment({ route: route2, userAgent: ship.userAgent, repos, contract, sourceTicket: ticket, authorship, attachments, shipName: ship.name, ...sandboxEnv(ship) });
+  return renderEnvironment({ route: route2, userAgent: ship.userAgent, repos: await withRepoMaps(repos, ship.mapTokenBudget, ship.shell), contract, sourceTicket: ticket, authorship, attachments, shipName: ship.name, ...sandboxEnv(ship) });
 }
 
 // src/control-api.ts
@@ -21979,7 +22236,7 @@ import { createHash as createHash10 } from "crypto";
 import {
   chmodSync as chmodSync4,
   closeSync as closeSync5,
-  existsSync as existsSync44,
+  existsSync as existsSync45,
   fstatSync,
   openSync as openSync5,
   readSync as readSync3,
@@ -21990,7 +22247,7 @@ import {
 } from "fs";
 import { createConnection } from "net";
 import { createServer } from "http";
-import { basename as basename14, dirname as dirname27, join as join47 } from "path";
+import { basename as basename14, dirname as dirname28, join as join48 } from "path";
 import { execFile as execFile3, spawn as spawn10 } from "child_process";
 
 // src/periscope-control.ts
@@ -22219,7 +22476,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) => join47(stateDir, CONTROL_SOCKET_NAME);
+var controlSocketFor = (stateDir) => join48(stateDir, CONTROL_SOCKET_NAME);
 var MAX_SOCKET_PATH = 100;
 var MAX_TAIL_BYTES = 1024 * 1024;
 var MAX_WAIT_SECONDS = 30;
@@ -22306,7 +22563,7 @@ function candidates(live, rotated) {
   const out = [live];
   if (!rotated) return out;
   try {
-    for (const n of readdirSync18(dirname27(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join47(dirname27(live), n));
+    for (const n of readdirSync18(dirname28(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join48(dirname28(live), n));
   } catch {
   }
   return out;
@@ -22350,7 +22607,7 @@ function lastLines2(path, n) {
 }
 function readTail(live, opts) {
   const max = opts.maxBytes ?? MAX_TAIL_BYTES;
-  if (!existsSync44(live)) {
+  if (!existsSync45(live)) {
     return { lines: [], cursor: opts.after ?? encodeCursor({ dev: 0, ino: 0, off: 0 }), reset: false };
   }
   const cur = opts.after ? decodeCursor(opts.after) : null;
@@ -22466,7 +22723,7 @@ async function tailReply(path, q2, rotated, abort) {
   const deadline = Date.now() + Math.min(wait, MAX_WAIT_SECONDS) * 1e3;
   let r = readTail(path, { after, tail: tail3, rotated });
   while (after && !r.lines.length && !r.reset && Date.now() < deadline && !abort.aborted) {
-    await waitForChange(dirname27(path), deadline - Date.now(), abort);
+    await waitForChange(dirname28(path), deadline - Date.now(), abort);
     r = readTail(path, { after: r.cursor, rotated });
   }
   return reply2(200, r);
@@ -22506,8 +22763,8 @@ 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 = join47(deps.stateDir, "streams", run3.endsWith(".jsonl") ? run3 : `${run3}.jsonl`);
-    if (!existsSync44(file)) return err2(404, "no such run");
+    const file = join48(deps.stateDir, "streams", run3.endsWith(".jsonl") ? run3 : `${run3}.jsonl`);
+    if (!existsSync45(file)) return err2(404, "no such run");
     return tailReply(file, url.searchParams, false, abort);
   }
   if ((p === "/pause" || p === "/resume") && post3) {
@@ -22551,7 +22808,7 @@ function send(res, r) {
   res.end(body);
 }
 async function socketIsStale(path) {
-  if (!existsSync44(path)) return false;
+  if (!existsSync45(path)) return false;
   return new Promise((resolve8) => {
     const c = createConnection(path);
     c.once("connect", () => {
@@ -22570,7 +22827,7 @@ async function startControlServer(deps) {
     return null;
   }
   if (await socketIsStale(path)) rmSync21(path, { force: true });
-  else if (existsSync44(path)) {
+  else if (existsSync45(path)) {
     log(`control API not started: ${path} is in use by another process`);
     return null;
   }
@@ -22656,31 +22913,31 @@ function crewJson(args, timeoutMs = 6e4) {
 
 // src/periscope-mcp.ts
 import { lstat, mkdir, readdir, readFile, readlink, realpath, rm, stat, writeFile } from "fs/promises";
-import { basename as basename15, dirname as dirname28, isAbsolute as isAbsolute4, join as join49, relative as relative2, resolve as resolve6, sep } from "path";
+import { basename as basename15, dirname as dirname29, isAbsolute as isAbsolute4, join as join50, 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 existsSync45, mkdirSync as mkdirSync32, readdirSync as readdirSync19, readFileSync as readFileSync40, rmSync as rmSync22, writeFileSync as writeFileSync33 } from "fs";
-import { join as join48 } from "path";
-var secretDir = (stateDir) => join48(stateDir, "periscope-mcp");
-var secretFile = (stateDir, id) => join48(secretDir(stateDir), `${id}.json`);
-var endpointDir = (stateDir) => join48(stateDir, "periscope-endpoints");
-var endpointFile = (stateDir, id) => join48(endpointDir(stateDir), `${id}.json`);
+import { chmodSync as chmodSync5, existsSync as existsSync46, mkdirSync as mkdirSync33, readdirSync as readdirSync19, readFileSync as readFileSync41, rmSync as rmSync22, writeFileSync as writeFileSync34 } from "fs";
+import { join as join49 } from "path";
+var secretDir = (stateDir) => join49(stateDir, "periscope-mcp");
+var secretFile = (stateDir, id) => join49(secretDir(stateDir), `${id}.json`);
+var endpointDir = (stateDir) => join49(stateDir, "periscope-endpoints");
+var endpointFile = (stateDir, id) => join49(endpointDir(stateDir), `${id}.json`);
 function mintPeriscopeSecret(stateDir, ticketRecordId) {
-  mkdirSync32(secretDir(stateDir), { recursive: true, mode: 448 });
+  mkdirSync33(secretDir(stateDir), { recursive: true, mode: 448 });
   const secret = randomBytes3(32).toString("base64url");
   const file = secretFile(stateDir, ticketRecordId);
-  writeFileSync33(file, `${JSON.stringify({ secret })}
+  writeFileSync34(file, `${JSON.stringify({ secret })}
 `, { mode: 384 });
   chmodSync5(file, 384);
   return secret;
 }
 function readPeriscopeSecret(stateDir, ticketRecordId) {
   try {
-    const v = JSON.parse(readFileSync40(secretFile(stateDir, ticketRecordId), "utf8"));
+    const v = JSON.parse(readFileSync41(secretFile(stateDir, ticketRecordId), "utf8"));
     return typeof v.secret === "string" && v.secret ? v.secret : void 0;
   } catch {
     return void 0;
@@ -22691,14 +22948,14 @@ function removePeriscopeSecret(stateDir, ticketRecordId) {
 }
 function readPeriscopeEndpoint(stateDir, ticketRecordId) {
   try {
-    return JSON.parse(readFileSync40(endpointFile(stateDir, ticketRecordId), "utf8"));
+    return JSON.parse(readFileSync41(endpointFile(stateDir, ticketRecordId), "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePeriscopeEndpoint(stateDir, rec) {
-  mkdirSync32(endpointDir(stateDir), { recursive: true });
-  writeFileSync33(endpointFile(stateDir, rec.ticketRecordId), `${JSON.stringify(rec, null, 2)}
+  mkdirSync33(endpointDir(stateDir), { recursive: true });
+  writeFileSync34(endpointFile(stateDir, rec.ticketRecordId), `${JSON.stringify(rec, null, 2)}
 `);
 }
 function removePeriscopeEndpointRecord(stateDir, ticketRecordId) {
@@ -22706,7 +22963,7 @@ function removePeriscopeEndpointRecord(stateDir, ticketRecordId) {
 }
 function listPeriscopeEndpoints(stateDir) {
   const dir = endpointDir(stateDir);
-  if (!existsSync45(dir)) return [];
+  if (!existsSync46(dir)) return [];
   const out = [];
   for (const name of readdirSync19(dir)) {
     if (!name.endsWith(".json")) continue;
@@ -22794,10 +23051,10 @@ async function realAncestor(p) {
     }
     if (isLink) {
       if (++hops > 40) throw new PathRefusal(`too many symbolic links resolving ${p}`);
-      cur = resolve6(dirname28(cur), await readlink(cur));
+      cur = resolve6(dirname29(cur), await readlink(cur));
       continue;
     }
-    const parent = dirname28(cur);
+    const parent = dirname29(cur);
     if (parent === cur) throw new PathRefusal(`cannot resolve ${p}`);
     tail3.push(basename15(cur));
     cur = parent;
@@ -22809,13 +23066,13 @@ async function resolveInWorktree(root, requested) {
   let abs;
   if (isAbsolute4(requested)) {
     abs = resolve6(requested);
-    if (isInside(root, abs)) abs = join49(realRoot, relative2(root, abs));
+    if (isInside(root, abs)) abs = join50(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 ? join49(real, rest) : real;
+  const final = rest ? join50(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;
@@ -22883,7 +23140,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(join49(abs, e.name))).size;
+      const size = (await lstat(join50(abs, e.name))).size;
       return `[FILE] ${e.name} (${size} bytes)`;
     }));
     return text(lines2.join("\n") || "(empty)");
@@ -22908,7 +23165,7 @@ function createPeriscopeMcpServer(d, sc) {
     if (Buffer.byteLength(content) > MAX_WRITE_BYTES) return text(`content exceeds ${MAX_WRITE_BYTES} bytes`, true);
     const abs = await inTree(path);
     if (abs === await realpath(root)) return text("path must name a file", true);
-    await mkdir(dirname28(abs), { recursive: true });
+    await mkdir(dirname29(abs), { recursive: true });
     await inTree(path);
     await writeFile(abs, content);
     return text(`Wrote ${Buffer.byteLength(content)} bytes to ${await rel(abs)}`);
@@ -22948,8 +23205,8 @@ function createPeriscopeMcpServer(d, sc) {
     inputSchema: { path: z.string() },
     annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
   }, async ({ path }) => {
-    const parent = await inTree(dirname28(path) === "" ? "." : dirname28(path));
-    const abs = join49(parent, basename15(path));
+    const parent = await inTree(dirname29(path) === "" ? "." : dirname29(path));
+    const abs = join50(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);
@@ -23070,7 +23327,7 @@ function findPeriscope(sidecars, segment) {
 }
 
 // src/cli.ts
-var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname29(process.execPath) : resolve7(dirname29(fileURLToPath(import.meta.url)), "..");
+var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname30(process.execPath) : resolve7(dirname30(fileURLToPath(import.meta.url)), "..");
 var RELEASE_LOCK_TTL_MS = 20 * 60 * 1e3;
 var CYCLE_SECONDS2 = 120;
 var STALE_CYCLES = 3;
@@ -23438,7 +23695,7 @@ if (command === "provision") {
   process.exit(outcome.code);
 }
 if (command === "pool-member") {
-  const pool = poolConfigFrom(argv, process.env, () => readFileSync41(0, "utf8"));
+  const pool = poolConfigFrom(argv, process.env, () => readFileSync42(0, "utf8"));
   if (typeof pool === "string") {
     process.stderr.write(`crew pool-member: ${pool}
 `);
@@ -23666,7 +23923,7 @@ if (command === "passenger-sync-daemon") {
     } else {
       const toleratesNoRoutes = command === "credential" || command === "forge" || command === "repos" || command === "ship" || command === "disconnect" && flag("reset") || command === "deprovision" || command === "connect" && flag("sign-out");
       const configless = command === "connect" && flag("sign-out") || command === "disconnect" && flag("reset") || command === "deprovision";
-      if (configless && !existsSync46(findConfigFile(CREW_HOME))) {
+      if (configless && !existsSync47(findConfigFile(CREW_HOME))) {
         cfg = loadConfig(CREW_HOME, firstRunConfigPath(), { text: "ship: {}\n", allowNoRoutes: true });
       } else {
         cfg = loadConfig(CREW_HOME, void 0, toleratesNoRoutes ? { allowNoRoutes: true } : {});
@@ -23681,7 +23938,7 @@ if (command === "passenger-sync-daemon") {
     throw e;
   }
   if (command === "credential") {
-    const r = runCredential(positional[1], readFileSync41(0, "utf8"), cfg.ship.forges, cfg.ship.stateDir);
+    const r = runCredential(positional[1], readFileSync42(0, "utf8"), cfg.ship.forges, cfg.ship.stateDir);
     process.stdout.write(r.out);
     process.stderr.write(r.err);
     process.exit(r.code);
@@ -23693,9 +23950,9 @@ if (command === "passenger-sync-daemon") {
         forges: cfg.ship.forges,
         stateDir: cfg.ship.stateDir,
         configFile: cfg.configFile,
-        readFile: (p) => readFileSync41(p, "utf8"),
-        writeFile: (p, t) => writeFileSync34(p, t),
-        stdin: () => readFileSync41(0, "utf8"),
+        readFile: (p) => readFileSync42(p, "utf8"),
+        writeFile: (p, t) => writeFileSync35(p, t),
+        stdin: () => readFileSync42(0, "utf8"),
         env: process.env
       }
     );
@@ -23988,8 +24245,8 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join50(homedir11(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync46(staleTimer)) {
+      const staleTimer = join51(homedir11(), ".config", "systemd", "user", `${label}.timer`);
+      if (existsSync47(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -24016,7 +24273,7 @@ if (command === "passenger-sync-daemon") {
     const tracker = new Tracker(c, cfg.ship);
     problems.push(...validateContract(tracker.contract).map((p) => `contract: ${p}`));
     for (const r of await resolvedRepos(c)) {
-      if (!existsSync46(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync47(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
       if (!satisfies(host, r.config.platform)) problems.push(`repo ${r.name}: requires ${r.config.platform}, this host is ${host}`);
       readiness.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
     }
@@ -24043,7 +24300,7 @@ if (command === "passenger-sync-daemon") {
   }
   async function doctorFix(o) {
     const routes = await Promise.all(routesInScope(cfg.routes, named).map((c) => gatherHealth({ route: c.route, enabled: c.enabled, hasRepos: reposOf(c).length > 0 }, () => routeProblems(c))));
-    const unitExists = (p) => existsSync46(p);
+    const unitExists = (p) => existsSync47(p);
     const crontab = o.host === "linux" ? spawnSync10("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
     const schedulerAbsent = o.host !== "windows" ? !schedulerInstalled(planInstall(cfg.ship, CREW_HOME, o.host, detectSystemd(), "run", installContext()), unitExists, crontab) : true;
     const plan = planFix({ routes, schedulerAbsent, host: o.host });
@@ -24060,7 +24317,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;
-          writeFileSync34(cfg.configFile, planEnable(readFileSync41(cfg.configFile, "utf8"), a.route));
+          writeFileSync35(cfg.configFile, planEnable(readFileSync42(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -24137,7 +24394,7 @@ ${changed2.map((c) => `  - ${c}
     return renderEnvironment({
       route: c,
       userAgent: cfg.ship.userAgent,
-      repos: await resolvedRepos(c),
+      repos: await withRepoMaps(await resolvedRepos(c), cfg.ship.mapTokenBudget, cfg.ship.shell),
       contract,
       sourceTicket: ticket,
       authorship: await tracker.authorshipProbe().catch(() => null),
@@ -25199,7 +25456,7 @@ ${cu.tail.trimEnd()}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join50(CREW_HOME, "src"), join50(CREW_HOME, "dist"), join50(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join51(CREW_HOME, "src"), join51(CREW_HOME, "dist"), join51(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -25504,10 +25761,10 @@ ${cu.tail.trimEnd()}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync46(resolvedPath) ? JSON.parse(readFileSync41(resolvedPath, "utf8")) : {};
+        const raw = existsSync47(resolvedPath) ? JSON.parse(readFileSync42(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
-        mkdirSync33(dirOf2(resolvedPath), { recursive: true });
-        writeFileSync34(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        mkdirSync34(dirOf2(resolvedPath), { recursive: true });
+        writeFileSync35(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (result.outcomes.some((o) => o.action === "diverged")) process.exitCode = 1;
@@ -25530,7 +25787,7 @@ ${cu.tail.trimEnd()}
         throw e;
       }
       const oldName = cfg.ship.name;
-      writeFileSync34(cfg.configFile, setShipNameInYaml(readFileSync41(cfg.configFile, "utf8"), newName));
+      writeFileSync35(cfg.configFile, setShipNameInYaml(readFileSync42(cfg.configFile, "utf8"), newName));
       cfg.ship.name = newName;
       let renameMachineId;
       try {
@@ -25577,14 +25834,14 @@ ${cu.tail.trimEnd()}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list" && sub !== "clone" && sub !== "hooks" && sub !== "check") usage2();
-      const configText = readFileSync41(cfg.configFile, "utf8");
+      const configText = readFileSync42(cfg.configFile, "utf8");
       if (sub === "check") {
         try {
           const routeArg = value("route") ?? positional[2];
           const found = cfg.routes.find((r) => r.route === routeArg);
           if (!found) throw new ReposError(`no route "${routeArg}" in the config (have: ${cfg.routes.map((r) => r.route).join(", ") || "none"})`);
           const named2 = value("route") ? void 0 : positional[3];
-          const dir = named2 ? repoDirOf(configText, dirname29(cfg.configFile), found.route, named2) : resolvePath(positional[value("route") ? 2 : 3] ?? ".");
+          const dir = named2 ? repoDirOf(configText, dirname30(cfg.configFile), found.route, named2) : resolvePath(positional[value("route") ? 2 : 3] ?? ".");
           const target = reposOf(found).find((t) => resolvePath(t.dir) === dir || t.name === named2);
           const o = target ? found.repoOverrides[target.name] : void 0;
           runReposCheck(dir, {
@@ -25607,9 +25864,9 @@ ${cu.tail.trimEnd()}
       if (sub === "hooks") {
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
-          const dir = repoDirOf(configText, dirname29(cfg.configFile), a.route, a.name);
-          if (!existsSync46(dir)) throw new ReposError(`${dir} does not exist on disk`);
-          const files = { exists: (r) => existsSync46(resolvePath(dir, r)), list: (r) => {
+          const dir = repoDirOf(configText, dirname30(cfg.configFile), a.route, a.name);
+          if (!existsSync47(dir)) throw new ReposError(`${dir} does not exist on disk`);
+          const files = { exists: (r) => existsSync47(resolvePath(dir, r)), list: (r) => {
             try {
               return readdirSync20(resolvePath(dir, r));
             } catch {
@@ -25617,7 +25874,7 @@ ${cu.tail.trimEnd()}
             }
           }, read: (r) => {
             try {
-              return readFileSync41(resolvePath(dir, r), "utf8");
+              return readFileSync42(resolvePath(dir, r), "utf8");
             } catch {
               return void 0;
             }
@@ -25659,19 +25916,19 @@ ${cu.tail.trimEnd()}
           let cleared;
           if (clear2) {
             const plan = clearRouteHooks(configText, a.route, a.name);
-            if (plan.removed.length > 0) writeFileSync34(cfg.configFile, plan.text);
+            if (plan.removed.length > 0) writeFileSync35(cfg.configFile, plan.text);
             cleared = { file: cfg.configFile, removed: plan.removed };
           }
           if (write && suggestion.source === null && recipeIds.length === 0 && hookSpecs.length === 0) throw new ReposError(`nothing to write: ${suggestion.notes[0]}`);
           if (write === "route") {
             const plan = planRouteHooks(configText, a.route, a.name, picked.hooks, { replace: flag("replace") });
-            writeFileSync34(cfg.configFile, plan.text);
+            writeFileSync35(cfg.configFile, plan.text);
             written = { target: "route", file: cfg.configFile, hooks: plan.written, kept: plan.kept, replaced: plan.replaced };
           } else if (write === "repo") {
             const have = existingRepoConfig(files);
             if (have) throw new ReposError(`${resolvePath(dir, have)} already exists; not overwriting it`);
             const file = resolvePath(dir, ".crew.yaml");
-            writeFileSync34(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
+            writeFileSync35(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
             written = { target: "repo", file, hooks: Object.keys(picked.hooks), kept: [], replaced: [] };
           }
           if (flag("json")) {
@@ -25727,7 +25984,7 @@ ${cu.tail.trimEnd()}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync46(resolvePath(p.replace(/^~(?=\/|$)/, homedir11()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync47(resolvePath(p.replace(/^~(?=\/|$)/, homedir11()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -25757,7 +26014,7 @@ ${cu.tail.trimEnd()}
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       if (sub === "list" || sub === "add") {
         const liveRoute = cfg.routes.find((r) => r.route === routeName);
-        if (liveRoute?.resolved?.reposModelId && existsSync46(resolvedFile) && !dryRun) {
+        if (liveRoute?.resolved?.reposModelId && existsSync47(resolvedFile) && !dryRun) {
           try {
             await hydrateApiKeys([liveRoute]);
             persistRepoRows(cfg.ship.stateDir, liveRoute.route, await new Tracker(liveRoute, cfg.ship).repoRowsForMap());
@@ -25766,16 +26023,16 @@ ${cu.tail.trimEnd()}
         }
       }
       let resolvedRemotes;
-      if (existsSync46(resolvedFile)) {
+      if (existsSync47(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync41(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync42(resolvedFile, "utf8"));
         } catch {
         }
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text2 = configText;
-      const base = dirname29(cfg.configFile);
-      const isCheckout = (d) => existsSync46(`${d}/.git`);
+      const base = dirname30(cfg.configFile);
+      const isCheckout = (d) => existsSync47(`${d}/.git`);
       try {
         if (sub === "list") {
           if (flag("json")) {
@@ -25785,11 +26042,11 @@ ${cu.tail.trimEnd()}
               base,
               resolved: resolvedRemotes,
               originOf,
-              exists: (d) => existsSync46(d),
+              exists: (d) => existsSync47(d),
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
-                  return Object.keys(parseRepoConfig(readFileSync41(resolvePath(d, f), "utf8"), f).hooks).length > 0;
+                  return Object.keys(parseRepoConfig(readFileSync42(resolvePath(d, f), "utf8"), f).hooks).length > 0;
                 } catch {
                   return false;
                 }
@@ -25806,7 +26063,7 @@ ${cu.tail.trimEnd()}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync46(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync47(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
             process.stdout.write(`${r.name}	${r.dir}	${note}
 `);
           }
@@ -25818,9 +26075,9 @@ ${cu.tail.trimEnd()}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text: text2, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir"), isCheckout });
-          if (existsSync46(plan2.target) && (existsSync46(`${plan2.target}/.git`) || readdirSync20(plan2.target).length > 0)) {
+          if (existsSync47(plan2.target) && (existsSync47(`${plan2.target}/.git`) || readdirSync20(plan2.target).length > 0)) {
             throw new ReposError(
-              existsSync46(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
+              existsSync47(`${plan2.target}/.git`) ? `${plan2.target} is already a checkout \u2014 attach it with \`crew repos add ${routeName} ${plan2.name} ${plan2.target}\`` : `${plan2.target} exists and is not empty \u2014 pass --dir to clone somewhere else`
             );
           }
           if (dryRun) {
@@ -25838,14 +26095,14 @@ ${cu.tail.trimEnd()}
             throw new ReposError(`${e.message}${authHint}
   crew.yaml was not changed`);
           }
-          writeFileSync34(cfg.configFile, plan2.text);
+          writeFileSync35(cfg.configFile, plan2.text);
           if (plan2.droppedDir) process.stderr.write(`crew repos: dropped dir: ${plan2.droppedDir} from route ${routeName} \u2014 it is not a checkout (the clone base); checkouts now live under repos:
 `);
           say("attached", { route: routeName, name: plan2.name, dir: plan2.target, mode: plan2.mode }, `cloned and attached ${plan2.target} to ${routeName} as ${plan2.mode === "dir" ? "dir" : `repos.${plan2.name}`} in ${cfg.configFile}`);
           break;
         }
         const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir11()));
-        const top = existsSync46(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync47(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
         if (!top) throw new ReposError(`${target} is not a git checkout`);
         const origin = originOf(top);
         const plan = planRepoAdd({
@@ -25897,15 +26154,15 @@ ${cu.tail.trimEnd()}
           const created = await rowTracker.createRepoRow(rowPayload);
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
-          if (existsSync46(resolvedFile)) {
-            const raw = JSON.parse(readFileSync41(resolvedFile, "utf8"));
+          if (existsSync47(resolvedFile)) {
+            const raw = JSON.parse(readFileSync42(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
-            writeFileSync34(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync35(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        writeFileSync34(cfg.configFile, plan.text);
+        writeFileSync35(cfg.configFile, plan.text);
         process.stdout.write(`added ${top} to ${routeName} as ${plan.mode === "dir" ? "dir" : `repos.${plan.name}`} in ${cfg.configFile}
 `);
       } catch (e) {
@@ -26274,7 +26531,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.exit(2);
         }
         if (found.shipNameAdopted && !dryRun) {
-          writeFileSync34(cfg.configFile, setShipNameInYaml(readFileSync41(cfg.configFile, "utf8"), found.shipNameAdopted));
+          writeFileSync35(cfg.configFile, setShipNameInYaml(readFileSync42(cfg.configFile, "utf8"), found.shipNameAdopted));
           cfg.ship.name = found.shipNameAdopted;
         }
         if (found.shipRow) {
@@ -26317,10 +26574,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
         let previous;
-        const hadPreviousFile = existsSync46(resolvedPath);
+        const hadPreviousFile = existsSync47(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync41(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync42(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -26450,10 +26707,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.stderr.write(`(dry run) would write resolved ids to ${resolvedPath}
 `);
         } else {
-          mkdirSync33(dirname29(resolvedPath), { recursive: true });
+          mkdirSync34(dirname30(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
-          writeFileSync34(tmpPath, `${JSON.stringify(resolved, null, 2)}
+          writeFileSync35(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
           renameSync6(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
@@ -26499,8 +26756,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             process.stderr.write(`(dry run) would write the minted API key to ${apiKeyFile}
 `);
           } else {
-            mkdirSync33(dirname29(apiKeyFile), { recursive: true });
-            writeFileSync34(apiKeyFile, `${apiKeyVar}=${apiKey}
+            mkdirSync34(dirname30(apiKeyFile), { recursive: true });
+            writeFileSync35(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
 `);
@@ -27375,7 +27632,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           const shellR = hit && resolveShell(hit.repo.config.shell ?? cfg.ship.shell);
           const resumed = await runPeriscopeResume({
             find: async () => hit && { row: hit.row, tag: hit.tag },
-            worktreeExists: (p) => existsSync46(p),
+            worktreeExists: (p) => existsSync47(p),
             prepareDropFile,
             caps: periscopeCaps(cfg.ship),
             runHook: async (name, cwd, env) => {
@@ -27470,10 +27727,10 @@ ${where.join("\n")}`);
           },
           prepare: async (path) => {
             for (const f of repoP.config.worktrees.copy) {
-              const src = join50(repoP.dir, f);
-              if (!existsSync46(src)) continue;
-              mkdirSync33(dirOf2(join50(path, f)), { recursive: true });
-              copyFileSync2(src, join50(path, f));
+              const src = join51(repoP.dir, f);
+              if (!existsSync47(src)) continue;
+              mkdirSync34(dirOf2(join51(path, f)), { recursive: true });
+              copyFileSync2(src, join51(path, f));
             }
             const setup = repoP.config.hooks.setup;
             return setup ? runScript(setup, { cwd: path, shell: shellP, onLine: (l) => {
@@ -27482,10 +27739,11 @@ ${where.join("\n")}`);
           },
           runHook: async (name, cwd, env) => {
             const script = repoP.config.hooks[name];
-            return script ? runScript(script, { cwd, env, shell: shellP, timeoutMs: name === "preview" ? 18e4 : void 0 }) : null;
+            return script ? runScript(script, { cwd, env, shell: shellP, timeoutMs: name === "preview" ? 18e4 : name === "intel" ? 6e4 : void 0 }) : null;
           },
           createRow: (fields) => trackerP.createPeriscope(fields),
           prepareDropFile,
+          registerCode: registerCodeServer,
           recordLocal: (sc) => {
             writePeriscopeSidecar(cfg.ship.stateDir, { ...sc, route: routeP.route });
             if (flag("serve-mcp")) mintPeriscopeSecret(cfg.ship.stateDir, sc.ticketRecordId);
@@ -27545,6 +27803,7 @@ ${where.join("\n")}`);
           },
           now: () => /* @__PURE__ */ new Date(),
           host: a.host ?? "localhost",
+          intelStartupSeconds: cfg.ship.intelStartupSeconds,
           say
         };
         if (dryRun) {
@@ -27628,7 +27887,7 @@ ${where.join("\n")}`);
     }
     case "sync": {
       emit.enter("worktree");
-      let tracked = 0;
+      let tracked2 = 0;
       let acted = 0;
       let baseChecked = 0;
       let baseActed = 0;
@@ -27666,7 +27925,7 @@ ${where.join("\n")}`);
           }
           if (!s2.upstream) continue;
           if (w.branch !== r.config.branch.base && s2.upstream === `${r.config.branch.remote}/${r.config.branch.base}`) continue;
-          tracked++;
+          tracked2++;
           if (s2.canFastForward) {
             acted++;
             if (dryRun) emit.emit(`would fast-forward ${w.branch}: ${s2.detail}`);
@@ -27679,8 +27938,8 @@ ${where.join("\n")}`);
       }
       if (baseUnsafe > 0) process.exitCode = 1;
       if (baseChecked > 0 && baseActed === 0) emit.emit(`${baseChecked} base branch(es) checked, all level with the remote`);
-      if (tracked === 0) emit.emit("no worktree tracks a remote branch \u2014 nothing to sync");
-      else if (acted === 0) emit.emit(`${tracked} worktree(s) tracking a remote, all level with it`);
+      if (tracked2 === 0) emit.emit("no worktree tracks a remote branch \u2014 nothing to sync");
+      else if (acted === 0) emit.emit(`${tracked2} worktree(s) tracking a remote, all level with it`);
       break;
     }
     case "pause":
@@ -27769,7 +28028,7 @@ ${where.join("\n")}`);
       };
       const droppedRoutes = [];
       try {
-        const rawCfg = parseYaml2(readFileSync41(cfg.configFile, "utf8"));
+        const rawCfg = parseYaml2(readFileSync42(cfg.configFile, "utf8"));
         for (const r of rawCfg?.routes ?? []) {
           if (typeof r?.route !== "string" || cfg.routes.some((x) => x.route === r.route)) continue;
           try {
@@ -27822,8 +28081,8 @@ ${where.join("\n")}`);
         process.stdout.write("crew reload: no daemon unit is running \u2014 nothing to reload (the next run reads crew.yaml fresh)\n");
         break;
       }
-      mkdirSync33(cfg.ship.stateDir, { recursive: true });
-      writeFileSync34(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
+      mkdirSync34(cfg.ship.stateDir, { recursive: true });
+      writeFileSync35(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
       process.stdout.write(
         "crew reload: requested \u2014 the daemon relaunches with the new config once its running agents end (it starts no new work meanwhile); if it is busy, `crew reload --now` forces the relaunch and interrupts them\n"
@@ -27888,7 +28147,7 @@ ${where.join("\n")}`);
     }
     case "log": {
       try {
-        const text2 = readFileSync41(cfg.ship.logFile, "utf8").split("\n");
+        const text2 = readFileSync42(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text2.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -27911,8 +28170,8 @@ ${where.join("\n")}`);
       };
       if (!route2.resolved) fail(`route ${route2.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route2, cfg.ship);
-      const configText = readFileSync41(cfg.configFile, "utf8");
-      const cfgBase = dirname29(cfg.configFile);
+      const configText = readFileSync42(cfg.configFile, "utf8");
+      const cfgBase = dirname30(cfg.configFile);
       const configured2 = configuredRepos(configText, route2.route, cfgBase);
       const dir = configured2.find((r) => r.name === SAMPLE_REPO)?.dir ?? sampleDir(configured2.map((r) => r.dir), route2.reposBasePath, route2.route.split("/")[0]);
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, route2.route);
@@ -27940,7 +28199,7 @@ ${where.join("\n")}`);
         }
         if (configured2.some((r) => r.dir === dir)) {
           try {
-            writeFileSync34(cfg.configFile, planRepoRemove(configText, cfgBase, route2.route, dir).text);
+            writeFileSync35(cfg.configFile, planRepoRemove(configText, cfgBase, route2.route, dir).text);
           } catch (e) {
             if (e instanceof ReposError) fail(e.message);
             throw e;
@@ -27948,29 +28207,29 @@ ${where.join("\n")}`);
         }
         if (row) {
           await tracker.deleteRepoRow(row.id);
-          if (existsSync46(resolvedFile)) {
-            const raw = JSON.parse(readFileSync41(resolvedFile, "utf8"));
+          if (existsSync47(resolvedFile)) {
+            const raw = JSON.parse(readFileSync42(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
-            writeFileSync34(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync35(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        if (existsSync46(join50(dir, ".git")) && basename16(dir) === SAMPLE_REPO) rmSync23(dir, { recursive: true, force: true });
+        if (existsSync47(join51(dir, ".git")) && basename16(dir) === SAMPLE_REPO) rmSync23(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 = !existsSync46(join50(dir, ".git"));
-      if (existsSync46(dir) && fresh && readdirSync20(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      const fresh = !existsSync47(join51(dir, ".git"));
+      if (existsSync47(dir) && fresh && readdirSync20(dir).length > 0) fail(`${dir} exists and is not a git checkout \u2014 move it aside`);
       if (dryRun) {
         say("dry-run", { dir, newCheckout: fresh, repoRow: row?.id ?? null }, `would ${fresh ? "create" : "reuse"} ${dir}${row ? "" : ", create the Repos row"}, and file one ${tracker.contract.statuses.approved} ticket`);
         break;
       }
       if (fresh) {
-        mkdirSync33(dir, { recursive: true });
-        writeFileSync34(join50(dir, "README.md"), SAMPLE_README);
-        writeFileSync34(join50(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        mkdirSync34(dir, { recursive: true });
+        writeFileSync35(join51(dir, "README.md"), SAMPLE_README);
+        writeFileSync35(join51(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync10("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -27988,17 +28247,17 @@ ${where.join("\n")}`);
           spec: { platform: "unix", releaseMode: "integrate", ciProvider: "none" }
         });
         repoId = (await tracker.createRepoRow(payload)).id;
-        if (existsSync46(resolvedFile)) {
-          const raw = JSON.parse(readFileSync41(resolvedFile, "utf8"));
+        if (existsSync47(resolvedFile)) {
+          const raw = JSON.parse(readFileSync42(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
-          writeFileSync34(resolvedFile, `${JSON.stringify(raw, null, 2)}
+          writeFileSync35(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
         }
       }
       if (!configured2.some((r) => r.dir === dir)) {
         try {
-          writeFileSync34(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route2.route, path: dir, name: SAMPLE_REPO }).text);
+          writeFileSync35(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route2.route, path: dir, name: SAMPLE_REPO }).text);
         } catch (e) {
           if (e instanceof ReposError) fail(e.message);
           throw e;
@@ -28344,7 +28603,7 @@ watermark:  ${state.watermark()}
           }
           for (const r of repos) {
             const remote = r.config.branch.remote;
-            if (existsSync46(r.dir)) {
+            if (existsSync47(r.dir)) {
               pushAuth.push({
                 route: c.route,
                 repo: r.name,
@@ -28382,7 +28641,8 @@ watermark:  ${state.watermark()}
               notes: validateEffective(r.config),
               base: doctorBaseReport(r, r.config.branch.base, baseHealth),
               hooks: r.config.hooks,
-              onPath: (cmd) => !!findOnPath(cmd, doctorSchedulerPath)
+              onPath: (cmd) => !!findOnPath(cmd, doctorSchedulerPath),
+              intelSyntax: r.config.hooks.intel ? checkHookSyntax(r.config.hooks.intel, r.config.shell) : void 0
             });
             problems.push(...f.problems);
             passed += f.passed;
@@ -28433,7 +28693,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       }
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync46(evFile) ? statSync16(evFile).size : 0;
+        const evSize = existsSync47(evFile) ? statSync16(evFile).size : 0;
         process.stdout.write(
           evSize > cfg.ship.eventsRotateBytes * 4 ? `events log:        WARN ${evFile} is ${Math.round(evSize / 1048576)} MB (> 4x eventsRotateBytes); run \`crew reap\` to rotate it
 ` : "events log:        ok\n"
@@ -28444,7 +28704,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 readFileSync41(p, "utf8");
+            return readFileSync42(p, "utf8");
           } catch {
             return null;
           }