@tablation/crew 0.121.0 → 0.122.0

package/dist/cli.js

@@ -262,6 +262,9 @@ function intelFlavor(script) {
   const w = script?.trim();
   return w && Object.prototype.hasOwnProperty.call(INTEL_FLAVORS, w) ? w : void 0;
 }
+function wantsCodeBridge(script) {
+  return !!script?.trim() && intelFlavor(script) !== "typescript-lsp";
+}
 var INTEL_MINIMUM_TOOLS = [
   "find symbols by name",
   "references to a symbol",
@@ -1309,13 +1312,17 @@ var claudeAdapter = {
       // so the resolved key is never written to an argv string or a config
       // file on disk. Skipped when there's no key to send: a route `crew
       // connect` hasn't resolved yet has nothing to authenticate with.
-      ...o.mcp ? ["--mcp-config", JSON.stringify({
+      ...o.mcp || o.code ? ["--mcp-config", JSON.stringify({
         mcpServers: {
-          tablation: {
-            type: "http",
-            url: o.mcp.url,
-            headers: { Authorization: `Bearer \${${o.mcp.keyVar}}` }
-          }
+          ...o.mcp ? {
+            tablation: {
+              type: "http",
+              url: o.mcp.url,
+              headers: { Authorization: `Bearer \${${o.mcp.keyVar}}` }
+            }
+          } : {},
+          // CREW-2912: the bridge to the worktree's symbol service, attached once `crew worktree` has started it.
+          ...o.code ? { [INTEL_SERVER_NAME]: { type: "stdio", command: o.code.command, args: o.code.args } } : {}
         }
       })] : [],
       // A crew-generated language-server plugin (the `typescript-lsp` intel flavor). Not under oMLX,
@@ -1664,6 +1671,14 @@ var codexAdapter = {
         ...cfg(`mcp_servers.${SERVER}.bearer_token_env_var`, o.mcp.keyVar),
         ...cfg(`mcp_servers.${SERVER}.default_tools_approval_mode`, "approve")
       ] : [],
+      // CREW-2912: the bridge to the worktree's symbol service, scoped to this run like the tracker entry above.
+      ...o.code ? [
+        "-c",
+        `mcp_servers.${INTEL_SERVER_NAME}.command=${tomlString(o.code.command)}`,
+        "-c",
+        `mcp_servers.${INTEL_SERVER_NAME}.args=[${o.code.args.map(tomlString).join(", ")}]`,
+        ...cfg(`mcp_servers.${INTEL_SERVER_NAME}.default_tools_approval_mode`, "approve")
+      ] : [],
       ...spec.args,
       // Prompt on stdin.
       "-"
@@ -2045,7 +2060,8 @@ var geminiAdapter = {
     ];
     return wrapInvocation(spec, { model: o.model, args });
   },
-  runEnv: (spec) => ({ ...spec.env }),
+  // CREW-2912: Gemini has no per-run server list, so the bridge is declared in a per-run system settings file the planner wrote.
+  runEnv: (spec, o) => ({ ...spec.env, ...o?.code?.settingsFile ? { GEMINI_CLI_SYSTEM_SETTINGS_PATH: o.code.settingsFile } : {} }),
   provider: () => "google",
   unsetEnv: BILLING_VARS_TO_UNSET2,
   mapStreamLine: mapGeminiLine,
@@ -6189,8 +6205,8 @@ function attentionProblems(items, already) {
 import { createHash as createHash6 } from "crypto";
 import { spawn as spawn5 } from "child_process";
 import { execFileSync as execFileSync8 } from "child_process";
-import { mkdirSync as mkdirSync18, readFileSync as readFileSync25, renameSync as renameSync3, writeFileSync as writeFileSync19, rmSync as rmSync14 } from "fs";
-import { dirname as dirname13, join as join30 } from "path";
+import { mkdirSync as mkdirSync19, readFileSync as readFileSync26, renameSync as renameSync3, writeFileSync as writeFileSync20, rmSync as rmSync15 } from "fs";
+import { dirname as dirname14, join as join31 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 
 // src/passenger-containers.ts
@@ -6203,18 +6219,18 @@ import { promisify as promisify2 } from "util";
 
 // src/deprovision-host.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import { existsSync as existsSync28, readdirSync as readdirSync11 } from "fs";
+import { existsSync as existsSync29, readdirSync as readdirSync11 } from "fs";
 
 // src/interrupted.ts
-import { existsSync as existsSync26, readdirSync as readdirSync9, readFileSync as readFileSync24 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync27, readdirSync as readdirSync9, readFileSync as readFileSync25 } from "fs";
+import { join as join29 } from "path";
 
 // src/agent.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { readFileSync as readFileSync23, existsSync as existsSync25, statSync as statSync8, mkdirSync as mkdirSync17, writeFileSync as writeFileSync18, createWriteStream, openSync as openSync4, closeSync as closeSync4, readSync } from "fs";
+import { readFileSync as readFileSync24, existsSync as existsSync26, statSync as statSync8, mkdirSync as mkdirSync18, writeFileSync as writeFileSync19, createWriteStream, openSync as openSync4, closeSync as closeSync4, readSync } from "fs";
 import { StringDecoder } from "string_decoder";
 import { finished } from "stream/promises";
-import { join as join27, dirname as dirname12, basename as basename9 } from "path";
+import { join as join28, dirname as dirname13, basename as basename9 } from "path";
 import { createHash as createHash4 } from "crypto";
 
 // src/state.ts
@@ -7100,6 +7116,143 @@ function renderEnvironment(i) {
   return lines2.join("\n");
 }
 
+// src/intel-bridge.ts
+import { existsSync as existsSync20, mkdirSync as mkdirSync14, readFileSync as readFileSync19, rmSync as rmSync11, writeFileSync as writeFileSync15 } from "fs";
+import { dirname as dirname10, join as join21 } from "path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var STATUS_TOOL = "code_status";
+var STATUS_WAITING = "The symbol service is not available yet: the worktree has not been cut. Run `crew worktree` for the ticket; the symbol tools appear in this server afterwards.";
+var STATUS_LOST = "The symbol service stopped answering, so its tools are unavailable. They return if the service comes back; until then use text search.";
+function intelDir(stateDir, route2, ticket) {
+  const safe = (s) => s.replace(/[^A-Za-z0-9._-]+/g, "_");
+  return join21(stateDir, "intel", safe(route2), safe(ticket));
+}
+var attachFilePath = (stateDir, route2, ticket) => join21(intelDir(stateDir, route2, ticket), "url");
+function writeAttachFile(file, url) {
+  mkdirSync14(dirname10(file), { recursive: true });
+  writeFileSync15(file, `${url}
+`);
+}
+function readAttachFile(file) {
+  try {
+    const url = readFileSync19(file, "utf8").trim();
+    return /^https?:\/\/\S+$/i.test(url) ? url : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var statusTool = {
+  name: STATUS_TOOL,
+  description: "Reports whether this repository's symbol service (find symbols, references, definitions, file outlines) is attached. Before `crew worktree` has been run for the ticket it is not; the symbol tools replace this one once it is.",
+  inputSchema: { type: "object", properties: {} }
+};
+var defaultConnect = async (url) => {
+  const client2 = new Client({ name: "crew-intel-bridge", version: "0" }, { capabilities: {} });
+  await client2.connect(new StreamableHTTPClientTransport(new URL(url)));
+  return client2;
+};
+function createBridge(o) {
+  const connect2 = o.connectUpstream ?? defaultConnect;
+  const server = new Server(
+    { name: INTEL_SERVER_NAME, version: o.version ?? "0" },
+    { capabilities: { tools: { listChanged: true } } }
+  );
+  let upstream;
+  let lost = false;
+  let connecting = false;
+  let timer;
+  const notify2 = () => {
+    void server.sendToolListChanged().catch(() => {
+    });
+  };
+  const drop = () => {
+    const gone = upstream;
+    upstream = void 0;
+    lost = true;
+    if (gone) void gone.close().catch(() => {
+    });
+    notify2();
+  };
+  const status2 = () => ({ content: [{ type: "text", text: lost ? STATUS_LOST : STATUS_WAITING }] });
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    if (!upstream) return { tools: [statusTool] };
+    try {
+      return await upstream.listTools();
+    } catch {
+      drop();
+      return { tools: [statusTool] };
+    }
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    if (!upstream) return status2();
+    try {
+      return await upstream.callTool({ name: req.params.name, arguments: req.params.arguments });
+    } catch {
+      drop();
+      return status2();
+    }
+  });
+  const tryAttach = async () => {
+    if (upstream || connecting) return false;
+    const url = readAttachFile(o.attachFile);
+    if (!url) return false;
+    connecting = true;
+    try {
+      const client2 = await connect2(url);
+      client2.onclose = () => {
+        if (upstream === client2) drop();
+      };
+      upstream = client2;
+      lost = false;
+      notify2();
+      return true;
+    } catch {
+      return false;
+    } finally {
+      connecting = false;
+    }
+  };
+  return {
+    server,
+    attached: () => upstream !== void 0,
+    tryAttach,
+    async start(transport) {
+      await server.connect(transport);
+      if (existsSync20(o.attachFile)) await tryAttach();
+      timer = setInterval(() => {
+        void tryAttach();
+      }, o.pollMs ?? 1e3);
+      timer.unref?.();
+    },
+    async stop() {
+      if (timer) clearInterval(timer);
+      const gone = upstream;
+      upstream = void 0;
+      await gone?.close().catch(() => {
+      });
+      await server.close().catch(() => {
+      });
+    }
+  };
+}
+async function runBridge(stateDir, route2, ticket) {
+  const bridge = createBridge({ attachFile: attachFilePath(stateDir, route2, ticket) });
+  const closed = new Promise((resolve8) => {
+    bridge.server.onclose = resolve8;
+    process.stdin.on("end", resolve8);
+  });
+  await bridge.start(new StdioServerTransport());
+  await closed;
+  await bridge.stop();
+}
+
 // src/contract.ts
 var DEFAULT_CONTRACT = {
   columns: {
@@ -7329,8 +7482,8 @@ var BeforeFirstEditTracker = class {
 };
 
 // src/agent-log.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync14, readdirSync as readdirSync6, readFileSync as readFileSync19, rmSync as rmSync11, writeFileSync as writeFileSync15 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync15, readdirSync as readdirSync6, readFileSync as readFileSync20, rmSync as rmSync12, writeFileSync as writeFileSync16 } from "fs";
+import { join as join22 } from "path";
 
 // src/pending-backoff.ts
 var sleepBackoff = (attempts) => Math.min(6e4 * 2 ** Math.max(0, attempts - 1), 30 * 6e4);
@@ -7533,20 +7686,20 @@ async function addRunToTicket(target, t, recordId, run3) {
     };
   }
 }
-var queueDir = (stateDir) => join21(stateDir, "pending-agent-logs");
+var queueDir = (stateDir) => join22(stateDir, "pending-agent-logs");
 function queueAgentRun(stateDir, name, q2) {
-  mkdirSync14(queueDir(stateDir), { recursive: true });
-  writeFileSync15(join21(queueDir(stateDir), `${name}.json`), JSON.stringify(q2));
+  mkdirSync15(queueDir(stateDir), { recursive: true });
+  writeFileSync16(join22(queueDir(stateDir), `${name}.json`), JSON.stringify(q2));
 }
 async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = queueDir(stateDir);
-  if (!existsSync20(dir)) return 0;
+  if (!existsSync21(dir)) return 0;
   let sent = 0;
   for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join21(dir, f);
+    const path = join22(dir, f);
     let q2;
     try {
-      q2 = JSON.parse(readFileSync19(path, "utf8"));
+      q2 = JSON.parse(readFileSync20(path, "utf8"));
     } catch {
       continue;
     }
@@ -7565,17 +7718,17 @@ async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__
         attempts: 0,
         nextAttemptAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      rmSync11(path, { force: true });
+      rmSync12(path, { force: true });
       sent += 1;
       log.emit(`sent a queued Agent Log report (${f})`);
     } catch (e) {
       if (!(e instanceof AgentLogUnreachableError)) {
-        rmSync11(path, { force: true });
+        rmSync12(path, { force: true });
         log.warn(`dropped a queued Agent Log report (${f}): ${e.message}`);
         continue;
       }
       const attempts = q2.attempts + 1;
-      writeFileSync15(path, JSON.stringify({
+      writeFileSync16(path, JSON.stringify({
         ...q2,
         attempts,
         warned: true,
@@ -7586,20 +7739,20 @@ async function replayQueuedAgentRuns(stateDir, route2, keyFor, log, now = /* @__
   }
   return sent;
 }
-var countersDir = (stateDir) => join21(stateDir, "pending-ticket-counters");
+var countersDir = (stateDir) => join22(stateDir, "pending-ticket-counters");
 function queueTicketCounters(stateDir, name, q2) {
-  mkdirSync14(countersDir(stateDir), { recursive: true });
-  writeFileSync15(join21(countersDir(stateDir), `${name}.json`), JSON.stringify(q2));
+  mkdirSync15(countersDir(stateDir), { recursive: true });
+  writeFileSync16(join22(countersDir(stateDir), `${name}.json`), JSON.stringify(q2));
 }
 async function replayQueuedTicketCounters(stateDir, route2, keyFor, log, now = /* @__PURE__ */ new Date()) {
   const dir = countersDir(stateDir);
-  if (!existsSync20(dir)) return 0;
+  if (!existsSync21(dir)) return 0;
   let sent = 0;
   for (const f of readdirSync6(dir).filter((n) => n.endsWith(".json")).sort()) {
-    const path = join21(dir, f);
+    const path = join22(dir, f);
     let q2;
     try {
-      q2 = JSON.parse(readFileSync19(path, "utf8"));
+      q2 = JSON.parse(readFileSync20(path, "utf8"));
     } catch {
       continue;
     }
@@ -7608,17 +7761,17 @@ async function replayQueuedTicketCounters(stateDir, route2, keyFor, log, now = /
       const apiKey = await keyFor(q2.role);
       if (!apiKey) continue;
       await writeCounters({ ...q2.target, apiKey }, q2.write);
-      rmSync11(path, { force: true });
+      rmSync12(path, { force: true });
       sent += 1;
       log.emit(`added a queued run's spend to ${q2.write.ticketReference ?? q2.write.recordId} (${f})`);
     } catch (e) {
       if (!isRetryable(e)) {
-        rmSync11(path, { force: true });
+        rmSync12(path, { force: true });
         log.warn(`dropped a queued ticket counter update (${f}): ${e.message}`);
         continue;
       }
       const attempts = q2.attempts + 1;
-      writeFileSync15(path, JSON.stringify({
+      writeFileSync16(path, JSON.stringify({
         ...q2,
         attempts,
         warned: true,
@@ -7821,8 +7974,8 @@ var HandoffTranscriptTracker = class {
 };
 
 // src/pending-handoff.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync15, readdirSync as readdirSync7, readFileSync as readFileSync20, rmSync as rmSync12, writeFileSync as writeFileSync16 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync16, readdirSync as readdirSync7, readFileSync as readFileSync21, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "fs";
+import { join as join24 } from "path";
 
 // src/ticket-branch.ts
 import { basename as basename7 } from "path";
@@ -8988,8 +9141,8 @@ function holdWarnings(tickets, ships, contract, humanHolds, now = Date.now()) {
 }
 
 // src/run-worktree.ts
-import { existsSync as existsSync21 } from "fs";
-import { dirname as dirname10, join as join22 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { dirname as dirname11, join as join23 } from "path";
 var describeRunWorktreePlan = (p) => {
   switch (p.action) {
     case "cut-remote":
@@ -9030,7 +9183,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 && existsSync21(existing.path)) {
+  if (existing && !existing.prunable && existsSync22(existing.path)) {
     const branch = existing.branch;
     if (status(existing.path).length > 0) {
       return { action: opts.resumeInterrupted ? "resume-dirty" : "leave-dirty", path: existing.path, branch };
@@ -9046,7 +9199,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 = join22(dirname10(dir), worktreeForTicket(dir, cfg, t, role));
+  const path = join23(dirname11(dir), worktreeForTicket(dir, cfg, t, role));
   if (located?.where === "remote" || located && hasRemote && remoteBranchExists(dir, remote, located.branch)) {
     return { action: "cut-remote", path, branch: located.branch };
   }
@@ -9100,7 +9253,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 && existsSync21(wt.path)) {
+  if (wt && existsSync22(wt.path)) {
     if (status(wt.path).length > 0) return false;
     if (gitOk(dir, ["worktree", "remove", wt.path]) === null) return false;
   }
@@ -9108,7 +9261,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 || !existsSync21(wt.path)) return { kind: "none" };
+  if (!wt || !existsSync22(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)) {
@@ -9120,7 +9273,7 @@ async function finishRunWorktree(dir, cfg, branch) {
     if (pids.length) await killGently(pids);
   }
   gitOk(dir, ["worktree", "remove", wt.path]);
-  return existsSync21(wt.path) ? { kind: "kept-dirty", path: wt.path } : { kind: "removed", path: wt.path };
+  return existsSync22(wt.path) ? { kind: "kept-dirty", path: wt.path } : { kind: "removed", path: wt.path };
 }
 
 // src/handoff-guard.ts
@@ -9503,20 +9656,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) => join23(stateDir, "pending-handoffs");
-var stateDirOfStream = (streamPath) => join23(streamPath, "..", "..");
+var pendingDirFor = (stateDir) => join24(stateDir, "pending-handoffs");
+var stateDirOfStream = (streamPath) => join24(streamPath, "..", "..");
 function writePendingHandoff(stateDir, rec) {
   const dir = pendingDirFor(stateDir);
-  mkdirSync15(dir, { recursive: true });
-  writeFileSync16(join23(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
+  mkdirSync16(dir, { recursive: true });
+  writeFileSync17(join24(dir, `${rec.ticketRecordId}.json`), JSON.stringify(rec, null, 2));
 }
 function listPendingHandoffs(stateDir, route2) {
   const dir = pendingDirFor(stateDir);
-  if (!existsSync22(dir)) return [];
+  if (!existsSync23(dir)) return [];
   const out = [];
   for (const f of readdirSync7(dir).filter((n) => n.endsWith(".json")).sort()) {
     try {
-      const rec = JSON.parse(readFileSync20(join23(dir, f), "utf8"));
+      const rec = JSON.parse(readFileSync21(join24(dir, f), "utf8"));
       if (rec.version === 1 && rec.ticketRecordId && (!route2 || rec.route === route2)) out.push(rec);
     } catch {
     }
@@ -9524,7 +9677,7 @@ function listPendingHandoffs(stateDir, route2) {
   return out;
 }
 function removePendingHandoff(stateDir, ticketRecordId) {
-  rmSync12(join23(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
+  rmSync13(join24(pendingDirFor(stateDir), `${ticketRecordId}.json`), { force: true });
 }
 function pendingHandoffFor(stateDir, ticketRecordId) {
   return listPendingHandoffs(stateDir).find((r) => r.ticketRecordId === ticketRecordId);
@@ -9634,8 +9787,8 @@ function expandSkillMarkers(text2, lookup2, opts = {}) {
 }
 
 // src/skills.ts
-import { readFileSync as readFileSync22, readdirSync as readdirSync8, existsSync as existsSync24 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync23, readdirSync as readdirSync8, existsSync as existsSync25 } from "fs";
+import { join as join26 } from "path";
 import { parse as parseYaml } from "yaml";
 import { TablationClient as TablationClient3, StaleWriteError as StaleWriteError3, TablationApiError as TablationApiError2 } from "@tablation/client";
 
@@ -9651,8 +9804,8 @@ ${additions}`;
 }
 
 // src/agents.ts
-import { readFileSync as readFileSync21, existsSync as existsSync23 } from "fs";
-import { join as join24 } from "path";
+import { readFileSync as readFileSync22, existsSync as existsSync24 } from "fs";
+import { join as join25 } from "path";
 import { TablationClient as TablationClient2, StaleWriteError as StaleWriteError2, TablationApiError } from "@tablation/client";
 var PERSONA_NAME = {
   dev: "Developer",
@@ -9666,12 +9819,12 @@ var CREW_AGENT_COLUMN = "agent_id";
 var AgentsSyncError = class extends Error {
 };
 function personaDefaultPrompt(promptsDir, role) {
-  const briefPath = join24(promptsDir, "personas", `lane-${role}.md`);
-  if (!existsSync23(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
-  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync21(briefPath, "utf8");
-  const commonPath = join24(promptsDir, "personas", "common.md");
-  if (!existsSync23(commonPath)) return readFileSync21(briefPath, "utf8");
-  return `${readFileSync21(commonPath, "utf8")}${readFileSync21(briefPath, "utf8")}`;
+  const briefPath = join25(promptsDir, "personas", `lane-${role}.md`);
+  if (!existsSync24(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
+  if (SELF_CONTAINED_ROLES.has(role)) return readFileSync22(briefPath, "utf8");
+  const commonPath = join25(promptsDir, "personas", "common.md");
+  if (!existsSync24(commonPath)) return readFileSync22(briefPath, "utf8");
+  return `${readFileSync22(commonPath, "utf8")}${readFileSync22(briefPath, "utf8")}`;
 }
 async function resolveAgentId(route2, role, opts) {
   const cached = route2.resolved?.agentPersonas?.[role]?.agentId;
@@ -10118,7 +10271,7 @@ function describeCrewLink(o) {
 var SkillSyncError = class extends Error {
 };
 function parseSkillFile(path) {
-  const text2 = readFileSync22(path, "utf8");
+  const text2 = readFileSync23(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];
@@ -10131,9 +10284,9 @@ function parseSkillFile(path) {
   return { name: meta.name, description: meta.description, prompt: body, file: path };
 }
 function listLocalSkills(promptsDir) {
-  const dir = join25(promptsDir, "skills");
-  if (!existsSync24(dir)) return [];
-  return readdirSync8(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join25(dir, f)));
+  const dir = join26(promptsDir, "skills");
+  if (!existsSync25(dir)) return [];
+  return readdirSync8(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join26(dir, f)));
 }
 async function syncSkills(route2, opts) {
   if (!route2.resolved) {
@@ -10318,9 +10471,9 @@ function skillMarkerWarnings(promptsDir, personaPrompts) {
 
 // src/runner.ts
 import { spawn as spawn3, execFile, execFileSync as execFileSync6 } from "child_process";
-import { mkdtempSync, mkdirSync as mkdirSync16, writeFileSync as writeFileSync17, rmSync as rmSync13 } from "fs";
+import { mkdtempSync, mkdirSync as mkdirSync17, writeFileSync as writeFileSync18, rmSync as rmSync14 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename8, dirname as dirname11, join as join26 } from "path";
+import { basename as basename8, dirname as dirname12, join as join27 } from "path";
 import { promisify } from "util";
 
 // src/run-limit.ts
@@ -10449,8 +10602,8 @@ var SandboxRunner = class {
         throw new Error(`cannot generate the sandbox policy: ${e.message}`);
       }
       policyFile = policyPathFor(plan.streamPath);
-      mkdirSync16(dirname11(policyFile), { recursive: true });
-      writeFileSync17(policyFile, generated.yaml, { mode: 384 });
+      mkdirSync17(dirname12(policyFile), { recursive: true });
+      writeFileSync18(policyFile, generated.yaml, { mode: 384 });
     }
     const create2 = ["sandbox", "create", "--name", name, "--detach"];
     if (policyFile) create2.push("--policy", policyFile);
@@ -10493,13 +10646,13 @@ var SandboxRunner = class {
       const harness = cfg.agentBin ?? basename8(plan.bin);
       const viaUpload = Buffer.byteLength(plan.prompt) > SANDBOX_STDIN_LIMIT;
       if (viaUpload) {
-        const tmp = mkdtempSync(join26(tmpdir2(), "crew-prompt-"));
+        const tmp = mkdtempSync(join27(tmpdir2(), "crew-prompt-"));
         try {
-          const file = join26(tmp, "prompt.txt");
-          writeFileSync17(file, plan.prompt, { mode: 384 });
+          const file = join27(tmp, "prompt.txt");
+          writeFileSync18(file, plan.prompt, { mode: 384 });
           await this.os(["sandbox", "upload", name, file, SANDBOX_PROMPT_PATH]);
         } finally {
-          rmSync13(tmp, { recursive: true, force: true });
+          rmSync14(tmp, { recursive: true, force: true });
         }
       }
       const withStubs = `PATH=${shQuote2(SANDBOX_STUB_DIR)}:"$PATH"; export PATH; `;
@@ -10649,7 +10802,7 @@ var ALLOWANCE_REFUSAL_MARKER = "AI_ALLOWANCE_EXCEEDED";
 function streamShowsAllowanceRefusal(streamPath) {
   let raw;
   try {
-    raw = readFileSync23(streamPath, "utf8");
+    raw = readFileSync24(streamPath, "utf8");
   } catch {
     return false;
   }
@@ -10672,26 +10825,49 @@ function streamShowsAllowanceRefusal(streamPath) {
   }
   return false;
 }
-var digestPathFor = (stateDir, routeLabel, role, runId) => join27(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPathFor = (stateDir, routeLabel, role, runId) => join28(stateDir, `digest-${routeLabel}-${role}${runId ? `-${runId}` : ""}.md`);
+function codeBridgeFor(o, harness) {
+  if (o.ship.runner === "sandbox" || !o.ticket) return void 0;
+  const number = /(\d+)$/.exec(o.ticket)?.[1];
+  if (!number) return void 0;
+  let intel;
+  try {
+    const repos = reposOf(o.route);
+    const target = repos.find((r) => r.name === o.repo) ?? (repos.length === 1 ? repos[0] : void 0);
+    intel = target ? loadRepoConfig(target.dir)?.hooks?.intel : void 0;
+  } catch {
+  }
+  if (!wantsCodeBridge(intel)) return void 0;
+  const args = [...process.execArgv, process.argv[1] ?? "crew", "intel", "bridge", o.route.route, number, "--state-dir", o.stateDir];
+  const bridge = { command: process.execPath, args };
+  if (harness === "gemini") {
+    const file = join28(intelDir(o.stateDir, o.route.route, number), "gemini-settings.json");
+    mkdirSync18(dirname13(file), { recursive: true });
+    writeFileSync19(file, `${JSON.stringify({ mcpServers: { [INTEL_SERVER_NAME]: { command: bridge.command, args } } }, null, 2)}
+`);
+    bridge.settingsFile = file;
+  }
+  return bridge;
+}
 function planAgentRun(o) {
-  const briefPath = join27(o.route.promptsDir, "personas", `lane-${o.role}.md`);
-  if (!existsSync25(briefPath)) {
+  const briefPath = join28(o.route.promptsDir, "personas", `lane-${o.role}.md`);
+  if (!existsSync26(briefPath)) {
     throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
   }
-  const commonPath = join27(o.route.promptsDir, "personas", "common.md");
-  const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync25(commonPath);
+  const commonPath = join28(o.route.promptsDir, "personas", "common.md");
+  const usesCommon = !SELF_CONTAINED_ROLES.has(o.role) && existsSync26(commonPath);
   const now = o.now ?? (() => Date.now());
   const routeLabel = routeSlug(o.route.route);
   const ownDigest = o.runId ? digestPathFor(o.stateDir, routeLabel, o.role, o.runId) : void 0;
-  const digestPath2 = ownDigest && existsSync25(ownDigest) ? ownDigest : digestPathFor(o.stateDir, routeLabel, o.role);
+  const digestPath2 = ownDigest && existsSync26(ownDigest) ? ownDigest : digestPathFor(o.stateDir, routeLabel, o.role);
   let digest;
   let ageSeconds;
-  if (existsSync25(digestPath2)) {
+  if (existsSync26(digestPath2)) {
     ageSeconds = Math.floor((now() - statSync8(digestPath2).mtimeMs) / 1e3);
-    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync23(digestPath2, "utf8");
+    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync24(digestPath2, "utf8");
   }
-  const common = usesCommon ? readFileSync23(commonPath, "utf8") : "";
-  const brief = readFileSync23(briefPath, "utf8");
+  const common = usesCommon ? readFileSync24(commonPath, "utf8") : "";
+  const brief = readFileSync24(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]));
@@ -10714,7 +10890,7 @@ function planAgentRun(o) {
     digest
   });
   const promptSha = createHash4("sha256").update(expanded.text).digest("hex");
-  const streamsDir = join27(o.stateDir, "streams");
+  const streamsDir = join28(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;
@@ -10729,7 +10905,9 @@ function planAgentRun(o) {
     toolchain = { ...toolchain, inference: { baseUrl: inferenceBaseUrl(o.route.baseUrl, o.route.resolved.workspaceId), token: o.apiKey } };
   }
   const adapter = adapterFor(toolchain.harness);
+  const code = codeBridgeFor(o, adapter.harness);
   const invocation = adapter.invocation(toolchain, {
+    code,
     role: o.role,
     model,
     pluginDirs: adapter.harness === "claude" ? lspPluginDirsFor(o.route, o.repo, o.stateDir) : void 0,
@@ -10788,7 +10966,7 @@ function planAgentRun(o) {
     unsetEnv: adapter.unsetEnv,
     setEnv: {
       ...o.apiKey ? { [API_KEY_VAR]: o.apiKey } : {},
-      ...adapter.runEnv(toolchain),
+      ...adapter.runEnv(toolchain, { code }),
       // The operator's global SessionStart hook (pair-context-hook.sh) injects
       // the interactive Pair persona's prompt for any session it can't tell
       // apart from a person's own terminal. Every headless lane run this
@@ -10805,8 +10983,8 @@ function planAgentRun(o) {
     digestAttached: digest !== void 0,
     digestAgeSeconds: ageSeconds,
     model,
-    streamPath: join27(streamsDir, `${base}.jsonl`),
-    eventsPath: join27(streamsDir, `${base}.events.jsonl`),
+    streamPath: join28(streamsDir, `${base}.jsonl`),
+    eventsPath: join28(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
     ticketRecordId: o.ticketRecordId ?? null,
     repo: o.repo ?? null,
@@ -10837,7 +11015,7 @@ function describePlan(p) {
 var pidPathFor = (streamPath) => `${streamPath}.pid`;
 function readRunSidecar(streamPath) {
   try {
-    const sc = JSON.parse(readFileSync23(pidPathFor(streamPath), "utf8"));
+    const sc = JSON.parse(readFileSync24(pidPathFor(streamPath), "utf8"));
     return typeof sc.pid === "number" && typeof sc.spawnedAt === "string" && typeof sc.role === "string" ? sc : null;
   } catch {
     return null;
@@ -10884,7 +11062,7 @@ async function killForDeadline(kill, pid, emit, role, ticket, spawnedAt, limitMi
 var withoutKey = ({ apiKey: _apiKey, ...rest }) => rest;
 function openSink(path) {
   try {
-    mkdirSync17(dirname12(path), { recursive: true });
+    mkdirSync18(dirname13(path), { recursive: true });
     return createWriteStream(path, { flags: "a" });
   } catch {
     return void 0;
@@ -11070,7 +11248,7 @@ var RunObserver = class {
 };
 function writeRunMeta(id, startedAt, liveTicket, extra) {
   try {
-    writeFileSync18(`${id.streamPath}.meta.json`, JSON.stringify({
+    writeFileSync19(`${id.streamPath}.meta.json`, JSON.stringify({
       route: id.route,
       role: id.role,
       hint: id.ticket,
@@ -11236,7 +11414,7 @@ function spawnAgent(plan, emit, hintMoved) {
   const id = identityOf(plan, adapter.harness);
   let streamFd;
   try {
-    mkdirSync17(dirname12(plan.streamPath), { recursive: true });
+    mkdirSync18(dirname13(plan.streamPath), { recursive: true });
     streamFd = openSync4(plan.streamPath, "a");
   } catch (e) {
     void endSink(eventsSink);
@@ -11294,7 +11472,7 @@ function spawnAgent(plan, emit, hintMoved) {
           promptSha: plan.promptSha
         };
         try {
-          writeFileSync18(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
+          writeFileSync19(pidPathFor(plan.streamPath), JSON.stringify(sidecar));
         } catch {
         }
       }
@@ -11408,21 +11586,21 @@ var pidAlive = (pid) => {
 };
 function runFinished(streamPath) {
   const path = `${streamPath}.meta.json`;
-  if (!existsSync26(path)) return false;
+  if (!existsSync27(path)) return false;
   try {
-    return JSON.parse(readFileSync24(path, "utf8")).running !== true;
+    return JSON.parse(readFileSync25(path, "utf8")).running !== true;
   } catch {
     return true;
   }
 }
 function orphanedStreams(o) {
-  const dir = join28(o.stateDir, "streams");
-  if (!existsSync26(dir)) return [];
+  const dir = join29(o.stateDir, "streams");
+  if (!existsSync27(dir)) return [];
   const ownerAlive = o.isOwnerAlive ?? pidAlive;
   const out = [];
   for (const name of readdirSync9(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join28(dir, name);
+    const streamPath = join29(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || sidecar.route !== o.routeLabel) continue;
@@ -11475,15 +11653,15 @@ async function reconcileRuns(o) {
 }
 
 // src/live-runs.ts
-import { existsSync as existsSync27, readdirSync as readdirSync10, statSync as statSync9 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync28, readdirSync as readdirSync10, statSync as statSync9 } from "fs";
+import { join as join30 } from "path";
 function liveRuns(stateDir, isAlive = runIsAlive) {
-  const dir = join29(stateDir, "streams");
-  if (!existsSync27(dir)) return [];
+  const dir = join30(stateDir, "streams");
+  if (!existsSync28(dir)) return [];
   const out = [];
   for (const name of readdirSync10(dir)) {
     if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-    const streamPath = join29(dir, name);
+    const streamPath = join30(dir, name);
     if (runFinished(streamPath)) continue;
     const sidecar = readRunSidecar(streamPath);
     if (!sidecar || !isAlive(sidecar)) continue;
@@ -11493,12 +11671,12 @@ function liveRuns(stateDir, isAlive = runIsAlive) {
 }
 function runActivity(stateDir, isAlive = runIsAlive) {
   const activeRuns = liveRuns(stateDir, isAlive).length;
-  const dir = join29(stateDir, "streams");
+  const dir = join30(stateDir, "streams");
   let newest = 0;
-  if (existsSync27(dir)) {
+  if (existsSync28(dir)) {
     for (const name of readdirSync10(dir)) {
       if (!name.endsWith(".jsonl") || name.endsWith(".events.jsonl")) continue;
-      const streamPath = join29(dir, name);
+      const streamPath = join30(dir, name);
       if (!runFinished(streamPath)) continue;
       try {
         newest = Math.max(newest, statSync9(`${streamPath}.meta.json`).mtimeMs);
@@ -11869,7 +12047,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) => existsSync28(p));
+    return ["run", "release", "passengers"].flatMap((job) => planInstall(cfg.ship, crewHome, host, systemd, job, ctx).unitPaths).filter((p) => existsSync29(p));
   };
   return {
     liveRuns: () => liveRuns(stateDir).map((r) => ({ role: r.role, route: r.route, pid: r.pid, ticketRecordId: r.ticketRecordId ?? void 0, streamPath: r.streamPath })),
@@ -11930,7 +12108,7 @@ function realDeprovisionDeps(cfg, emit, crewHome, getStore) {
     },
     remaining() {
       const left = [];
-      if (existsSync28(cfg.configFile)) left.push(`config ${cfg.configFile}`);
+      if (existsSync29(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}`);
@@ -12538,19 +12716,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) => join30(stateDir, "sandbox-images.json");
+var sandboxStatePath = (stateDir) => join31(stateDir, "sandbox-images.json");
 function readSandboxState(stateDir) {
   try {
-    const v = JSON.parse(readFileSync25(sandboxStatePath(stateDir), "utf8"));
+    const v = JSON.parse(readFileSync26(sandboxStatePath(stateDir), "utf8"));
     return v && typeof v === "object" && !Array.isArray(v) ? v : {};
   } catch {
     return {};
   }
 }
 function writeSandboxState(stateDir, state) {
-  mkdirSync18(stateDir, { recursive: true });
+  mkdirSync19(stateDir, { recursive: true });
   const file = sandboxStatePath(stateDir);
-  writeFileSync19(`${file}.tmp`, `${JSON.stringify(state, null, 2)}
+  writeFileSync20(`${file}.tmp`, `${JSON.stringify(state, null, 2)}
 `);
   renameSync3(`${file}.tmp`, file);
 }
@@ -12570,7 +12748,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 = "") => {
-    writeFileSync19(logPath, `$ ${engine} ${args.join(" ")}
+    writeFileSync20(logPath, `$ ${engine} ${args.join(" ")}
 ${Buffer.concat(chunks).toString("utf8")}${extra}`, { flag: "a" });
     resolve8(code);
   };
@@ -12592,7 +12770,7 @@ var engineRemoveImage = (engine = "docker", exec = realExec2) => (tag) => {
   } catch {
   }
 };
-var sandboxLogDir = (stateDir) => join30(stateDir, "sandbox-logs");
+var sandboxLogDir = (stateDir) => join31(stateDir, "sandbox-logs");
 async function buildSandboxImage(plan, deps) {
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   const state = readSandboxState(deps.stateDir);
@@ -12601,20 +12779,20 @@ async function buildSandboxImage(plan, deps) {
     return { kind: "reused", tag: plan.tag };
   }
   const logDir = sandboxLogDir(deps.stateDir);
-  mkdirSync18(logDir, { recursive: true });
-  const logPath = join30(logDir, `${slug(plan.repo)}-${now().toISOString().replace(/[:.]/g, "-")}.log`);
+  mkdirSync19(logDir, { recursive: true });
+  const logPath = join31(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 = join30(tmpdir3(), `crew-sandbox-${hash([layer.tag, process.pid, Date.now()])}`);
-    mkdirSync18(ctx, { recursive: true });
+    const ctx = join31(tmpdir3(), `crew-sandbox-${hash([layer.tag, process.pid, Date.now()])}`);
+    mkdirSync19(ctx, { recursive: true });
     try {
-      writeFileSync19(join30(ctx, "Dockerfile"), layer.dockerfile);
+      writeFileSync20(join31(ctx, "Dockerfile"), layer.dockerfile);
       for (const [name, content] of Object.entries(layer.files)) {
-        mkdirSync18(dirname13(join30(ctx, name)), { recursive: true });
-        writeFileSync19(join30(ctx, name), content);
+        mkdirSync19(dirname14(join31(ctx, name)), { recursive: true });
+        writeFileSync20(join31(ctx, name), content);
       }
-      const code = await deps.run(["build", "--tag", layer.tag, "--file", join30(ctx, "Dockerfile"), ctx], logPath);
+      const code = await deps.run(["build", "--tag", layer.tag, "--file", join31(ctx, "Dockerfile"), ctx], logPath);
       if (code !== 0) {
         state[plan.repo] = { ...entry, failure: { tag: plan.tag, at: now().toISOString(), logPath } };
         writeSandboxState(deps.stateDir, state);
@@ -12622,7 +12800,7 @@ async function buildSandboxImage(plan, deps) {
       }
       builtLayers.push(layer.name);
     } finally {
-      rmSync14(ctx, { recursive: true, force: true });
+      rmSync15(ctx, { recursive: true, force: true });
     }
   }
   const tags = [{ tag: plan.tag, builtAt: now().toISOString(), claude: plan.claude }, ...entry.tags.filter((t) => t.tag !== plan.tag)];
@@ -12803,9 +12981,9 @@ function managedRuntimeWarnings(kind, ship) {
 
 // src/selftest.ts
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync29, mkdirSync as mkdirSync19, mkdtempSync as mkdtempSync2, readFileSync as readFileSync26, rmSync as rmSync15, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync20, mkdtempSync as mkdtempSync2, readFileSync as readFileSync27, rmSync as rmSync16, writeFileSync as writeFileSync21 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join31 } from "path";
+import { join as join32 } 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: ";
@@ -12966,7 +13144,7 @@ async function runSelftest(i, deps = realDeps) {
     ...adapter.runEnv(spec),
     [KEY_VAR]: i.apiKey
   };
-  const cwd = mkdtempSync2(join31(tmpdir4(), "crew-selftest-"));
+  const cwd = mkdtempSync2(join32(tmpdir4(), "crew-selftest-"));
   try {
     const run3 = await deps.run({
       bin: invocation.bin,
@@ -12988,7 +13166,7 @@ async function runSelftest(i, deps = realDeps) {
     return finish({ ok: false, failure, detail, ...usage2 });
   } finally {
     try {
-      rmSync15(cwd, { recursive: true, force: true });
+      rmSync16(cwd, { recursive: true, force: true });
     } catch {
     }
   }
@@ -12999,11 +13177,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) => join31(stateDir, "selftest.json");
+var fileFor2 = (stateDir) => join32(stateDir, "selftest.json");
 function readSelftest(stateDir) {
   try {
     const p = fileFor2(stateDir);
-    return existsSync29(p) ? JSON.parse(readFileSync26(p, "utf8")) : {};
+    return existsSync30(p) ? JSON.parse(readFileSync27(p, "utf8")) : {};
   } catch {
     return {};
   }
@@ -13011,8 +13189,8 @@ function readSelftest(stateDir) {
 function recordSelftest(stateDir, results) {
   const all = readSelftest(stateDir);
   for (const r of results) all[r.toolchain] = r;
-  mkdirSync19(stateDir, { recursive: true });
-  writeFileSync20(fileFor2(stateDir), `${JSON.stringify(all, null, 2)}
+  mkdirSync20(stateDir, { recursive: true });
+  writeFileSync21(fileFor2(stateDir), `${JSON.stringify(all, null, 2)}
 `);
 }
 function doctorSelftestLines(stored, toolchains) {
@@ -13024,7 +13202,7 @@ function doctorSelftestLines(stored, toolchains) {
 }
 
 // src/cli.ts
-import { resolve as resolve7, dirname as dirname32, join as join53, basename as basename16 } from "path";
+import { resolve as resolve7, dirname as dirname33, join as join54, basename as basename16 } from "path";
 import { fileURLToPath } from "url";
 import { hostname as hostname4, homedir as homedir11 } from "os";
 import { spawnSync as spawnSync11 } from "child_process";
@@ -13032,6 +13210,7 @@ import { parse as parseYaml2 } from "yaml";
 
 // src/argv.ts
 var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "state-dir",
   "agent-bin",
   "area",
   "base-url",
@@ -13221,14 +13400,14 @@ function rosterMarkdown(roster, meId) {
 }
 
 // src/connect-resume.ts
-import { mkdirSync as mkdirSync20, readFileSync as readFileSync27, rmSync as rmSync16, writeFileSync as writeFileSync21 } from "fs";
-import { dirname as dirname14, join as join32 } from "path";
+import { mkdirSync as mkdirSync21, readFileSync as readFileSync28, rmSync as rmSync17, writeFileSync as writeFileSync22 } from "fs";
+import { dirname as dirname15, join as join33 } from "path";
 function lastSessionFile(stateDir) {
-  return join32(stateDir, "connect-session.json");
+  return join33(stateDir, "connect-session.json");
 }
 function readPointers(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync27(lastSessionFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync28(lastSessionFile(stateDir), "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     const out = {};
     for (const [host, v] of Object.entries(parsed)) {
@@ -13242,8 +13421,8 @@ function readPointers(stateDir) {
 }
 function writePointers(stateDir, pointers) {
   const file = lastSessionFile(stateDir);
-  mkdirSync20(dirname14(file), { recursive: true });
-  writeFileSync21(file, `${JSON.stringify(pointers, null, 2)}
+  mkdirSync21(dirname15(file), { recursive: true });
+  writeFileSync22(file, `${JSON.stringify(pointers, null, 2)}
 `, { mode: 384 });
 }
 function rememberSession(stateDir, host, workspaceSlug) {
@@ -13260,7 +13439,7 @@ function forgetWorkspace(stateDir, host, workspaceSlug) {
     const { [host]: _old, ...rest } = all;
     const next = left.length ? { ...rest, [host]: left } : rest;
     if (Object.keys(next).length) writePointers(stateDir, next);
-    else rmSync16(lastSessionFile(stateDir), { force: true });
+    else rmSync17(lastSessionFile(stateDir), { force: true });
   } catch {
   }
 }
@@ -13300,7 +13479,7 @@ function forgetSession(stateDir, host) {
   try {
     const { [host]: _gone, ...rest } = readPointers(stateDir);
     if (Object.keys(rest).length) writePointers(stateDir, rest);
-    else rmSync16(lastSessionFile(stateDir), { force: true });
+    else rmSync17(lastSessionFile(stateDir), { force: true });
   } catch {
   }
 }
@@ -13328,15 +13507,15 @@ async function signOutSessions(o) {
 }
 
 // src/reset.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync21, readFileSync as readFileSync28, readdirSync as readdirSync12, rmSync as rmSync17, statSync as statSync10, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname15, join as join33 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync22, readFileSync as readFileSync29, readdirSync as readdirSync12, rmSync as rmSync18, statSync as statSync10, writeFileSync as writeFileSync23 } from "fs";
+import { dirname as dirname16, join as join34 } from "path";
 import { hostFromUrl as hostFromUrl3 } from "@tablation/client";
 function clonedCheckoutsFile(stateDir) {
-  return join33(stateDir, "cloned-checkouts.json");
+  return join34(stateDir, "cloned-checkouts.json");
 }
 function readClonedCheckouts(stateDir) {
   try {
-    const parsed = JSON.parse(readFileSync28(clonedCheckoutsFile(stateDir), "utf8"));
+    const parsed = JSON.parse(readFileSync29(clonedCheckoutsFile(stateDir), "utf8"));
     return Array.isArray(parsed) ? parsed.filter((d) => typeof d === "string") : [];
   } catch {
     return [];
@@ -13346,8 +13525,8 @@ function recordClonedCheckout(stateDir, dir) {
   const known = readClonedCheckouts(stateDir);
   if (known.includes(dir)) return;
   const file = clonedCheckoutsFile(stateDir);
-  mkdirSync21(dirname15(file), { recursive: true });
-  writeFileSync22(file, `${JSON.stringify([...known, dir], null, 2)}
+  mkdirSync22(dirname16(file), { recursive: true });
+  writeFileSync23(file, `${JSON.stringify([...known, dir], null, 2)}
 `);
 }
 var mark = (dryRun) => dryRun ? "would-remove" : "removed";
@@ -13401,8 +13580,8 @@ 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 (existsSync30(o.configFile)) {
-    if (!o.dryRun) rmSync17(o.configFile, { force: true });
+  if (existsSync31(o.configFile)) {
+    if (!o.dryRun) rmSync18(o.configFile, { force: true });
     steps.push({ step: "config", target: o.configFile, action: mark(o.dryRun) });
   } else {
     steps.push({ step: "config", target: o.configFile, action: "absent" });
@@ -13410,7 +13589,7 @@ async function runReset(o, fx) {
   return steps;
 }
 function removeCheckout(dir, dryRun, fx) {
-  if (!existsSync30(dir)) return { step: "checkout", target: dir, action: "absent", detail: "already gone" };
+  if (!existsSync31(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" : ""})` };
@@ -13418,21 +13597,21 @@ function removeCheckout(dir, dryRun, fx) {
   if (linkedWorktrees.length) {
     return { step: "checkout", target: dir, action: "kept", detail: `has linked worktrees (${linkedWorktrees.join(", ")}); remove them first` };
   }
-  if (!dryRun) rmSync17(dir, { recursive: true, force: true });
+  if (!dryRun) rmSync18(dir, { recursive: true, force: true });
   return { step: "checkout", target: dir, action: mark(dryRun) };
 }
 function removeState(stateDir, dryRun) {
   const out = [];
-  const targets = [join33(stateDir, "resolved"), join33(stateDir, "keys"), clonedCheckoutsFile(stateDir), join33(stateDir, "connect-session.json"), join33(stateDir, "reload-requested"), join33(stateDir, "daemon.started")];
+  const targets = [join34(stateDir, "resolved"), join34(stateDir, "keys"), clonedCheckoutsFile(stateDir), join34(stateDir, "connect-session.json"), join34(stateDir, "reload-requested"), join34(stateDir, "daemon.started")];
   try {
     for (const name of readdirSync12(stateDir)) {
-      if (name.startsWith(".") && statSync10(join33(stateDir, name)).isFile()) targets.push(join33(stateDir, name));
+      if (name.startsWith(".") && statSync10(join34(stateDir, name)).isFile()) targets.push(join34(stateDir, name));
     }
   } catch {
   }
   for (const t of targets) {
-    if (!existsSync30(t)) continue;
-    if (!dryRun) rmSync17(t, { recursive: true, force: true });
+    if (!existsSync31(t)) continue;
+    if (!dryRun) rmSync18(t, { recursive: true, force: true });
     out.push({ step: "state", target: t, action: mark(dryRun) });
   }
   if (!out.length) out.push({ step: "state", target: stateDir, action: "absent", detail: "nothing to remove" });
@@ -13446,7 +13625,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) rmSync17(join33(stateDir, n), { recursive: true, force: true });
+  if (!dryRun) for (const n of names) rmSync18(join34(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) {
@@ -13527,9 +13706,9 @@ async function runDeprovision(o, fx, deps) {
 }
 
 // src/pool-member.ts
-import { mkdirSync as mkdirSync22, readFileSync as readFileSync29, renameSync as renameSync4, writeFileSync as writeFileSync23 } from "fs";
+import { mkdirSync as mkdirSync23, readFileSync as readFileSync30, renameSync as renameSync4, writeFileSync as writeFileSync24 } from "fs";
 import { homedir as homedir8 } from "os";
-import { dirname as dirname16, join as join34 } from "path";
+import { dirname as dirname17, join as join35 } from "path";
 var POOL_EXIT = { ok: 0, failed: 1, credential: 2 };
 function backoffMs(attempt) {
   return Math.min(6e4, 5e3 * 2 ** Math.max(0, attempt));
@@ -13760,22 +13939,22 @@ async function runPoolMember(deps) {
   }
 }
 function defaultMemberDir(env = process.env) {
-  return env.CREW_POOL_DIR ?? join34(env.XDG_STATE_HOME ?? join34(homedir8(), ".local", "state"), "crew-pool-member");
+  return env.CREW_POOL_DIR ?? join35(env.XDG_STATE_HOME ?? join35(homedir8(), ".local", "state"), "crew-pool-member");
 }
 function fileMemberStore(dir) {
-  const file = join34(dir, "member.json");
+  const file = join35(dir, "member.json");
   return {
     read() {
       try {
-        return JSON.parse(readFileSync29(file, "utf8"));
+        return JSON.parse(readFileSync30(file, "utf8"));
       } catch {
         return {};
       }
     },
     write(f) {
-      mkdirSync22(dirname16(file), { recursive: true, mode: 448 });
+      mkdirSync23(dirname17(file), { recursive: true, mode: 448 });
       const tmp = `${file}.tmp`;
-      writeFileSync23(tmp, `${JSON.stringify(f)}
+      writeFileSync24(tmp, `${JSON.stringify(f)}
 `, { mode: 384 });
       renameSync4(tmp, file);
     }
@@ -13827,16 +14006,16 @@ function hostArchitecture(arch = process.arch) {
 
 // src/pool-member-host.ts
 import "child_process";
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 import { hostname as hostname3 } from "os";
 
 // src/machine-id.ts
 import { execFileSync as execFileSync10 } from "child_process";
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync31, mkdirSync as mkdirSync23, readFileSync as readFileSync30, writeFileSync as writeFileSync24 } from "fs";
-import { dirname as dirname17, join as join35 } from "path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync24, readFileSync as readFileSync31, writeFileSync as writeFileSync25 } from "fs";
+import { dirname as dirname18, join as join36 } from "path";
 function machineIdPathFor(stateDir) {
-  return join35(stateDir, "machine-id");
+  return join36(stateDir, "machine-id");
 }
 var sha256 = (s) => createHash7("sha256").update(s).digest("hex");
 function readRawMachineId(platform2 = process.platform) {
@@ -13849,8 +14028,8 @@ function readRawMachineId(platform2 = process.platform) {
       return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(out)?.[1];
     }
     for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
-      if (existsSync31(p)) {
-        const id = readFileSync30(p, "utf8").trim();
+      if (existsSync32(p)) {
+        const id = readFileSync31(p, "utf8").trim();
         if (id) return id;
       }
     }
@@ -13861,15 +14040,15 @@ function readRawMachineId(platform2 = process.platform) {
 function ensureMachineId(stateDir, opts = {}) {
   if (opts.override?.trim()) return sha256(opts.override.trim());
   const path = machineIdPathFor(stateDir);
-  if (existsSync31(path)) {
-    const cached = readFileSync30(path, "utf8").trim();
+  if (existsSync32(path)) {
+    const cached = readFileSync31(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);
-  mkdirSync23(dirname17(path), { recursive: true });
-  writeFileSync24(path, `${hashed}
+  mkdirSync24(dirname18(path), { recursive: true });
+  writeFileSync25(path, `${hashed}
 `, { mode: 384 });
   return hashed;
 }
@@ -13882,7 +14061,7 @@ function matchShipRows(ships, shipName2, machineId) {
 
 // src/provision.ts
 import { spawnSync as spawnSync8 } from "child_process";
-import { existsSync as existsSync32, readFileSync as readFileSync31, writeFileSync as writeFileSync25 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync32, writeFileSync as writeFileSync26 } from "fs";
 import { hostname as hostname2 } from "os";
 import { parseDocument as parseDocument3, isMap as isMap2, isScalar } from "yaml";
 
@@ -13891,7 +14070,7 @@ import { parseDocument as parseDocument2 } from "yaml";
 
 // src/repos-cmd.ts
 import { homedir as homedir9 } from "os";
-import { basename as basename10, join as join36, resolve as resolve4 } from "path";
+import { basename as basename10, join as join37, resolve as resolve4 } from "path";
 import { isMap, isSeq, parseDocument, stringify as stringify2 } from "yaml";
 var ReposError = class extends Error {
 };
@@ -14169,7 +14348,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) : join36(expandDir(basePath, i.base), i.route.split("/")[0], name);
+  const target = i.dir ? expandDir(i.dir, i.base) : join37(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 } : {} };
@@ -14476,7 +14655,7 @@ function realProvisionDeps(crewHome) {
   };
   const configFile = () => {
     const f = findConfigFile(crewHome);
-    return existsSync32(f) ? f : null;
+    return existsSync33(f) ? f : null;
   };
   return {
     crew: spawnCrew,
@@ -14484,13 +14663,13 @@ function realProvisionDeps(crewHome) {
     enableRoute(route2) {
       const file = configFile();
       if (!file) return false;
-      const text2 = readFileSync31(file, "utf8");
+      const text2 = readFileSync32(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;
-      writeFileSync25(file, planEnable(text2, route2));
+      writeFileSync26(file, planEnable(text2, route2));
       return true;
     },
     installState() {
@@ -14510,14 +14689,14 @@ function realProvisionDeps(crewHome) {
           continue;
         }
         for (const p of plan.unitPaths) {
-          if (!existsSync32(p) || readFileSync31(p, "utf8") !== plan.unitContent[p]) unitsStale = true;
+          if (!existsSync33(p) || readFileSync32(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 || existsSync32(systemUnitPathFor(label));
+        const system = ctx.root || existsSync33(systemUnitPathFor(label));
         const ctl = system ? ["systemctl"] : ["systemctl", "--user"];
         running = spawnSync8(ctl[0], [...ctl.slice(1), "is-active", "--quiet", `${label}.service`]).status === 0;
         if (!system) {
@@ -14534,18 +14713,18 @@ function realProvisionDeps(crewHome) {
     setShipSetting(key, value2) {
       const file = configFile();
       if (!file) return false;
-      const doc = parseDocument3(readFileSync31(file, "utf8"));
+      const doc = parseDocument3(readFileSync32(file, "utf8"));
       if (doc.getIn(["ship", key]) === value2) return false;
       doc.setIn(["ship", key], value2);
-      writeFileSync25(file, doc.toString());
+      writeFileSync26(file, doc.toString());
       return true;
     },
     applyManagedDefaults() {
       const file = configFile();
       if (!file) return [];
-      const doc = parseDocument3(readFileSync31(file, "utf8"));
+      const doc = parseDocument3(readFileSync32(file, "utf8"));
       const wrote = applyManagedDefaultsToDoc(doc);
-      if (wrote.length) writeFileSync25(file, doc.toString());
+      if (wrote.length) writeFileSync26(file, doc.toString());
       return wrote;
     },
     storedToken(host) {
@@ -14562,9 +14741,9 @@ host=${host}
 
 // src/tunnel.ts
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync33, mkdirSync as mkdirSync24, readFileSync as readFileSync32, writeFileSync as writeFileSync26, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync25, readFileSync as readFileSync33, writeFileSync as writeFileSync27, unlinkSync as unlinkSync3, readdirSync as readdirSync13 } from "fs";
 import { randomInt } from "crypto";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn7(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -14636,21 +14815,21 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join37(stateDir, "passengers", `${workspaceId}.json`);
+  return join38(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
-  if (!existsSync33(path)) return void 0;
+  if (!existsSync34(path)) return void 0;
   try {
-    return JSON.parse(readFileSync32(path, "utf8"));
+    return JSON.parse(readFileSync33(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync24(join37(stateDir, "passengers"), { recursive: true });
-  writeFileSync26(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync25(join38(stateDir, "passengers"), { recursive: true });
+  writeFileSync27(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function updatePersistedTunnel(stateDir, workspaceId, patch2) {
@@ -14752,8 +14931,8 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join37(stateDir, "passengers");
-  if (!existsSync33(dir)) return [];
+  const dir = join38(stateDir, "passengers");
+  if (!existsSync34(dir)) return [];
   return readdirSync13(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
@@ -14778,7 +14957,7 @@ function realPoolMemberDeps(o) {
       crewVersion: crewVersion(o.crewHome),
       hostname: hostname3()
     },
-    hasShipConfig: () => existsSync34(findConfigFile(o.crewHome)),
+    hasShipConfig: () => existsSync35(findConfigFile(o.crewHome)),
     async provision(lease, instanceClass, shipKind) {
       const hosts = lease.forges.map((f) => f.host.toLowerCase());
       const lines2 = [];
@@ -15654,8 +15833,8 @@ ${waiting.map((t) => `| ${displayKey2(t)} | ${t.status} | ${blockers(t, i)} |`).
 }
 
 // src/poll.ts
-import { writeFileSync as writeFileSync27 } from "fs";
-import { join as join38 } from "path";
+import { writeFileSync as writeFileSync28 } from "fs";
+import { join as join39 } from "path";
 
 // src/stalled.ts
 var STALLED_AFTER_CYCLES = 30;
@@ -15962,7 +16141,7 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route2, role, runId) => join38(stateDir, `digest-${route2}-${role}${runId ? `-${runId}` : ""}.md`);
+var digestPath = (stateDir, route2, role, runId) => join39(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));
@@ -16040,7 +16219,7 @@ function writeDigest(o, d, role, stateDir, runId, own) {
 
 ${body}` : body;
     const path = digestPath(stateDir, routeSlug(o.route.route), role, runId);
-    writeFileSync27(path, text2);
+    writeFileSync28(path, text2);
     o.emit.emit(`queue digest written for ${role} (${Buffer.byteLength(text2)} bytes)`, {
       data: { role, bytes: Buffer.byteLength(text2) }
     });
@@ -16148,8 +16327,8 @@ async function resolveOne(tracker, t, seat, approvedStatus, buildingStatus, affi
 }
 
 // src/repo-refresh.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync25, readFileSync as readFileSync33, writeFileSync as writeFileSync28 } from "fs";
-import { dirname as dirname19 } from "path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync26, readFileSync as readFileSync34, writeFileSync as writeFileSync29 } from "fs";
+import { dirname as dirname20 } from "path";
 var REFRESH_COOLDOWN_MS = 2 * 6e4;
 var UNSERVABLE_PASSES_BEFORE_ATTENTION = 3;
 var lastAsked = /* @__PURE__ */ new Map();
@@ -16178,11 +16357,11 @@ function applyRepoRows(resolved, rows) {
 }
 function persistRepoRows(stateDir, routeName, rows) {
   const path = resolvedPathFor(stateDir, routeName);
-  if (!existsSync35(path)) return;
-  const raw = JSON.parse(readFileSync33(path, "utf8"));
+  if (!existsSync36(path)) return;
+  const raw = JSON.parse(readFileSync34(path, "utf8"));
   applyRepoRows(raw, rows);
-  mkdirSync25(dirname19(path), { recursive: true });
-  writeFileSync28(path, `${JSON.stringify(raw, null, 2)}
+  mkdirSync26(dirname20(path), { recursive: true });
+  writeFileSync29(path, `${JSON.stringify(raw, null, 2)}
 `);
 }
 async function refreshUnknownRepos(o) {
@@ -16632,13 +16811,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 dirname20, join as join39 } from "path";
-import { accessSync as accessSync3, constants as constants3, existsSync as existsSync36, mkdirSync as mkdirSync26, writeFileSync as writeFileSync29 } from "fs";
+import { delimiter, dirname as dirname21, join as join40 } from "path";
+import { accessSync as accessSync3, constants as constants3, existsSync as existsSync37, mkdirSync as mkdirSync27, writeFileSync as writeFileSync30 } from "fs";
 import { stringify as stringify3 } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
 function shouldRunWizard(opts) {
   if (!opts.isTTY) return false;
-  const exists = opts.configExists ?? existsSync36;
+  const exists = opts.configExists ?? existsSync37;
   return !configSearchPath(opts.crewHome).some((p) => exists(p));
 }
 function firstRunConfigPath() {
@@ -16655,7 +16834,7 @@ function defaultIsExecutable(p) {
 function findOnPath2(name, pathEnv, isExecutable = defaultIsExecutable) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join39(dir, name);
+    const candidate = join40(dir, name);
     if (isExecutable(candidate)) return candidate;
   }
   return void 0;
@@ -16681,9 +16860,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 = dirname20(env.nodePath);
+  const nodeDir = dirname21(env.nodePath);
   const pnpmPath = findOnPath2("pnpm", env.pathEnv, isExec);
-  const baseDirs = [nodeDir, pnpmPath ? dirname20(pnpmPath) : void 0];
+  const baseDirs = [nodeDir, pnpmPath ? dirname21(pnpmPath) : void 0];
   p.say(
     `
 Host Passengers lets this machine run the agent sessions that other people's
@@ -16694,7 +16873,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 ? dirname20(dockerPath) : void 0]);
+  const extraPath = deriveExtraPath([...baseDirs, dockerPath ? dirname21(dockerPath) : void 0]);
   if (extraPath) {
     p.say(`Hooks will get ${extraPath} on their PATH (where node, pnpm${dockerPath ? " and docker" : ""} live).`);
   }
@@ -16716,9 +16895,9 @@ routes:
 ${routeBlock}`;
 }
 function writeNewConfig(path, text2) {
-  mkdirSync26(dirname20(path), { recursive: true });
+  mkdirSync27(dirname21(path), { recursive: true });
   try {
-    writeFileSync29(path, text2, { mode: 384, flag: "wx" });
+    writeFileSync30(path, text2, { mode: 384, flag: "wx" });
     return true;
   } catch (e) {
     if (e.code === "EEXIST") return false;
@@ -16752,7 +16931,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 dirname21, join as join40 } from "path";
+import { dirname as dirname22, join as join41 } from "path";
 import { delimiter as delimiter2 } from "path";
 var CHOICE_EXIT_CODE = 3;
 function createEmitter(json2, write) {
@@ -16791,12 +16970,12 @@ function agentBinSearchDirs(home, pathEnv, extraPath) {
   const dirs = [
     ...pathEnv.split(delimiter2),
     ...(extraPath ?? "").split(delimiter2),
-    join40(home, ".local/bin"),
-    join40(home, ".claude/local"),
+    join41(home, ".local/bin"),
+    join41(home, ".claude/local"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
-    join40(home, ".npm-global/bin"),
-    join40(home, ".volta/bin")
+    join41(home, ".npm-global/bin"),
+    join41(home, ".volta/bin")
   ];
   return [...new Set(dirs.filter(Boolean))];
 }
@@ -16818,7 +16997,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([dirname21(env.nodePath), pnpmPath ? dirname21(pnpmPath) : void 0, dockerPath ? dirname21(dockerPath) : void 0]);
+  const extraPath = f.extraPath ?? deriveExtraPath([dirname22(env.nodePath), pnpmPath ? dirname22(pnpmPath) : void 0, dockerPath ? dirname22(dockerPath) : void 0]);
   return {
     answers: {
       name: f.shipName?.trim() || env.hostname,
@@ -16832,8 +17011,8 @@ function flagWizardAnswers(f, env) {
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync34, writeFileSync as writeFileSync30, existsSync as existsSync37, copyFileSync, mkdirSync as mkdirSync27, mkdtempSync as mkdtempSync3, rmSync as rmSync18 } from "fs";
-import { dirname as dirname22, join as join41 } from "path";
+import { readFileSync as readFileSync35, writeFileSync as writeFileSync31, existsSync as existsSync38, copyFileSync, mkdirSync as mkdirSync28, mkdtempSync as mkdtempSync3, rmSync as rmSync19 } from "fs";
+import { dirname as dirname23, join as join42 } from "path";
 import { tmpdir as tmpdir5 } from "os";
 
 // src/release.ts
@@ -17574,13 +17753,13 @@ async function bump(o, size) {
     }
     return printed;
   }
-  const files = o.repo.release.versionFiles.map((f) => join41(o.cwd, f));
+  const files = o.repo.release.versionFiles.map((f) => join42(o.cwd, f));
   const first = files[0];
-  if (!existsSync37(first)) {
+  if (!existsSync38(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
     return null;
   }
-  const current = JSON.parse(readFileSync34(first, "utf8")).version;
+  const current = JSON.parse(readFileSync35(first, "utf8")).version;
   if (!current) {
     o.emit.error(`no version field in ${o.repo.release.versionFiles[0]}`);
     return null;
@@ -17593,27 +17772,27 @@ async function bump(o, size) {
     return version;
   }
   for (const f of files) {
-    const src = readFileSync34(f, "utf8");
+    const src = readFileSync35(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;
     }
-    writeFileSync30(f, out);
+    writeFileSync31(f, out);
   }
   return version;
 }
 function writeChangelog(o, version, entries) {
   const file = o.repo.release.changelog;
   if (!file || entries.length === 0) return;
-  const path = join41(o.cwd, file);
+  const path = join42(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 = existsSync37(path) ? readFileSync34(path, "utf8") : "# Changelog\n";
-  writeFileSync30(path, insertChangelogSection(existing, section));
+  const existing = existsSync38(path) ? readFileSync35(path, "utf8") : "# Changelog\n";
+  writeFileSync31(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
   if (!o.repo.hooks.released) return void 0;
@@ -17696,7 +17875,7 @@ function closeReleaseCheckout(cwd, root, dir, branch, run3 = gitOk) {
     run3(cwd, ["worktree", "remove", "--force", dir]);
   } finally {
     try {
-      rmSync18(root, { recursive: true, force: true });
+      rmSync19(root, { recursive: true, force: true });
     } finally {
       run3(cwd, ["worktree", "prune"]);
       run3(cwd, ["branch", "-D", branch]);
@@ -17706,8 +17885,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(join41(tmpdir5(), "crew-release-"));
-  const dir = join41(root, "checkout");
+  const root = mkdtempSync3(join42(tmpdir5(), "crew-release-"));
+  const dir = join42(root, "checkout");
   o.emit.emit(`release checkout: ${dir}`, { step: "release" });
   const close = () => closeReleaseCheckout(o.cwd, root, dir, branch);
   try {
@@ -17717,10 +17896,10 @@ function openReleaseCheckout(o) {
     throw e;
   }
   for (const f of o.repo.worktrees.copy) {
-    const src = join41(o.cwd, f);
-    if (!existsSync37(src)) continue;
-    mkdirSync27(dirname22(join41(dir, f)), { recursive: true });
-    copyFileSync(src, join41(dir, f));
+    const src = join42(o.cwd, f);
+    if (!existsSync38(src)) continue;
+    mkdirSync28(dirname23(join42(dir, f)), { recursive: true });
+    copyFileSync(src, join42(dir, f));
   }
   return { dir, branch, close };
 }
@@ -18742,7 +18921,7 @@ function missingReleaserWarning(repo, release, ships, now = Date.now()) {
 }
 
 // src/watch.ts
-import { watch as watchFile, existsSync as existsSync38, statSync as statSync11, openSync as openSync5, readSync as readSync2, closeSync as closeSync5 } from "fs";
+import { watch as watchFile, existsSync as existsSync39, statSync as statSync11, openSync as openSync5, readSync as readSync2, closeSync as closeSync5 } from "fs";
 var E = "\x1B[";
 var dim = (s) => `${E}2m${s}${E}0m`;
 var bold = (s) => `${E}1m${s}${E}0m`;
@@ -18843,7 +19022,7 @@ function renderHeaders(states, now = Date.now()) {
   return states.map((s) => renderHeader(s, now)).join("");
 }
 function readFrom(file, from) {
-  if (!existsSync38(file)) return { events: [], offset: from };
+  if (!existsSync39(file)) return { events: [], offset: from };
   const size = statSync11(file).size;
   if (size < from) return readFrom(file, 0);
   if (size === from) return { events: [], offset: from };
@@ -19086,8 +19265,8 @@ function nextRoles(decision, ran) {
 }
 
 // src/ship-name.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync28, readFileSync as readFileSync35, renameSync as renameSync5, writeFileSync as writeFileSync31 } from "fs";
-import { dirname as dirname23 } from "path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync29, readFileSync as readFileSync36, renameSync as renameSync5, writeFileSync as writeFileSync32 } from "fs";
+import { dirname as dirname24 } from "path";
 import { parseDocument as parseDocument5 } from "yaml";
 var ShipNameError = class extends Error {
 };
@@ -19148,34 +19327,34 @@ async function syncRouteName(i) {
   return { status: "ok", ...base, action, name: i.local };
 }
 function readSyncedName(resolvedFile) {
-  if (!existsSync39(resolvedFile)) return void 0;
+  if (!existsSync40(resolvedFile)) return void 0;
   try {
-    const v = JSON.parse(readFileSync35(resolvedFile, "utf8")).shipName;
+    const v = JSON.parse(readFileSync36(resolvedFile, "utf8")).shipName;
     return typeof v === "string" ? v : void 0;
   } catch {
     return void 0;
   }
 }
 function writeSyncedName(resolvedFile, name) {
-  if (!existsSync39(resolvedFile)) return;
+  if (!existsSync40(resolvedFile)) return;
   let raw;
   try {
-    raw = JSON.parse(readFileSync35(resolvedFile, "utf8"));
+    raw = JSON.parse(readFileSync36(resolvedFile, "utf8"));
   } catch {
     return;
   }
   if (raw.shipName === name) return;
   raw.shipName = name;
-  mkdirSync28(dirname23(resolvedFile), { recursive: true });
+  mkdirSync29(dirname24(resolvedFile), { recursive: true });
   const tmp = `${resolvedFile}.tmp${process.pid}`;
-  writeFileSync31(tmp, `${JSON.stringify(raw, null, 2)}
+  writeFileSync32(tmp, `${JSON.stringify(raw, null, 2)}
 `);
   renameSync5(tmp, resolvedFile);
 }
 async function reconcileShipName(i) {
   let local = i.ship.name;
   try {
-    local = shipNameOfYaml(readFileSync35(i.configFile, "utf8")) ?? local;
+    local = shipNameOfYaml(readFileSync36(i.configFile, "utf8")) ?? local;
   } catch {
   }
   const resolvedFile = resolvedPathFor(i.stateDir, i.route);
@@ -19199,8 +19378,8 @@ async function reconcileShipName(i) {
   }
   if (result.status !== "ok") return result;
   if (result.action === "adopt" || result.action === "row-wins") {
-    const text2 = readFileSync35(i.configFile, "utf8");
-    writeFileSync31(i.configFile, setShipNameInYaml(text2, result.name));
+    const text2 = readFileSync36(i.configFile, "utf8");
+    writeFileSync32(i.configFile, setShipNameInYaml(text2, result.name));
     i.ship.name = result.name;
     if (result.action === "row-wins") {
       i.emit?.warn(
@@ -19859,8 +20038,8 @@ function describeCapability(i) {
 }
 
 // src/agents-sync-run.ts
-import { existsSync as existsSync40, mkdirSync as mkdirSync29, readFileSync as readFileSync36, writeFileSync as writeFileSync32 } from "fs";
-import { dirname as dirname24 } from "path";
+import { existsSync as existsSync41, mkdirSync as mkdirSync30, readFileSync as readFileSync37, writeFileSync as writeFileSync33 } from "fs";
+import { dirname as dirname25 } from "path";
 async function runAgentsSync(target, o) {
   const dryRun = o.dryRun ?? false;
   const force = o.force ?? false;
@@ -19893,12 +20072,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 = existsSync40(resolvedPath) ? JSON.parse(readFileSync36(resolvedPath, "utf8")) : {};
+    const raw = existsSync41(resolvedPath) ? JSON.parse(readFileSync37(resolvedPath, "utf8")) : {};
     raw.agentPersonas = personaResult.agentPersonas;
     if (skillResult) raw.agentSkills = skillResult.agentSkills;
     if (personaResult.releaseAgentId) raw.releaseAgentId = personaResult.releaseAgentId;
-    mkdirSync29(dirname24(resolvedPath), { recursive: true });
-    writeFileSync32(resolvedPath, `${JSON.stringify(raw, null, 2)}
+    mkdirSync30(dirname25(resolvedPath), { recursive: true });
+    writeFileSync33(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
     if (target.resolved) {
       target.resolved.agentPersonas = personaResult.agentPersonas;
@@ -20015,7 +20194,7 @@ async function showLogEntry(route2, entryId, opts = {}) {
 
 // src/repos-check.ts
 import { spawnSync as spawnSync10 } from "child_process";
-import { readFileSync as readFileSync37 } from "fs";
+import { readFileSync as readFileSync38 } from "fs";
 import { basename as basename11 } from "path";
 var POSIX_SHELL = /^(?:ba|z|da|k|a|mk)?sh$|^fish$/;
 function checkHookSyntax(script, shell) {
@@ -20056,7 +20235,7 @@ function checkRepoSpec(dir, opts = {}) {
   }
   let parsed;
   try {
-    parsed = parseRepoConfig(readFileSync37(file, "utf8"), file);
+    parsed = parseRepoConfig(readFileSync38(file, "utf8"), file);
   } catch (e) {
     if (!(e instanceof RepoConfigError)) throw e;
     return { ...empty, file, error: e.message, exitCode: 1 };
@@ -20513,7 +20692,7 @@ ${run3.err}` });
 }
 
 // src/sample-ticket.ts
-import { basename as basename12, dirname as dirname25, join as join42 } from "path";
+import { basename as basename12, dirname as dirname26, join as join43 } from "path";
 var SAMPLE_REPO = "crew-sample";
 var SAMPLE_REMOTE = `local/${SAMPLE_REPO}`;
 var SAMPLE_MARKER = "sample: true";
@@ -20536,8 +20715,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 join42(dirname25(existing[0]), SAMPLE_REPO);
-  return join42(reposBase, workspace, SAMPLE_REPO);
+  if (existing.length > 0) return join43(dirname26(existing[0]), SAMPLE_REPO);
+  return join43(reposBase, workspace, SAMPLE_REPO);
 }
 var SAMPLE_TITLE = "Sample: add a documented `greet` function with a test";
 function sampleDescription() {
@@ -20581,8 +20760,8 @@ function planSampleTicket(i) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync41, readFileSync as readFileSync38, readdirSync as readdirSync14 } from "fs";
-import { basename as basename13, dirname as dirname26, join as join43, resolve as resolve5 } from "path";
+import { existsSync as existsSync42, readFileSync as readFileSync39, readdirSync as readdirSync14 } from "fs";
+import { basename as basename13, dirname as dirname27, join as join44, resolve as resolve5 } from "path";
 function planWorktreeSweep(target, tickets, contract) {
   const terminal = new Set(contract.statuses.resolved.filter((s) => s !== contract.statuses.verified));
   const verified = contract.statuses.verified;
@@ -20646,7 +20825,7 @@ function worktreeTicketNumbers(target) {
   return [...nums];
 }
 function siblingWorktreeDirs(target) {
-  const parent = dirname26(target.dir.replace(/[/\\]+$/, ""));
+  const parent = dirname27(target.dir.replace(/[/\\]+$/, ""));
   const stem = `${basename13(target.dir.replace(/[/\\]+$/, ""))}-`;
   const registered = new Set(worktrees(target.dir).map((w) => resolve5(w.path)));
   let names;
@@ -20659,7 +20838,7 @@ function siblingWorktreeDirs(target) {
   for (const name of names) {
     if (!name.startsWith(stem)) continue;
     const m = DIR_NUMBER_SUFFIXED.exec(name);
-    const path = join43(parent, name);
+    const path = join44(parent, name);
     if (m && !registered.has(resolve5(path))) out.push({ path, number: m[1] });
   }
   return out;
@@ -20694,7 +20873,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 && existsSync41(a.path) && isHandBackMerge(a.path, base)) {
+    if (!dryRun && base && !a.keepBranch && existsSync42(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`,
@@ -20702,7 +20881,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         );
       }
     }
-    if (!dryRun && existsSync41(a.path)) {
+    if (!dryRun && existsSync42(a.path)) {
       let dirty = false;
       try {
         dirty = status(a.path).length > 0;
@@ -20713,7 +20892,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin",
         continue;
       }
     }
-    if (!dryRun && a.requirePushed && a.branch && existsSync41(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
+    if (!dryRun && a.requirePushed && a.branch && existsSync42(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
       refuse2(a, "unpushed commits", `${a.branch} has commits that are not on ${remote}`);
       continue;
     }
@@ -20762,7 +20941,7 @@ function isHandBackMerge(path, base) {
   if (!msgPath) return false;
   let first;
   try {
-    first = readFileSync38(resolve5(path, msgPath), "utf8").split("\n")[0] ?? "";
+    first = readFileSync39(resolve5(path, msgPath), "utf8").split("\n")[0] ?? "";
   } catch {
     return false;
   }
@@ -20867,14 +21046,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync42, readdirSync as readdirSync15, rmSync as rmSync19, statSync as statSync12 } from "fs";
-import { join as join44 } from "path";
+import { existsSync as existsSync43, readdirSync as readdirSync15, rmSync as rmSync20, statSync as statSync12 } from "fs";
+import { join as join45 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join44(stateDir, "streams");
-  if (!existsSync42(dir)) return [];
+  const dir = join45(stateDir, "streams");
+  if (!existsSync43(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync15(dir).map((name) => join44(dir, name)).filter((path) => {
+  return readdirSync15(dir).map((name) => join45(dir, name)).filter((path) => {
     try {
       return statSync12(path).mtimeMs < cutoff;
     } catch {
@@ -20890,7 +21069,7 @@ function applyStreamSweep(paths, dryRun, log) {
       continue;
     }
     try {
-      rmSync19(path, { force: true });
+      rmSync20(path, { force: true });
       removed++;
       log.emit(`removed stream artifact ${path}`, { step: "worktree" });
     } catch (e) {
@@ -20900,9 +21079,9 @@ function applyStreamSweep(paths, dryRun, log) {
   return removed;
 }
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
-  if (!existsSync42(stateDir)) return [];
+  if (!existsSync43(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync15(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join44(stateDir, name)).filter((path) => {
+  return readdirSync15(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join45(stateDir, name)).filter((path) => {
     try {
       return statSync12(path).mtimeMs < cutoff;
     } catch {
@@ -20912,12 +21091,12 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { realpathSync as realpathSync3, readFileSync as readFileSync44, existsSync as existsSync49, mkdirSync as mkdirSync37, writeFileSync as writeFileSync37, rmSync as rmSync24, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync6, statSync as statSync16, readdirSync as readdirSync20 } from "fs";
+import { realpathSync as realpathSync3, readFileSync as readFileSync45, existsSync as existsSync50, mkdirSync as mkdirSync38, writeFileSync as writeFileSync38, rmSync as rmSync25, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync6, statSync as statSync16, readdirSync as readdirSync20 } from "fs";
 import { createInterface } from "readline/promises";
 
 // src/periscope-cmd.ts
-import { existsSync as existsSync43, mkdirSync as mkdirSync30, readFileSync as readFileSync39, rmSync as rmSync20, writeFileSync as writeFileSync33 } from "fs";
-import { join as join45 } from "path";
+import { existsSync as existsSync44, mkdirSync as mkdirSync31, readFileSync as readFileSync40, rmSync as rmSync21, writeFileSync as writeFileSync34 } from "fs";
+import { join as join46 } from "path";
 var PeriscopeError = class extends Error {
 };
 var LivePeriscopeError = class extends PeriscopeError {
@@ -20927,22 +21106,22 @@ var LivePeriscopeError = class extends PeriscopeError {
     this.data = { refused: "live_periscope_exists", ...live };
   }
 };
-var priorDir = (stateDir) => join45(stateDir, "periscope-priors");
-var priorPath = (stateDir, ticketRecordId) => join45(priorDir(stateDir), `${ticketRecordId}.json`);
+var priorDir = (stateDir) => join46(stateDir, "periscope-priors");
+var priorPath = (stateDir, ticketRecordId) => join46(priorDir(stateDir), `${ticketRecordId}.json`);
 function removePeriscopePrior(stateDir, ticketRecordId) {
-  rmSync20(priorPath(stateDir, ticketRecordId), { force: true });
+  rmSync21(priorPath(stateDir, ticketRecordId), { force: true });
 }
 function writePeriscopePrior(stateDir, ticketRecordId, prior) {
   try {
-    mkdirSync30(priorDir(stateDir), { recursive: true });
-    writeFileSync33(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
+    mkdirSync31(priorDir(stateDir), { recursive: true });
+    writeFileSync34(priorPath(stateDir, ticketRecordId), JSON.stringify(prior));
   } catch {
   }
 }
 function readPeriscopePrior(stateDir, ticketRecordId) {
   try {
     const p = priorPath(stateDir, ticketRecordId);
-    return existsSync43(p) ? JSON.parse(readFileSync39(p, "utf8")) : void 0;
+    return existsSync44(p) ? JSON.parse(readFileSync40(p, "utf8")) : void 0;
   } catch {
     return void 0;
   }
@@ -21396,7 +21575,7 @@ ${tail2(preview.output)}`);
 // src/periscope-idle.ts
 import { execFileSync as execFileSync12 } from "child_process";
 import { statSync as statSync13 } from "fs";
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 var MAX_SCANNED_FILES = 2e4;
 function newestWorktreeMtime(root) {
   const a = newestTrackedMtime(root);
@@ -21421,7 +21600,7 @@ function newestTrackedMtime(root) {
     if (!rel) continue;
     if (++scanned > MAX_SCANNED_FILES) break;
     try {
-      const m = statSync13(join46(root, rel)).mtimeMs;
+      const m = statSync13(join47(root, rel)).mtimeMs;
       if (newest === null || m > newest) newest = m;
     } catch {
     }
@@ -21497,18 +21676,18 @@ import { dirname as dirOf2, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync13 } from "child_process";
-import { existsSync as existsSync44, mkdirSync as mkdirSync31, readFileSync as readFileSync40, chmodSync as chmodSync3 } from "fs";
-import { dirname as dirname27, join as join47 } from "path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync32, readFileSync as readFileSync41, chmodSync as chmodSync3 } from "fs";
+import { dirname as dirname28, join as join48 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join47(stateDir, "ssh", "id_ed25519");
+  return join48(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync44(privateKeyPath)) {
-    mkdirSync31(dirname27(privateKeyPath), { recursive: true });
+  if (!existsSync45(privateKeyPath)) {
+    mkdirSync32(dirname28(privateKeyPath), { recursive: true });
     try {
       execFileSync13("ssh-keygen", [
         "-t",
@@ -21528,10 +21707,10 @@ function ensureShipSshKeypair(stateDir) {
     }
     chmodSync3(privateKeyPath, 384);
   }
-  if (!existsSync44(publicKeyPath)) {
+  if (!existsSync45(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync40(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync41(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -21695,12 +21874,12 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn9 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync45, mkdirSync as mkdirSync33, readFileSync as readFileSync41, writeFileSync as writeFileSync34, unlinkSync as unlinkSync4, readdirSync as readdirSync16 } from "fs";
-import { join as join48 } from "path";
+import { existsSync as existsSync46, mkdirSync as mkdirSync34, readFileSync as readFileSync42, writeFileSync as writeFileSync35, unlinkSync as unlinkSync4, readdirSync as readdirSync16 } from "fs";
+import { join as join49 } from "path";
 
 // src/passenger-mirror.ts
-import { mkdirSync as mkdirSync32 } from "fs";
-import { dirname as dirname28 } from "path";
+import { mkdirSync as mkdirSync33 } from "fs";
+import { dirname as dirname29 } from "path";
 function mirrorRepoOf(spec) {
   const fromOrigin = spec.originUrl ? parseRemote(spec.originUrl) : null;
   if (fromOrigin) return fromOrigin;
@@ -21718,9 +21897,9 @@ async function materializeMirrorCheckouts(specs, cacheFor = (s) => new SandboxCa
       continue;
     }
     try {
-      const parent = dirname28(spec.dir);
-      mkdirSync32(parent, { recursive: true });
-      mkdirSync32(spec.dir, { recursive: true });
+      const parent = dirname29(spec.dir);
+      mkdirSync33(parent, { recursive: true });
+      mkdirSync33(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) {
@@ -21826,21 +22005,21 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join48(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join49(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
-  if (!existsSync45(path)) return void 0;
+  if (!existsSync46(path)) return void 0;
   try {
-    return JSON.parse(readFileSync41(path, "utf8"));
+    return JSON.parse(readFileSync42(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync33(join48(stateDir, "passengers"), { recursive: true });
-  writeFileSync34(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync34(join49(stateDir, "passengers"), { recursive: true });
+  writeFileSync35(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function removePersistedSyncDaemon(stateDir, workspaceId) {
@@ -21860,8 +22039,8 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join48(stateDir, "passengers");
-  if (!existsSync45(dir)) return [];
+  const dir = join49(stateDir, "passengers");
+  if (!existsSync46(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync16(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
@@ -21919,12 +22098,12 @@ function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
 
 // src/periscope-proxy.ts
 import { spawn as spawn10 } from "child_process";
-import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync34 } from "fs";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync35 } from "fs";
 import { createServer, request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { connect as netConnect } from "net";
 import { connect as tlsConnect } from "tls";
-import { dirname as dirname29, isAbsolute as isAbsolute4 } from "path";
+import { dirname as dirname30, isAbsolute as isAbsolute4 } from "path";
 import { brotliDecompressSync, gunzipSync, inflateSync } from "zlib";
 
 // src/periscope-inspector.ts
@@ -22038,7 +22217,7 @@ function parsePointedBody(raw) {
   return entry;
 }
 function appendPointed(file, entry, now = /* @__PURE__ */ new Date()) {
-  mkdirSync34(dirname29(file), { recursive: true });
+  mkdirSync35(dirname30(file), { recursive: true });
   appendFileSync3(file, `${JSON.stringify({ ...entry, at: now.toISOString() })}
 `);
 }
@@ -22299,6 +22478,33 @@ async function launchProxy(invocation, worktree, previewUrl, number, o) {
   throw new Error(`the proxy did not start listening on ${o.host}:${port}`);
 }
 
+// src/intel-worktree.ts
+async function startWorktreeIntel(d) {
+  const file = attachFilePath(d.stateDir, d.route, d.number);
+  const probe = d.probe ?? probeIntel;
+  let outcome;
+  try {
+    const known = readAttachFile(file);
+    outcome = known ? await probe({ runHook: async () => ({ code: 0, output: known }) }, {}, 3) : { state: "absent" };
+    if (outcome.state !== "ready") {
+      const prepared = await d.prepare(d.worktree);
+      if (prepared && prepared.code !== 0) {
+        outcome = { state: "failed", reason: `setup exited ${prepared.code}` };
+      } else {
+        const env = { CREW_TICKET: d.ticketTag, CREW_BRANCH: d.branch };
+        const ports = await d.runHook("ports", d.worktree, env);
+        if (ports) Object.assign(env, parseEnvLines(ports.output));
+        outcome = await probe({ runHook: (e) => d.runHook("intel", d.worktree, e) }, env, d.startupSeconds);
+      }
+    }
+    if (outcome.state === "ready") writeAttachFile(file, outcome.url);
+  } catch (e) {
+    outcome = { state: "failed", reason: e.message.slice(0, 200) };
+  }
+  const tail3 = outcome.state === "ready" ? " The session's `code` server attaches to it within a second; until it lists these tools it still shows only `code_status`." : "";
+  return `${codeToolsParagraph(outcome)}${tail3}`;
+}
+
 // src/outage.ts
 var TRANSIENT_BACKOFF_MS = [15e3, 3e4, 6e4];
 var OUTAGE_ESCALATE_AFTER = 5;
@@ -22331,8 +22537,8 @@ function describeCause(err3) {
 }
 
 // src/daemon.ts
-import { existsSync as existsSync46, mkdirSync as mkdirSync35, readFileSync as readFileSync42, readdirSync as readdirSync17, rmSync as rmSync21, statSync as statSync14, writeFileSync as writeFileSync35 } from "fs";
-import { join as join49 } from "path";
+import { existsSync as existsSync47, mkdirSync as mkdirSync36, readFileSync as readFileSync43, readdirSync as readdirSync17, rmSync as rmSync22, statSync as statSync14, writeFileSync as writeFileSync36 } from "fs";
+import { join as join50 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
@@ -22420,7 +22626,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(join49(path, entry.name)));
+    latest = Math.max(latest, latestMtime(join50(path, entry.name)));
   }
   return latest;
 }
@@ -22429,10 +22635,10 @@ function computeTreeSignature(paths) {
 }
 function makeStaleChecker(paths, opts = {}) {
   const initial = computeTreeSignature(paths);
-  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync46(opts.reloadSentinel);
+  return () => computeTreeSignature(paths) !== initial || opts.reloadSentinel !== void 0 && existsSync47(opts.reloadSentinel);
 }
 function reloadSentinelFor(stateDir) {
-  return join49(stateDir, "reload-requested");
+  return join50(stateDir, "reload-requested");
 }
 function readReloadRequestedAt(stateDir) {
   try {
@@ -22442,17 +22648,17 @@ function readReloadRequestedAt(stateDir) {
   }
 }
 function daemonStampFor(stateDir) {
-  return join49(stateDir, "daemon.started");
+  return join50(stateDir, "daemon.started");
 }
 function noteDaemonStarted(stateDir, now = Date.now()) {
-  mkdirSync35(stateDir, { recursive: true });
-  rmSync21(reloadSentinelFor(stateDir), { force: true });
-  writeFileSync35(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
+  mkdirSync36(stateDir, { recursive: true });
+  rmSync22(reloadSentinelFor(stateDir), { force: true });
+  writeFileSync36(daemonStampFor(stateDir), `${JSON.stringify({ pid: process.pid, startedAt: now })}
 `);
 }
 function readDaemonStarted(stateDir) {
   try {
-    const v = JSON.parse(readFileSync42(daemonStampFor(stateDir), "utf8")).startedAt;
+    const v = JSON.parse(readFileSync43(daemonStampFor(stateDir), "utf8")).startedAt;
     return typeof v === "number" ? v : null;
   } catch {
     return null;
@@ -23018,18 +23224,18 @@ import { createHash as createHash10 } from "crypto";
 import {
   chmodSync as chmodSync4,
   closeSync as closeSync6,
-  existsSync as existsSync47,
+  existsSync as existsSync48,
   fstatSync,
   openSync as openSync6,
   readSync as readSync3,
   readdirSync as readdirSync18,
-  rmSync as rmSync22,
+  rmSync as rmSync23,
   statSync as statSync15,
   watch
 } from "fs";
 import { createConnection } from "net";
 import { createServer as createServer2 } from "http";
-import { basename as basename14, dirname as dirname30, join as join50 } from "path";
+import { basename as basename14, dirname as dirname31, join as join51 } from "path";
 import { execFile as execFile3, spawn as spawn12 } from "child_process";
 
 // src/periscope-control.ts
@@ -23258,7 +23464,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) => join50(stateDir, CONTROL_SOCKET_NAME);
+var controlSocketFor = (stateDir) => join51(stateDir, CONTROL_SOCKET_NAME);
 var MAX_SOCKET_PATH = 100;
 var MAX_TAIL_BYTES = 1024 * 1024;
 var MAX_WAIT_SECONDS = 30;
@@ -23345,7 +23551,7 @@ function candidates(live, rotated) {
   const out = [live];
   if (!rotated) return out;
   try {
-    for (const n of readdirSync18(dirname30(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join50(dirname30(live), n));
+    for (const n of readdirSync18(dirname31(live))) if (ROTATED_EVENTS_RE.test(n)) out.push(join51(dirname31(live), n));
   } catch {
   }
   return out;
@@ -23389,7 +23595,7 @@ function lastLines2(path, n) {
 }
 function readTail(live, opts) {
   const max = opts.maxBytes ?? MAX_TAIL_BYTES;
-  if (!existsSync47(live)) {
+  if (!existsSync48(live)) {
     return { lines: [], cursor: opts.after ?? encodeCursor({ dev: 0, ino: 0, off: 0 }), reset: false };
   }
   const cur = opts.after ? decodeCursor(opts.after) : null;
@@ -23505,7 +23711,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(dirname30(path), deadline - Date.now(), abort);
+    await waitForChange(dirname31(path), deadline - Date.now(), abort);
     r = readTail(path, { after: r.cursor, rotated });
   }
   return reply2(200, r);
@@ -23545,8 +23751,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 = join50(deps.stateDir, "streams", run3.endsWith(".jsonl") ? run3 : `${run3}.jsonl`);
-    if (!existsSync47(file)) return err2(404, "no such run");
+    const file = join51(deps.stateDir, "streams", run3.endsWith(".jsonl") ? run3 : `${run3}.jsonl`);
+    if (!existsSync48(file)) return err2(404, "no such run");
     return tailReply(file, url.searchParams, false, abort);
   }
   if ((p === "/pause" || p === "/resume") && post3) {
@@ -23590,7 +23796,7 @@ function send(res, r) {
   res.end(body);
 }
 async function socketIsStale(path) {
-  if (!existsSync47(path)) return false;
+  if (!existsSync48(path)) return false;
   return new Promise((resolve8) => {
     const c = createConnection(path);
     c.once("connect", () => {
@@ -23608,8 +23814,8 @@ async function startControlServer(deps) {
     log(`control API not started: socket path is too long for a unix socket (${path})`);
     return null;
   }
-  if (await socketIsStale(path)) rmSync22(path, { force: true });
-  else if (existsSync47(path)) {
+  if (await socketIsStale(path)) rmSync23(path, { force: true });
+  else if (existsSync48(path)) {
     log(`control API not started: ${path} is in use by another process`);
     return null;
   }
@@ -23655,7 +23861,7 @@ async function startControlServer(deps) {
         path,
         close: () => new Promise((done) => {
           server.close(() => {
-            rmSync22(path, { force: true });
+            rmSync23(path, { force: true });
             done();
           });
         })
@@ -23695,57 +23901,57 @@ 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 dirname31, isAbsolute as isAbsolute5, join as join52, relative as relative2, resolve as resolve6, sep } from "path";
+import { basename as basename15, dirname as dirname32, isAbsolute as isAbsolute5, join as join53, 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 existsSync48, mkdirSync as mkdirSync36, readdirSync as readdirSync19, readFileSync as readFileSync43, rmSync as rmSync23, writeFileSync as writeFileSync36 } from "fs";
-import { join as join51 } from "path";
-var secretDir = (stateDir) => join51(stateDir, "periscope-mcp");
-var secretFile = (stateDir, id) => join51(secretDir(stateDir), `${id}.json`);
-var endpointDir = (stateDir) => join51(stateDir, "periscope-endpoints");
-var endpointFile = (stateDir, id) => join51(endpointDir(stateDir), `${id}.json`);
+import { chmodSync as chmodSync5, existsSync as existsSync49, mkdirSync as mkdirSync37, readdirSync as readdirSync19, readFileSync as readFileSync44, rmSync as rmSync24, writeFileSync as writeFileSync37 } from "fs";
+import { join as join52 } from "path";
+var secretDir = (stateDir) => join52(stateDir, "periscope-mcp");
+var secretFile = (stateDir, id) => join52(secretDir(stateDir), `${id}.json`);
+var endpointDir = (stateDir) => join52(stateDir, "periscope-endpoints");
+var endpointFile = (stateDir, id) => join52(endpointDir(stateDir), `${id}.json`);
 function mintPeriscopeSecret(stateDir, ticketRecordId) {
-  mkdirSync36(secretDir(stateDir), { recursive: true, mode: 448 });
+  mkdirSync37(secretDir(stateDir), { recursive: true, mode: 448 });
   const secret = randomBytes3(32).toString("base64url");
   const file = secretFile(stateDir, ticketRecordId);
-  writeFileSync36(file, `${JSON.stringify({ secret })}
+  writeFileSync37(file, `${JSON.stringify({ secret })}
 `, { mode: 384 });
   chmodSync5(file, 384);
   return secret;
 }
 function readPeriscopeSecret(stateDir, ticketRecordId) {
   try {
-    const v = JSON.parse(readFileSync43(secretFile(stateDir, ticketRecordId), "utf8"));
+    const v = JSON.parse(readFileSync44(secretFile(stateDir, ticketRecordId), "utf8"));
     return typeof v.secret === "string" && v.secret ? v.secret : void 0;
   } catch {
     return void 0;
   }
 }
 function removePeriscopeSecret(stateDir, ticketRecordId) {
-  rmSync23(secretFile(stateDir, ticketRecordId), { force: true });
+  rmSync24(secretFile(stateDir, ticketRecordId), { force: true });
 }
 function readPeriscopeEndpoint(stateDir, ticketRecordId) {
   try {
-    return JSON.parse(readFileSync43(endpointFile(stateDir, ticketRecordId), "utf8"));
+    return JSON.parse(readFileSync44(endpointFile(stateDir, ticketRecordId), "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePeriscopeEndpoint(stateDir, rec) {
-  mkdirSync36(endpointDir(stateDir), { recursive: true });
-  writeFileSync36(endpointFile(stateDir, rec.ticketRecordId), `${JSON.stringify(rec, null, 2)}
+  mkdirSync37(endpointDir(stateDir), { recursive: true });
+  writeFileSync37(endpointFile(stateDir, rec.ticketRecordId), `${JSON.stringify(rec, null, 2)}
 `);
 }
 function removePeriscopeEndpointRecord(stateDir, ticketRecordId) {
-  rmSync23(endpointFile(stateDir, ticketRecordId), { force: true });
+  rmSync24(endpointFile(stateDir, ticketRecordId), { force: true });
 }
 function listPeriscopeEndpoints(stateDir) {
   const dir = endpointDir(stateDir);
-  if (!existsSync48(dir)) return [];
+  if (!existsSync49(dir)) return [];
   const out = [];
   for (const name of readdirSync19(dir)) {
     if (!name.endsWith(".json")) continue;
@@ -23833,10 +24039,10 @@ async function realAncestor(p) {
     }
     if (isLink) {
       if (++hops > 40) throw new PathRefusal(`too many symbolic links resolving ${p}`);
-      cur = resolve6(dirname31(cur), await readlink(cur));
+      cur = resolve6(dirname32(cur), await readlink(cur));
       continue;
     }
-    const parent = dirname31(cur);
+    const parent = dirname32(cur);
     if (parent === cur) throw new PathRefusal(`cannot resolve ${p}`);
     tail3.push(basename15(cur));
     cur = parent;
@@ -23848,13 +24054,13 @@ async function resolveInWorktree(root, requested) {
   let abs;
   if (isAbsolute5(requested)) {
     abs = resolve6(requested);
-    if (isInside(root, abs)) abs = join52(realRoot, relative2(root, abs));
+    if (isInside(root, abs)) abs = join53(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 ? join52(real, rest) : real;
+  const final = rest ? join53(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;
@@ -23922,7 +24128,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(join52(abs, e.name))).size;
+      const size = (await lstat(join53(abs, e.name))).size;
       return `[FILE] ${e.name} (${size} bytes)`;
     }));
     return text(lines2.join("\n") || "(empty)");
@@ -23947,7 +24153,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(dirname31(abs), { recursive: true });
+    await mkdir(dirname32(abs), { recursive: true });
     await inTree(path);
     await writeFile(abs, content);
     return text(`Wrote ${Buffer.byteLength(content)} bytes to ${await rel(abs)}`);
@@ -23987,8 +24193,8 @@ function createPeriscopeMcpServer(d, sc) {
     inputSchema: { path: z.string() },
     annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
   }, async ({ path }) => {
-    const parent = await inTree(dirname31(path) === "" ? "." : dirname31(path));
-    const abs = join52(parent, basename15(path));
+    const parent = await inTree(dirname32(path) === "" ? "." : dirname32(path));
+    const abs = join53(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);
@@ -24109,7 +24315,7 @@ function findPeriscope(sidecars, segment) {
 }
 
 // src/cli.ts
-var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname32(process.execPath) : resolve7(dirname32(fileURLToPath(import.meta.url)), "..");
+var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname33(process.execPath) : resolve7(dirname33(fileURLToPath(import.meta.url)), "..");
 var RELEASE_LOCK_TTL_MS = 20 * 60 * 1e3;
 var CYCLE_SECONDS2 = 120;
 var STALE_CYCLES = 3;
@@ -24367,6 +24573,7 @@ if (!command) usage(argv.length ? `unknown option "${argv[0]}"` : void 0);
 var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "passenger-sync-daemon",
   "periscope-proxy",
+  "intel",
   "agents",
   "connect",
   "credential",
@@ -24478,7 +24685,7 @@ if (command === "provision") {
   process.exit(outcome.code);
 }
 if (command === "pool-member") {
-  const pool = poolConfigFrom(argv, process.env, () => readFileSync44(0, "utf8"));
+  const pool = poolConfigFrom(argv, process.env, () => readFileSync45(0, "utf8"));
   if (typeof pool === "string") {
     process.stderr.write(`crew pool-member: ${pool}
 `);
@@ -24512,6 +24719,14 @@ if (command === "passenger-sync-daemon") {
     process.exit(2);
   }
   runProxyFromEnv(dropFile);
+} else if (command === "intel") {
+  const [, sub, bridgeRoute, bridgeTicket] = positional;
+  const stateDir = value("state-dir");
+  if (sub !== "bridge" || !bridgeRoute || !bridgeTicket || !stateDir) {
+    process.stderr.write("usage: crew intel bridge <route> <ticket number> --state-dir DIR (registered by a lane run, not run by hand)\n");
+    process.exit(2);
+  }
+  await runBridge(stateDir, bridgeRoute, bridgeTicket);
 } else {
   let requireArmed = function(what) {
     if (dryRun || route2.enabled) return;
@@ -24713,7 +24928,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 && !existsSync49(findConfigFile(CREW_HOME))) {
+      if (configless && !existsSync50(findConfigFile(CREW_HOME))) {
         cfg = loadConfig(CREW_HOME, firstRunConfigPath(), { text: "ship: {}\n", allowNoRoutes: true });
       } else {
         cfg = loadConfig(CREW_HOME, void 0, toleratesNoRoutes ? { allowNoRoutes: true } : {});
@@ -24728,7 +24943,7 @@ if (command === "passenger-sync-daemon") {
     throw e;
   }
   if (command === "credential") {
-    const r = runCredential(positional[1], readFileSync44(0, "utf8"), cfg.ship.forges, cfg.ship.stateDir);
+    const r = runCredential(positional[1], readFileSync45(0, "utf8"), cfg.ship.forges, cfg.ship.stateDir);
     process.stdout.write(r.out);
     process.stderr.write(r.err);
     process.exit(r.code);
@@ -24740,9 +24955,9 @@ if (command === "passenger-sync-daemon") {
         forges: cfg.ship.forges,
         stateDir: cfg.ship.stateDir,
         configFile: cfg.configFile,
-        readFile: (p) => readFileSync44(p, "utf8"),
-        writeFile: (p, t) => writeFileSync37(p, t),
-        stdin: () => readFileSync44(0, "utf8"),
+        readFile: (p) => readFileSync45(p, "utf8"),
+        writeFile: (p, t) => writeFileSync38(p, t),
+        stdin: () => readFileSync45(0, "utf8"),
         env: process.env
       }
     );
@@ -25035,8 +25250,8 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join53(homedir11(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync49(staleTimer)) {
+      const staleTimer = join54(homedir11(), ".config", "systemd", "user", `${label}.timer`);
+      if (existsSync50(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -25063,7 +25278,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 (!existsSync49(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync50(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}`));
     }
@@ -25090,7 +25305,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) => existsSync49(p);
+    const unitExists = (p) => existsSync50(p);
     const crontab = o.host === "linux" ? spawnSync11("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 });
@@ -25107,7 +25322,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;
-          writeFileSync37(cfg.configFile, planEnable(readFileSync44(cfg.configFile, "utf8"), a.route));
+          writeFileSync38(cfg.configFile, planEnable(readFileSync45(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -26246,7 +26461,7 @@ ${cu.tail.trimEnd()}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join53(CREW_HOME, "src"), join53(CREW_HOME, "dist"), join53(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join54(CREW_HOME, "src"), join54(CREW_HOME, "dist"), join54(CREW_HOME, "bin")];
       const configPaths = daemonConfigPaths(cfg);
       watchPaths.push(...configPaths);
       noteDaemonStarted(cfg.ship.stateDir);
@@ -26551,10 +26766,10 @@ ${cu.tail.trimEnd()}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync49(resolvedPath) ? JSON.parse(readFileSync44(resolvedPath, "utf8")) : {};
+        const raw = existsSync50(resolvedPath) ? JSON.parse(readFileSync45(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
-        mkdirSync37(dirOf2(resolvedPath), { recursive: true });
-        writeFileSync37(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        mkdirSync38(dirOf2(resolvedPath), { recursive: true });
+        writeFileSync38(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (result.outcomes.some((o) => o.action === "diverged")) process.exitCode = 1;
@@ -26577,7 +26792,7 @@ ${cu.tail.trimEnd()}
         throw e;
       }
       const oldName = cfg.ship.name;
-      writeFileSync37(cfg.configFile, setShipNameInYaml(readFileSync44(cfg.configFile, "utf8"), newName));
+      writeFileSync38(cfg.configFile, setShipNameInYaml(readFileSync45(cfg.configFile, "utf8"), newName));
       cfg.ship.name = newName;
       let renameMachineId;
       try {
@@ -26624,14 +26839,14 @@ ${cu.tail.trimEnd()}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list" && sub !== "clone" && sub !== "hooks" && sub !== "check") usage2();
-      const configText = readFileSync44(cfg.configFile, "utf8");
+      const configText = readFileSync45(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, dirname32(cfg.configFile), found.route, named2) : resolvePath(positional[value("route") ? 2 : 3] ?? ".");
+          const dir = named2 ? repoDirOf(configText, dirname33(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, {
@@ -26654,9 +26869,9 @@ ${cu.tail.trimEnd()}
       if (sub === "hooks") {
         try {
           const a = parseHooksArgs(positional.slice(2), routeNamesOf(configText));
-          const dir = repoDirOf(configText, dirname32(cfg.configFile), a.route, a.name);
-          if (!existsSync49(dir)) throw new ReposError(`${dir} does not exist on disk`);
-          const files = { exists: (r) => existsSync49(resolvePath(dir, r)), list: (r) => {
+          const dir = repoDirOf(configText, dirname33(cfg.configFile), a.route, a.name);
+          if (!existsSync50(dir)) throw new ReposError(`${dir} does not exist on disk`);
+          const files = { exists: (r) => existsSync50(resolvePath(dir, r)), list: (r) => {
             try {
               return readdirSync20(resolvePath(dir, r));
             } catch {
@@ -26664,7 +26879,7 @@ ${cu.tail.trimEnd()}
             }
           }, read: (r) => {
             try {
-              return readFileSync44(resolvePath(dir, r), "utf8");
+              return readFileSync45(resolvePath(dir, r), "utf8");
             } catch {
               return void 0;
             }
@@ -26706,19 +26921,19 @@ ${cu.tail.trimEnd()}
           let cleared;
           if (clear2) {
             const plan = clearRouteHooks(configText, a.route, a.name);
-            if (plan.removed.length > 0) writeFileSync37(cfg.configFile, plan.text);
+            if (plan.removed.length > 0) writeFileSync38(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") });
-            writeFileSync37(cfg.configFile, plan.text);
+            writeFileSync38(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");
-            writeFileSync37(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
+            writeFileSync38(file, starterRepoConfig(picked.hooks, picked.release), { flag: "wx" });
             written = { target: "repo", file, hooks: Object.keys(picked.hooks), kept: [], replaced: [] };
           }
           if (flag("json")) {
@@ -26774,7 +26989,7 @@ ${cu.tail.trimEnd()}
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync49(resolvePath(p.replace(/^~(?=\/|$)/, homedir11()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync50(resolvePath(p.replace(/^~(?=\/|$)/, homedir11()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -26804,7 +27019,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 && existsSync49(resolvedFile) && !dryRun) {
+        if (liveRoute?.resolved?.reposModelId && existsSync50(resolvedFile) && !dryRun) {
           try {
             await hydrateApiKeys([liveRoute]);
             persistRepoRows(cfg.ship.stateDir, liveRoute.route, await new Tracker(liveRoute, cfg.ship).repoRowsForMap());
@@ -26813,16 +27028,16 @@ ${cu.tail.trimEnd()}
         }
       }
       let resolvedRemotes;
-      if (existsSync49(resolvedFile)) {
+      if (existsSync50(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync44(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync45(resolvedFile, "utf8"));
         } catch {
         }
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text2 = configText;
-      const base = dirname32(cfg.configFile);
-      const isCheckout = (d) => existsSync49(`${d}/.git`);
+      const base = dirname33(cfg.configFile);
+      const isCheckout = (d) => existsSync50(`${d}/.git`);
       try {
         if (sub === "list") {
           if (flag("json")) {
@@ -26832,11 +27047,11 @@ ${cu.tail.trimEnd()}
               base,
               resolved: resolvedRemotes,
               originOf,
-              exists: (d) => existsSync49(d),
+              exists: (d) => existsSync50(d),
               isCheckout,
               repoHasHooks: (d) => REPO_CONFIG_FILENAMES.some((f) => {
                 try {
-                  return Object.keys(parseRepoConfig(readFileSync44(resolvePath(d, f), "utf8"), f).hooks).length > 0;
+                  return Object.keys(parseRepoConfig(readFileSync45(resolvePath(d, f), "utf8"), f).hooks).length > 0;
                 } catch {
                   return false;
                 }
@@ -26853,7 +27068,7 @@ ${cu.tail.trimEnd()}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync49(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync50(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}
 `);
           }
@@ -26865,9 +27080,9 @@ ${cu.tail.trimEnd()}
 ` : `${human}
 `);
           const plan2 = planRepoClone({ text: text2, base, route: routeName, name: addName, resolved: resolvedRemotes, dir: value("dir"), isCheckout });
-          if (existsSync49(plan2.target) && (existsSync49(`${plan2.target}/.git`) || readdirSync20(plan2.target).length > 0)) {
+          if (existsSync50(plan2.target) && (existsSync50(`${plan2.target}/.git`) || readdirSync20(plan2.target).length > 0)) {
             throw new ReposError(
-              existsSync49(`${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`
+              existsSync50(`${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) {
@@ -26885,14 +27100,14 @@ ${cu.tail.trimEnd()}
             throw new ReposError(`${e.message}${authHint}
   crew.yaml was not changed`);
           }
-          writeFileSync37(cfg.configFile, plan2.text);
+          writeFileSync38(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 = existsSync49(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const top = existsSync50(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({
@@ -26944,15 +27159,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 (existsSync49(resolvedFile)) {
-            const raw = JSON.parse(readFileSync44(resolvedFile, "utf8"));
+          if (existsSync50(resolvedFile)) {
+            const raw = JSON.parse(readFileSync45(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
-            writeFileSync37(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync38(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        writeFileSync37(cfg.configFile, plan.text);
+        writeFileSync38(cfg.configFile, plan.text);
         process.stdout.write(`added ${top} to ${routeName} as ${plan.mode === "dir" ? "dir" : `repos.${plan.name}`} in ${cfg.configFile}
 `);
       } catch (e) {
@@ -27323,7 +27538,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           process.exit(2);
         }
         if (found.shipNameAdopted && !dryRun) {
-          writeFileSync37(cfg.configFile, setShipNameInYaml(readFileSync44(cfg.configFile, "utf8"), found.shipNameAdopted));
+          writeFileSync38(cfg.configFile, setShipNameInYaml(readFileSync45(cfg.configFile, "utf8"), found.shipNameAdopted));
           cfg.ship.name = found.shipNameAdopted;
         }
         if (found.shipRow) {
@@ -27366,10 +27581,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           }
         }
         let previous;
-        const hadPreviousFile = existsSync49(resolvedPath);
+        const hadPreviousFile = existsSync50(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync44(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync45(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -27499,10 +27714,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 {
-          mkdirSync37(dirname32(resolvedPath), { recursive: true });
+          mkdirSync38(dirname33(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
-          writeFileSync37(tmpPath, `${JSON.stringify(resolved, null, 2)}
+          writeFileSync38(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
           renameSync6(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
@@ -27548,8 +27763,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 {
-            mkdirSync37(dirname32(apiKeyFile), { recursive: true });
-            writeFileSync37(apiKeyFile, `${apiKeyVar}=${apiKey}
+            mkdirSync38(dirname33(apiKeyFile), { recursive: true });
+            writeFileSync38(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
 `);
@@ -28231,6 +28446,33 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       }
       const pathWt = applyRunWorktree(repoWt.dir, repoWt.config, planWt);
       emit.emit(describeRunWorktreePlan(planWt));
+      if (pathWt && planIsUsable(planWt) && repoWt.config.hooks.intel) {
+        const shellWt = resolveShell(repoWt.config.shell ?? cfg.ship.shell);
+        const paragraph = await startWorktreeIntel({
+          worktree: pathWt,
+          route: routeWt.route,
+          number: String(nWt),
+          stateDir: cfg.ship.stateDir,
+          ticketTag: String(ticketWt.issue_tag ?? ticketWt.issue_id ?? `ISSUE-${nWt}`),
+          branch: planWt.branch ?? "",
+          startupSeconds: cfg.ship.intelStartupSeconds,
+          prepare: async (path) => {
+            for (const f of repoWt.config.worktrees.copy) {
+              const src = join54(repoWt.dir, f);
+              if (!existsSync50(src) || existsSync50(join54(path, f))) continue;
+              mkdirSync38(dirOf2(join54(path, f)), { recursive: true });
+              copyFileSync2(src, join54(path, f));
+            }
+            const setup = repoWt.config.hooks.setup;
+            return setup ? runScript(setup, { cwd: path, shell: shellWt }) : null;
+          },
+          runHook: async (name, cwd, env) => {
+            const script = repoWt.config.hooks[name];
+            return script ? runScript(script, { cwd, env, shell: shellWt, timeoutMs: name === "intel" ? 6e4 : void 0 }) : null;
+          }
+        });
+        emit.emit(paragraph);
+      }
       if (pathWt) process.stdout.write(`${pathWt}
 `);
       if (!planIsUsable(planWt)) process.exitCode = 1;
@@ -28430,7 +28672,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) => existsSync49(p),
+            worktreeExists: (p) => existsSync50(p),
             prepareDropFile,
             startProxy: (wt, url, n) => launchProxy(crewInvocation(CREW_HOME), wt, url, Number(n), { host: hit.row.host || "localhost", inject: hit.repo.config.periscope?.inspector !== "repo" }),
             caps: periscopeCaps(cfg.ship),
@@ -28526,10 +28768,10 @@ ${where.join("\n")}`);
           },
           prepare: async (path) => {
             for (const f of repoP.config.worktrees.copy) {
-              const src = join53(repoP.dir, f);
-              if (!existsSync49(src)) continue;
-              mkdirSync37(dirOf2(join53(path, f)), { recursive: true });
-              copyFileSync2(src, join53(path, f));
+              const src = join54(repoP.dir, f);
+              if (!existsSync50(src)) continue;
+              mkdirSync38(dirOf2(join54(path, f)), { recursive: true });
+              copyFileSync2(src, join54(path, f));
             }
             const setup = repoP.config.hooks.setup;
             return setup ? runScript(setup, { cwd: path, shell: shellP, onLine: (l) => {
@@ -28839,7 +29081,7 @@ ${where.join("\n")}`);
       };
       const droppedRoutes = [];
       try {
-        const rawCfg = parseYaml2(readFileSync44(cfg.configFile, "utf8"));
+        const rawCfg = parseYaml2(readFileSync45(cfg.configFile, "utf8"));
         for (const r of rawCfg?.routes ?? []) {
           if (typeof r?.route !== "string" || cfg.routes.some((x) => x.route === r.route)) continue;
           try {
@@ -28892,8 +29134,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;
       }
-      mkdirSync37(cfg.ship.stateDir, { recursive: true });
-      writeFileSync37(sentinel, `${(/* @__PURE__ */ new Date()).toISOString()}
+      mkdirSync38(cfg.ship.stateDir, { recursive: true });
+      writeFileSync38(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"
@@ -28958,7 +29200,7 @@ ${where.join("\n")}`);
     }
     case "log": {
       try {
-        const text2 = readFileSync44(cfg.ship.logFile, "utf8").split("\n");
+        const text2 = readFileSync45(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text2.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -28981,8 +29223,8 @@ ${where.join("\n")}`);
       };
       if (!route2.resolved) fail2(`route ${route2.route} is not connected \u2014 run \`crew connect\` first`);
       const tracker = new Tracker(route2, cfg.ship);
-      const configText = readFileSync44(cfg.configFile, "utf8");
-      const cfgBase = dirname32(cfg.configFile);
+      const configText = readFileSync45(cfg.configFile, "utf8");
+      const cfgBase = dirname33(cfg.configFile);
       const configured2 = configuredRepos(configText, route2.route, cfgBase);
       const dir = configured2.find((r) => r.name === SAMPLE_REPO)?.dir ?? sampleDir(configured2.map((r) => r.dir), route2.reposBasePath, route2.route.split("/")[0]);
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, route2.route);
@@ -29010,7 +29252,7 @@ ${where.join("\n")}`);
         }
         if (configured2.some((r) => r.dir === dir)) {
           try {
-            writeFileSync37(cfg.configFile, planRepoRemove(configText, cfgBase, route2.route, dir).text);
+            writeFileSync38(cfg.configFile, planRepoRemove(configText, cfgBase, route2.route, dir).text);
           } catch (e) {
             if (e instanceof ReposError) fail2(e.message);
             throw e;
@@ -29018,29 +29260,29 @@ ${where.join("\n")}`);
         }
         if (row) {
           await tracker.deleteRepoRow(row.id);
-          if (existsSync49(resolvedFile)) {
-            const raw = JSON.parse(readFileSync44(resolvedFile, "utf8"));
+          if (existsSync50(resolvedFile)) {
+            const raw = JSON.parse(readFileSync45(resolvedFile, "utf8"));
             if (raw.repoNames) delete raw.repoNames[row.id];
             if (raw.repoRemotes) delete raw.repoRemotes[row.id];
-            writeFileSync37(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync38(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        if (existsSync49(join53(dir, ".git")) && basename16(dir) === SAMPLE_REPO) rmSync24(dir, { recursive: true, force: true });
+        if (existsSync50(join54(dir, ".git")) && basename16(dir) === SAMPLE_REPO) rmSync25(dir, { recursive: true, force: true });
         say("removed", { dir, closed }, `removed the sample repo${closed.length ? `, closed ${closed.join(", ")}` : ""}`);
         break;
       }
       const projectId = route2.resolved.areaId ?? resolveRepoProject(await tracker.projectRows(), value("project"));
-      const fresh = !existsSync49(join53(dir, ".git"));
-      if (existsSync49(dir) && fresh && readdirSync20(dir).length > 0) fail2(`${dir} exists and is not a git checkout \u2014 move it aside`);
+      const fresh = !existsSync50(join54(dir, ".git"));
+      if (existsSync50(dir) && fresh && readdirSync20(dir).length > 0) fail2(`${dir} exists and is not a git checkout \u2014 move it aside`);
       if (dryRun) {
         say("dry-run", { dir, newCheckout: fresh, repoRow: row?.id ?? null }, `would ${fresh ? "create" : "reuse"} ${dir}${row ? "" : ", create the Repos row"}, and file one ${tracker.contract.statuses.approved} ticket`);
         break;
       }
       if (fresh) {
-        mkdirSync37(dir, { recursive: true });
-        writeFileSync37(join53(dir, "README.md"), SAMPLE_README);
-        writeFileSync37(join53(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
+        mkdirSync38(dir, { recursive: true });
+        writeFileSync38(join54(dir, "README.md"), SAMPLE_README);
+        writeFileSync38(join54(dir, ".crew.yaml"), SAMPLE_CREW_YAML);
         const g = (...a) => {
           const r = spawnSync11("git", a, { cwd: dir, encoding: "utf8" });
           if (r.status !== 0) fail2(`git ${a[0]} failed in ${dir}: ${(r.stderr || r.stdout).trim()}`);
@@ -29058,17 +29300,17 @@ ${where.join("\n")}`);
           spec: { platform: "unix", releaseMode: "integrate", ciProvider: "none" }
         });
         repoId = (await tracker.createRepoRow(payload)).id;
-        if (existsSync49(resolvedFile)) {
-          const raw = JSON.parse(readFileSync44(resolvedFile, "utf8"));
+        if (existsSync50(resolvedFile)) {
+          const raw = JSON.parse(readFileSync45(resolvedFile, "utf8"));
           raw.repoNames = { ...raw.repoNames, [repoId]: SAMPLE_REPO };
           raw.repoRemotes = { ...raw.repoRemotes, [repoId]: SAMPLE_REMOTE };
-          writeFileSync37(resolvedFile, `${JSON.stringify(raw, null, 2)}
+          writeFileSync38(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
         }
       }
       if (!configured2.some((r) => r.dir === dir)) {
         try {
-          writeFileSync37(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route2.route, path: dir, name: SAMPLE_REPO }).text);
+          writeFileSync38(cfg.configFile, planRepoAdd({ text: configText, base: cfgBase, route: route2.route, path: dir, name: SAMPLE_REPO }).text);
         } catch (e) {
           if (e instanceof ReposError) fail2(e.message);
           throw e;
@@ -29414,7 +29656,7 @@ watermark:  ${state.watermark()}
           }
           for (const r of repos) {
             const remote = r.config.branch.remote;
-            if (existsSync49(r.dir)) {
+            if (existsSync50(r.dir)) {
               pushAuth.push({
                 route: c.route,
                 repo: r.name,
@@ -29509,7 +29751,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       }
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync49(evFile) ? statSync16(evFile).size : 0;
+        const evSize = existsSync50(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"
@@ -29520,7 +29762,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 readFileSync44(p, "utf8");
+            return readFileSync45(p, "utf8");
           } catch {
             return null;
           }