@tablation/crew 0.30.1 → 0.31.0

package/dist/cli.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve4, dirname as dirname11, join as join20, basename as basename9 } from "path";
+import { resolve as resolve4, dirname as dirname12, join as join21, basename as basename9 } from "path";
 import { fileURLToPath } from "url";
-import { hostname as hostname2, homedir as homedir5 } from "os";
+import { hostname as hostname2, homedir as homedir6 } from "os";
 import { spawnSync as spawnSync3 } from "child_process";
 
 // src/config.ts
-import { readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
-import { resolve, dirname as dirname2, isAbsolute, join as join4, basename as basename3 } from "path";
-import { homedir as homedir2, tmpdir } from "os";
+import { readFileSync as readFileSync5, existsSync as existsSync4 } from "fs";
+import { resolve, dirname as dirname3, isAbsolute, join as join5, basename as basename3 } from "path";
+import { homedir as homedir3, tmpdir } from "os";
 import { parse as parse2 } from "yaml";
 
 // src/events.ts
@@ -157,8 +157,10 @@ var Emitter = class _Emitter {
 };
 var eventFileFor = (stateDir) => join(stateDir, "events.jsonl");
 
-// src/toolchain.ts
-import { basename } from "path";
+// src/pair-install.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync2, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join3 } from "path";
 
 // src/stream.ts
 function toolTarget(name, input) {
@@ -273,6 +275,14 @@ function ensureClaudeMcp(o) {
   }
   return `mcp: registered the ${MCP_SERVER_NAME} MCP server with Claude Code \u2192 ${o.url} (user scope, ~/.claude.json)`;
 }
+function removeClaudeMcp(o) {
+  const got = runClaude(o.bin, ["mcp", "get", MCP_SERVER_NAME]);
+  if (got.missing) return `mcp: \`${o.bin}\` not found, so Claude Code was not touched`;
+  if (got.status !== 0) return `mcp: no ${MCP_SERVER_NAME} server registered with Claude Code`;
+  if (o.dryRun) return `(dry run) would remove the ${MCP_SERVER_NAME} MCP server from Claude Code (user scope)`;
+  const rm = runClaude(o.bin, ["mcp", "remove", MCP_SERVER_NAME, "--scope", "user"]);
+  return rm.status === 0 ? `mcp: removed the ${MCP_SERVER_NAME} MCP server from Claude Code (user scope)` : `mcp: \`claude mcp remove\` failed (${rm.stderr.trim() || `exit ${rm.status}`})`;
+}
 
 // src/capability.ts
 function profileFor(role) {
@@ -312,6 +322,16 @@ function claudeToolsFor(p) {
 function allowedTools(role) {
   return claudeToolsFor(profileFor(role));
 }
+var claudePair = {
+  harness: "claude",
+  displayName: "Claude Code",
+  installPair: (o) => ensureClaudeMcp({ bin: o.bin ?? "claude", url: o.url, key: o.key ?? "", home: o.home, replace: o.replace, dryRun: o.dryRun }),
+  verifyPair(o) {
+    const s = inspectClaudeMcp({ bin: o.bin ?? "claude", url: o.url, key: o.key ?? "", home: o.home });
+    return s.state === "registered" ? { ok: true, detail: s.url } : s.state === "different" ? { ok: false, detail: s.detail } : { ok: false, detail: s.state === "no-claude" ? "claude binary not found" : "tablation MCP server not registered" };
+  },
+  removePair: (o) => removeClaudeMcp({ bin: o.bin ?? "claude", dryRun: o.dryRun })
+};
 var claudeAdapter = {
   harness: "claude",
   displayName: "Claude Code",
@@ -388,7 +408,291 @@ var claudeAdapter = {
   ensureMcp: ensureClaudeMcp
 };
 
+// src/pair-install.ts
+var PAIR_BLOCK_START = "<!-- crew:pair start -->";
+var PAIR_BLOCK_END = "<!-- crew:pair end -->";
+var PAIR_KEY_VAR = "CREW_API_KEY";
+var SERVER = "tablation";
+function pairBlock(harness) {
+  return [
+    PAIR_BLOCK_START,
+    "## Tablation Pair (managed by `crew connect` \u2014 edit nothing between the markers)",
+    "",
+    "At the start of every session, run `crew agents prompt pair --harness " + harness + "` and follow what it prints.",
+    `The Tablation tracker tools come from the \`${SERVER}\` MCP server; its key is read from \`$${PAIR_KEY_VAR}\`.`,
+    PAIR_BLOCK_END
+  ].join("\n");
+}
+var BLOCK_RE = new RegExp(`${escapeRe(PAIR_BLOCK_START)}[\\s\\S]*?${escapeRe(PAIR_BLOCK_END)}\\n?`);
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasPairBlock(text) {
+  return BLOCK_RE.test(text);
+}
+function pairBlockIsBroken(text) {
+  return !hasPairBlock(text) && (text.includes(PAIR_BLOCK_START) || text.includes(PAIR_BLOCK_END));
+}
+function upsertPairBlock(text, block) {
+  if (hasPairBlock(text)) return text.replace(BLOCK_RE, () => `${block}
+`);
+  if (text.trim() === "") return `${block}
+`;
+  return `${text.replace(/\n*$/, "")}
+
+${block}
+`;
+}
+function removePairBlock(text) {
+  if (!hasPairBlock(text)) return text;
+  return text.replace(new RegExp(`\\n*${BLOCK_RE.source}`), "\n").replace(/^\n+/, "").replace(/\n{3,}/g, "\n\n");
+}
+function readIfExists(path) {
+  return existsSync2(path) ? readFileSync3(path, "utf8") : void 0;
+}
+function writeFileMkdir(path, text) {
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync(path, text);
+}
+function installBlockFile(path, harness, dryRun) {
+  const before = readIfExists(path) ?? "";
+  if (pairBlockIsBroken(before)) return { changed: false, error: `${path} has an unmatched ${PAIR_BLOCK_START}/${PAIR_BLOCK_END} marker \u2014 fix it by hand` };
+  const after = upsertPairBlock(before, pairBlock(harness));
+  if (after === before) return { changed: false };
+  if (!dryRun) writeFileMkdir(path, after);
+  return { changed: true };
+}
+function removeBlockFile(path, dryRun) {
+  const before = readIfExists(path);
+  if (before === void 0 || !hasPairBlock(before)) return false;
+  if (dryRun) return true;
+  const after = removePairBlock(before);
+  if (after.trim() === "") rmSync2(path);
+  else writeFileSync(path, after);
+  return true;
+}
+function blockVerdict(path, harness) {
+  const text = readIfExists(path);
+  if (text === void 0 || !hasPairBlock(text)) return { ok: false, detail: `no managed block in ${path}` };
+  if (!text.includes(pairBlock(harness))) return { ok: false, detail: `the managed block in ${path} is out of date \u2014 run crew connect` };
+  return { ok: true, detail: "" };
+}
+var HEADER_RE = /^\s*\[\[?\s*([^\]]+?)\s*\]\]?\s*(#.*)?$/;
+var tableName = (raw) => raw.replace(/["']/g, "").replace(/\s*\.\s*/g, ".");
+function tomlTableRange(lines, name) {
+  const start = lines.findIndex((l) => {
+    const m = HEADER_RE.exec(l);
+    return m !== null && tableName(m[1]) === name;
+  });
+  if (start < 0) return void 0;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (HEADER_RE.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+  while (end > start + 1 && lines[end - 1].trim() === "") end--;
+  return [start, end];
+}
+var tomlString = (v) => JSON.stringify(v);
+function codexTable(url) {
+  return [`[mcp_servers.${SERVER}]`, `url = ${tomlString(url)}`, `bearer_token_env_var = ${tomlString(PAIR_KEY_VAR)}`];
+}
+function upsertTomlTable(text, name, table2) {
+  const lines = text.split("\n");
+  const r = tomlTableRange(lines, name);
+  if (r) {
+    lines.splice(r[0], r[1] - r[0], ...table2);
+    return lines.join("\n");
+  }
+  const body = text.replace(/\n*$/, "");
+  return body === "" ? `${table2.join("\n")}
+` : `${body}
+
+${table2.join("\n")}
+`;
+}
+function removeTomlTable(text, name) {
+  const lines = text.split("\n");
+  let r = tomlTableRange(lines, name);
+  if (!r) return text;
+  while (r) {
+    let [start, end] = r;
+    if (start > 0 && lines[start - 1].trim() === "") start--;
+    lines.splice(start, end - start);
+    const childName = lines.map((l) => HEADER_RE.exec(l)).map((m) => m ? tableName(m[1]) : void 0).find((n) => n !== void 0 && n.startsWith(`${name}.`));
+    r = childName === void 0 ? void 0 : tomlTableRange(lines, childName);
+  }
+  const out = lines.join("\n").replace(/^\n+/, "");
+  return out.trim() === "" ? "" : out.replace(/\n*$/, "\n");
+}
+function tomlValue(lines, range, key) {
+  for (let i = range[0] + 1; i < range[1]; i++) {
+    const m = new RegExp(`^\\s*${key}\\s*=\\s*"((?:[^"\\\\]|\\\\.)*)"`).exec(lines[i]);
+    if (m) return m[1];
+  }
+  return void 0;
+}
+var codexPaths = (home) => ({
+  instructions: join3(home, ".codex", "AGENTS.md"),
+  config: join3(home, ".codex", "config.toml")
+});
+function codexMcpState(config, url) {
+  const lines = config.split("\n");
+  const r = tomlTableRange(lines, `mcp_servers.${SERVER}`);
+  if (!r) return { state: "missing" };
+  const got = tomlValue(lines, r, "url");
+  const env = tomlValue(lines, r, "bearer_token_env_var");
+  if (got !== url) return { state: "different", detail: `it points at ${got ?? "(no url)"}, not ${url}` };
+  if (env !== PAIR_KEY_VAR) return { state: "different", detail: `it does not read its key from $${PAIR_KEY_VAR}` };
+  return { state: "registered" };
+}
+var codexPair = {
+  harness: "codex",
+  displayName: "Codex",
+  installPair(o) {
+    const p = codexPaths(o.home ?? homedir2());
+    const config = readIfExists(p.config) ?? "";
+    const st = codexMcpState(config, o.url);
+    if (st.state === "different" && !o.replace) {
+      return `pair(codex): left ${p.config} alone \u2014 a "${SERVER}" server exists and ${st.detail}. Re-run with --mcp replace to overwrite it.`;
+    }
+    const block = installBlockFile(p.instructions, "codex", o.dryRun);
+    if (block.error) return `pair(codex): ${block.error}`;
+    let mcpChanged = false;
+    if (st.state !== "registered") {
+      mcpChanged = true;
+      if (!o.dryRun) writeFileMkdir(p.config, upsertTomlTable(config, `mcp_servers.${SERVER}`, codexTable(o.url)));
+    }
+    if (!block.changed && !mcpChanged) return `pair(codex): already installed (${p.instructions}, ${p.config})`;
+    return `pair(codex): ${o.dryRun ? "(dry run) would install" : "installed"} the Pair block in ${p.instructions} and ${SERVER} in ${p.config} (key read from $${PAIR_KEY_VAR})`;
+  },
+  verifyPair(o) {
+    const p = codexPaths(o.home ?? homedir2());
+    const b = blockVerdict(p.instructions, "codex");
+    if (!b.ok) return b;
+    const st = codexMcpState(readIfExists(p.config) ?? "", o.url);
+    if (st.state === "missing") return { ok: false, detail: `no ${SERVER} server in ${p.config}` };
+    if (st.state === "different") return { ok: false, detail: `${SERVER} in ${p.config} ${st.detail}` };
+    return { ok: true, detail: `${p.instructions}, ${p.config}` };
+  },
+  removePair(o) {
+    const p = codexPaths(o.home ?? homedir2());
+    const hadBlock = removeBlockFile(p.instructions, o.dryRun);
+    const config = readIfExists(p.config);
+    const st = codexMcpState(config ?? "", o.url);
+    const hadMcp = config !== void 0 && st.state === "registered";
+    const kept = st.state === "different" ? `; left the existing ${SERVER} server alone \u2014 ${st.detail}` : "";
+    if (hadMcp && !o.dryRun) {
+      const after = removeTomlTable(config, `mcp_servers.${SERVER}`);
+      if (after === "") rmSync2(p.config);
+      else writeFileSync(p.config, after);
+    }
+    const what = hadBlock && hadMcp ? `the Pair block and ${SERVER} server` : hadBlock ? "the Pair block" : `the ${SERVER} server`;
+    return hadBlock || hadMcp ? `pair(codex): ${o.dryRun ? "(dry run) would remove" : "removed"} ${what}${kept}` : `pair(codex): nothing to remove${kept}`;
+  }
+};
+var geminiPaths = (home) => ({
+  instructions: join3(home, ".gemini", "GEMINI.md"),
+  config: join3(home, ".gemini", "settings.json")
+});
+function readGeminiSettings(path) {
+  const text = readIfExists(path);
+  if (text === void 0 || text.trim() === "") return {};
+  try {
+    const j = JSON.parse(text);
+    return j && typeof j === "object" && !Array.isArray(j) ? j : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var geminiEntry = (url) => ({ httpUrl: url, headers: { Authorization: `Bearer $${PAIR_KEY_VAR}` } });
+function geminiMcpState(s, url) {
+  const e = s.mcpServers?.[SERVER];
+  if (!e) return { state: "missing" };
+  if (e.httpUrl !== url) return { state: "different", detail: `it points at ${e.httpUrl ?? "(no httpUrl)"}, not ${url}` };
+  if (e.headers?.Authorization !== `Bearer $${PAIR_KEY_VAR}`) return { state: "different", detail: `it does not read its key from $${PAIR_KEY_VAR}` };
+  return { state: "registered" };
+}
+var geminiPair = {
+  harness: "gemini",
+  displayName: "Gemini CLI",
+  installPair(o) {
+    const p = geminiPaths(o.home ?? homedir2());
+    const settings = readGeminiSettings(p.config);
+    if (!settings) return `pair(gemini): ${p.config} is not a JSON object \u2014 fix it by hand; nothing was written`;
+    const st = geminiMcpState(settings, o.url);
+    if (st.state === "different" && !o.replace) {
+      return `pair(gemini): left ${p.config} alone \u2014 a "${SERVER}" server exists and ${st.detail}. Re-run with --mcp replace to overwrite it.`;
+    }
+    const block = installBlockFile(p.instructions, "gemini", o.dryRun);
+    if (block.error) return `pair(gemini): ${block.error}`;
+    const mcpChanged = st.state !== "registered";
+    if (mcpChanged && !o.dryRun) {
+      const next = { ...settings, mcpServers: { ...settings.mcpServers, [SERVER]: geminiEntry(o.url) } };
+      writeFileMkdir(p.config, `${JSON.stringify(next, null, 2)}
+`);
+    }
+    if (!block.changed && !mcpChanged) return `pair(gemini): already installed (${p.instructions}, ${p.config})`;
+    return `pair(gemini): ${o.dryRun ? "(dry run) would install" : "installed"} the Pair block in ${p.instructions} and ${SERVER} in ${p.config} (key read from $${PAIR_KEY_VAR})`;
+  },
+  verifyPair(o) {
+    const p = geminiPaths(o.home ?? homedir2());
+    const b = blockVerdict(p.instructions, "gemini");
+    if (!b.ok) return b;
+    const settings = readGeminiSettings(p.config);
+    if (!settings) return { ok: false, detail: `${p.config} is not a JSON object` };
+    const st = geminiMcpState(settings, o.url);
+    if (st.state === "missing") return { ok: false, detail: `no ${SERVER} server in ${p.config}` };
+    if (st.state === "different") return { ok: false, detail: `${SERVER} in ${p.config} ${st.detail}` };
+    return { ok: true, detail: `${p.instructions}, ${p.config}` };
+  },
+  removePair(o) {
+    const p = geminiPaths(o.home ?? homedir2());
+    const hadBlock = removeBlockFile(p.instructions, o.dryRun);
+    const settings = readGeminiSettings(p.config);
+    const st = settings ? geminiMcpState(settings, o.url) : { state: "missing" };
+    const hadMcp = st.state === "registered";
+    const kept = st.state === "different" ? `; left the existing ${SERVER} server alone \u2014 ${st.detail}` : "";
+    if (hadMcp && settings && !o.dryRun) {
+      const { [SERVER]: _gone, ...rest } = settings.mcpServers ?? {};
+      const next = { ...settings };
+      if (Object.keys(rest).length > 0) next.mcpServers = rest;
+      else delete next.mcpServers;
+      if (Object.keys(next).length === 0) rmSync2(p.config);
+      else writeFileSync(p.config, `${JSON.stringify(next, null, 2)}
+`);
+    }
+    const what = hadBlock && hadMcp ? `the Pair block and ${SERVER} server` : hadBlock ? "the Pair block" : `the ${SERVER} server`;
+    return hadBlock || hadMcp ? `pair(gemini): ${o.dryRun ? "(dry run) would remove" : "removed"} ${what}${kept}` : `pair(gemini): nothing to remove${kept}`;
+  }
+};
+var PAIR_INSTALLERS = {
+  [claudePair.harness]: claudePair,
+  [codexPair.harness]: codexPair,
+  [geminiPair.harness]: geminiPair
+};
+var PAIR_HARNESS_NAMES = Object.keys(PAIR_INSTALLERS);
+var DEFAULT_PAIR = ["claude"];
+function isPairHarness(name) {
+  return Object.hasOwn(PAIR_INSTALLERS, name);
+}
+function pairInstallerFor(harness) {
+  const i = Object.hasOwn(PAIR_INSTALLERS, harness) ? PAIR_INSTALLERS[harness] : void 0;
+  if (!i) throw new Error(`no Pair installer for "${harness}" (have: ${PAIR_HARNESS_NAMES.join(", ")})`);
+  return i;
+}
+function harnessPromptNote(harness) {
+  if (!harness || !isPairHarness(harness)) return "";
+  return `
+
+(This Pair session is running in ${pairInstallerFor(harness).displayName}.)
+`;
+}
+
 // src/toolchain.ts
+import { basename } from "path";
 var TIERS = ["light", "standard", "deep"];
 var ADAPTERS = {
   [claudeAdapter.harness]: claudeAdapter
@@ -512,8 +816,8 @@ function explain(ship, required) {
 }
 
 // src/repo-config.ts
-import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
-import { join as join3, basename as basename2 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
+import { join as join4, basename as basename2 } from "path";
 import { parse } from "yaml";
 var SPEC_VERSION = 1;
 var REPO_CONFIG_FILENAMES = [".crew.yaml", ".crew.yml", ".crew.json"];
@@ -586,8 +890,8 @@ var MODES = ["local", "integrate", "ci_manual", "ci_auto", "external"];
 var PROVIDERS = ["github", "buildkite", "other", "none"];
 function findRepoConfig(dir) {
   for (const name of REPO_CONFIG_FILENAMES) {
-    const p = join3(dir, name);
-    if (existsSync2(p)) return p;
+    const p = join4(dir, name);
+    if (existsSync3(p)) return p;
   }
   return null;
 }
@@ -817,7 +1121,7 @@ function parseRepoConfig(text, file) {
 function loadRepoConfig(dir) {
   const file = findRepoConfig(dir);
   if (!file) return null;
-  return parseRepoConfig(readFileSync3(file, "utf8"), file);
+  return parseRepoConfig(readFileSync4(file, "utf8"), file);
 }
 function hookLabel(cfg, hook2) {
   return cfg.labels[hook2] ?? cfg.hooks[hook2] ?? hook2;
@@ -1084,6 +1388,7 @@ var SHIP_KEYS = /* @__PURE__ */ new Set([
   "agent",
   "toolchains",
   "toolchain",
+  "pair",
   "shell",
   "extraPath",
   "useNvm",
@@ -1228,16 +1533,16 @@ function mergeRouteRelease(route, override) {
   };
 }
 function expand(p, base) {
-  let out = p.startsWith("~") ? p.replace(/^~/, homedir2()) : p;
-  out = out.replace(/\$\{?HOME\}?/g, homedir2());
+  let out = p.startsWith("~") ? p.replace(/^~/, homedir3()) : p;
+  out = out.replace(/\$\{?HOME\}?/g, homedir3());
   return isAbsolute(out) ? out : resolve(base, out);
 }
 function resolvePromptsDir(promptSet, crewHome, base) {
-  if (!promptSet) return join4(crewHome, "prompts", "default");
+  if (!promptSet) return join5(crewHome, "prompts", "default");
   if (promptSet.includes("/") || promptSet.startsWith(".") || promptSet.startsWith("~")) {
     return expand(promptSet, base);
   }
-  return join4(crewHome, "prompts", promptSet);
+  return join5(crewHome, "prompts", promptSet);
 }
 var Missing = class {
   paths = [];
@@ -1261,7 +1566,7 @@ var Missing = class {
 };
 function crewVersion(crewHome) {
   try {
-    const pkg = JSON.parse(readFileSync4(join4(crewHome, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync5(join5(crewHome, "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -1271,26 +1576,26 @@ function configSearchPath(crewHome) {
   if (process.env.CREW_CONFIG) return [resolve(process.env.CREW_CONFIG)];
   const xdg = process.env.XDG_CONFIG_HOME;
   return [
-    ...xdg ? [join4(xdg, "crew", "crew.yaml")] : [],
-    join4(homedir2(), ".config", "crew", "crew.yaml"),
+    ...xdg ? [join5(xdg, "crew", "crew.yaml")] : [],
+    join5(homedir3(), ".config", "crew", "crew.yaml"),
     resolve(crewHome, "crew.yaml")
   ];
 }
 function findConfigFile(crewHome) {
   const candidates = configSearchPath(crewHome);
-  return candidates.find((c) => existsSync3(c)) ?? candidates[candidates.length - 1];
+  return candidates.find((c) => existsSync4(c)) ?? candidates[candidates.length - 1];
 }
-var defaultConfigPath = () => join4(process.env.XDG_CONFIG_HOME ?? join4(homedir2(), ".config"), "crew", "crew.yaml");
+var defaultConfigPath = () => join5(process.env.XDG_CONFIG_HOME ?? join5(homedir3(), ".config"), "crew", "crew.yaml");
 function routeSlug(route) {
   return route.replace(/\//g, "-");
 }
 function resolvedPathFor(stateDir, route) {
   const [workspace, project] = splitRoute(route);
-  return join4(stateDir, "resolved", workspace, `${project}.json`);
+  return join5(stateDir, "resolved", workspace, `${project}.json`);
 }
 function apiKeyPathFor(stateDir, route) {
   const [workspace, project] = splitRoute(route);
-  return join4(stateDir, "keys", workspace, `${project}.env`);
+  return join5(stateDir, "keys", workspace, `${project}.env`);
 }
 function splitRoute(route) {
   const parts = route.split("/");
@@ -1301,9 +1606,9 @@ function splitRoute(route) {
 }
 function readResolvedFile(stateDir, route) {
   const path = resolvedPathFor(stateDir, route);
-  if (!existsSync3(path)) return void 0;
+  if (!existsSync4(path)) return void 0;
   try {
-    return JSON.parse(readFileSync4(path, "utf8"));
+    return JSON.parse(readFileSync5(path, "utf8"));
   } catch (e) {
     throw new ConfigError(`${path}: not valid JSON \u2014 ${e.message}`);
   }
@@ -1359,23 +1664,23 @@ function parseResolved(raw, m, where) {
 }
 function loadConfig(crewHome, configFile, opts = {}) {
   const file = configFile ?? findConfigFile(crewHome);
-  if (opts.text === void 0 && !existsSync3(file)) {
+  if (opts.text === void 0 && !existsSync4(file)) {
     throw new ConfigError(
       `no config found. Looked in:
 ` + configSearchPath(crewHome).map((c) => `  - ${c}`).join("\n") + `
 
 Create the first of those:
-  mkdir -p ${dirname2(defaultConfigPath())} && cp ${join4(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
+  mkdir -p ${dirname3(defaultConfigPath())} && cp ${join5(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
     );
   }
   let raw;
   try {
-    raw = parse2(opts.text ?? readFileSync4(file, "utf8"));
+    raw = parse2(opts.text ?? readFileSync5(file, "utf8"));
   } catch (e) {
     throw new ConfigError(`${file}: not valid YAML \u2014 ${e.message}`);
   }
   if (!raw || typeof raw !== "object") throw new ConfigError(`${file} is empty or not a mapping`);
-  const base = dirname2(file);
+  const base = dirname3(file);
   const missing = new Missing();
   rejectUnknownKeys(raw, /* @__PURE__ */ new Set(["ship", "routes"]), "top-level", file);
   const shipRaw = raw.ship ?? {};
@@ -1402,6 +1707,7 @@ Create the first of those:
   }
   const toolchains = parseToolchains(shipRaw.toolchains, base, missing, file);
   const toolchainNames = /* @__PURE__ */ new Set([LEGACY_TOOLCHAIN, ...toolchains.map((x) => x.name)]);
+  const pair = parsePair(shipRaw.pair, missing);
   const shipToolchain = shipRaw.toolchain === void 0 ? void 0 : String(shipRaw.toolchain);
   if (shipToolchain !== void 0 && !toolchainNames.has(shipToolchain)) {
     missing.add(`ship.toolchain "${shipToolchain}" is not defined (have: ${[...toolchainNames].join(", ")})`);
@@ -1441,12 +1747,13 @@ Create the first of those:
       },
       ...toolchains.length > 0 ? { toolchains } : {},
       ...shipToolchain !== void 0 ? { toolchain: shipToolchain } : {},
+      ...pair ? { pair } : {},
       shell: shipRaw.shell,
       extraPath: shipRaw.extraPath,
       useNvm: shipRaw.useNvm !== false,
       nvmSh: shipRaw.nvmSh,
       stateDir,
-      logFile: expand(shipRaw.logFile ?? join4(tmpdir(), "crew.log"), base),
+      logFile: expand(shipRaw.logFile ?? join5(tmpdir(), "crew.log"), base),
       userAgent: shipRaw.userAgent ?? `Mozilla/5.0 CrewAgent/${crewVersion(crewHome)}`,
       maxConcurrentAgents,
       streamRetentionDays,
@@ -1468,6 +1775,22 @@ function expandCommand(cmd, base) {
   return cmd.includes("/") || cmd.startsWith("~") ? expand(cmd, base) : cmd;
 }
 var TOOLCHAIN_KEYS = /* @__PURE__ */ new Set(["harness", "bin", "launcher", "model", "tiers", "args", "env", "maxThinkingTokens"]);
+function parsePair(raw, missing) {
+  if (raw === void 0) return void 0;
+  if (!Array.isArray(raw)) {
+    missing.add("ship.pair must be a list of harness names");
+    return void 0;
+  }
+  const out = [];
+  for (const h of raw.map(String)) {
+    if (!isPairHarness(h)) missing.add(`ship.pair "${h}" is not a harness Pair can be installed for (have: ${PAIR_HARNESS_NAMES.join(", ")})`);
+    else if (!out.includes(h)) out.push(h);
+  }
+  return out;
+}
+function shipPair(ship) {
+  return ship.pair ?? DEFAULT_PAIR;
+}
 function parseToolchains(raw, base, missing, file) {
   if (raw === void 0 || raw === null) return [];
   if (typeof raw !== "object" || Array.isArray(raw)) {
@@ -1644,8 +1967,8 @@ function repoIdForName(r, name) {
 }
 function resolveApiKey(r) {
   if (r.apiKey) return r.apiKey;
-  if (r.apiKeyFile && r.apiKeyVar && existsSync3(r.apiKeyFile)) {
-    for (const line of readFileSync4(r.apiKeyFile, "utf8").split("\n")) {
+  if (r.apiKeyFile && r.apiKeyVar && existsSync4(r.apiKeyFile)) {
+    for (const line of readFileSync5(r.apiKeyFile, "utf8").split("\n")) {
       const m = line.match(new RegExp(`^${r.apiKeyVar}=(.*)$`));
       if (m) return (m[1] ?? "").trim().replace(/^["']|["']$/g, "");
     }
@@ -1708,7 +2031,7 @@ function configuredMembers(rt) {
   return out;
 }
 function defaultRepoDir(basePath, workspace, repoName) {
-  return join4(basePath, workspace, repoName);
+  return join5(basePath, workspace, repoName);
 }
 function reposOf(r) {
   const named = Object.entries(r.repos);
@@ -1732,7 +2055,7 @@ function passengerRepoTargets(r) {
   return reposOf(r).filter((t) => r.repoOverrides[t.name]?.hostPassengers !== false);
 }
 function passengerCheckoutDir(basePath, workspace, repoName) {
-  return join4(basePath, workspace, ".passenger-checkouts", repoName);
+  return join5(basePath, workspace, ".passenger-checkouts", repoName);
 }
 function passengerCheckoutTargets(r) {
   if (!r.hostPassengers) return [];
@@ -1864,17 +2187,17 @@ function rosterMarkdown(roster, meId) {
 }
 
 // src/state.ts
-import { readFileSync as readFileSync5, writeFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, rmSync as rmSync2, statSync as statSync2 } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync3, rmSync as rmSync3, statSync as statSync2 } from "fs";
+import { join as join6 } from "path";
 var EPOCH = "1970-01-01T00:00:00.000Z";
 var State = class _State {
   dir;
   constructor(dir) {
     this.dir = dir;
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync3(dir, { recursive: true });
   }
   path(...parts) {
-    return join5(this.dir, ...parts);
+    return join6(this.dir, ...parts);
   }
   /**
    * The timestamp every "new since last poll" check is measured against.
@@ -1885,14 +2208,14 @@ var State = class _State {
    */
   watermark() {
     try {
-      const v = readFileSync5(this.path(".poll-watermark"), "utf8").trim();
+      const v = readFileSync6(this.path(".poll-watermark"), "utf8").trim();
       return v || EPOCH;
     } catch {
       return EPOCH;
     }
   }
   setWatermark(at) {
-    writeFileSync(this.path(".poll-watermark"), `${at}
+    writeFileSync2(this.path(".poll-watermark"), `${at}
 `);
   }
   /**
@@ -1910,19 +2233,19 @@ var State = class _State {
   }
   /** Whole-crew pause, and the per-role sentinels one level down. */
   isPaused() {
-    return existsSync4(this.path(".crew-paused"));
+    return existsSync5(this.path(".crew-paused"));
   }
   isRolePaused(role) {
-    return existsSync4(this.path(`.role-paused-${role}`));
+    return existsSync5(this.path(`.role-paused-${role}`));
   }
   pausedRoles(roles) {
     return new Set(roles.filter((r) => this.isRolePaused(r)));
   }
   pause(role) {
-    writeFileSync(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
+    writeFileSync2(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), "");
   }
   resume(role) {
-    rmSync2(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
+    rmSync3(role ? this.path(`.role-paused-${role}`) : this.path(".crew-paused"), { force: true });
   }
   /**
    * The release phase (merge, deploy, release) has its own sentinel, one
@@ -1930,11 +2253,11 @@ var State = class _State {
    * while agents keep working.
    */
   isReleasePaused() {
-    return existsSync4(this.path(".release-paused"));
+    return existsSync5(this.path(".release-paused"));
   }
   setReleasePaused(paused) {
-    if (paused) writeFileSync(this.path(".release-paused"), "");
-    else rmSync2(this.path(".release-paused"), { force: true });
+    if (paused) writeFileSync2(this.path(".release-paused"), "");
+    else rmSync3(this.path(".release-paused"), { force: true });
   }
   /**
    * Why a release cycle must not run right now, or null when it may. Every
@@ -1971,7 +2294,7 @@ var State = class _State {
     const name = _State.safe(rawName);
     const file = this.path(`.${name}.lock`);
     try {
-      const existing = Number.parseInt(readFileSync5(file, "utf8").trim(), 10);
+      const existing = Number.parseInt(readFileSync6(file, "utf8").trim(), 10);
       if (Number.isFinite(existing) && existing > 0) {
         try {
           process.kill(existing, 0);
@@ -1981,13 +2304,13 @@ var State = class _State {
       }
     } catch {
     }
-    writeFileSync(file, `${process.pid}
+    writeFileSync2(file, `${process.pid}
 `);
     return {
       ok: true,
       release: () => {
         try {
-          rmSync2(file, { force: true });
+          rmSync3(file, { force: true });
         } catch {
         }
       }
@@ -2065,7 +2388,7 @@ var State = class _State {
     const heldReported = `.release-held-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync5(this.path(f), "utf8").trim() || null;
+        return readFileSync6(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -2074,12 +2397,12 @@ var State = class _State {
       blockedCount: () => Number.parseInt(read(blocked) ?? "", 10) || 0,
       noteBlocked: () => {
         const n = (Number.parseInt(read(blocked) ?? "", 10) || 0) + 1;
-        writeFileSync(this.path(blocked), `${n}
+        writeFileSync2(this.path(blocked), `${n}
 `);
         return n;
       },
       clearBlocked: () => {
-        rmSync2(this.path(blocked), { force: true });
+        rmSync3(this.path(blocked), { force: true });
       },
       /**
        * The commit a deploy last failed on.
@@ -2091,11 +2414,11 @@ var State = class _State {
        */
       deployFailedSha: () => read(failed),
       noteDeployFailed: (sha) => {
-        writeFileSync(this.path(failed), `${sha}
+        writeFileSync2(this.path(failed), `${sha}
 `);
       },
       clearDeployFailed: () => {
-        rmSync2(this.path(failed), { force: true });
+        rmSync3(this.path(failed), { force: true });
       },
       /**
        * Consecutive test-gate failures on the same head (CREW-1368). A failure
@@ -2105,31 +2428,31 @@ var State = class _State {
       noteTestGateFailed: (sha) => {
         const [prev, n] = (read(gateFailed) ?? "").split(" ");
         const next = prev === sha ? (Number.parseInt(n ?? "", 10) || 0) + 1 : 1;
-        writeFileSync(this.path(gateFailed), `${sha} ${next}
+        writeFileSync2(this.path(gateFailed), `${sha} ${next}
 `);
         return next;
       },
       clearTestGateFailed: () => {
-        rmSync2(this.path(gateFailed), { force: true });
+        rmSync3(this.path(gateFailed), { force: true });
       },
       /** Whether the board was already told about this head's red gate. */
       heldReported: () => {
         try {
-          return readFileSync5(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
+          return readFileSync6(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
         } catch {
           return null;
         }
       },
       noteHeldReported: (signature) => {
-        writeFileSync(this.path(heldReported), `${signature}
+        writeFileSync2(this.path(heldReported), `${signature}
 `);
       },
       clearHeldReported: () => {
-        rmSync2(this.path(heldReported), { force: true });
+        rmSync3(this.path(heldReported), { force: true });
       },
       testGateReported: (sha) => read(gateReported) === sha,
       noteTestGateReported: (sha) => {
-        writeFileSync(this.path(gateReported), `${sha}
+        writeFileSync2(this.path(gateReported), `${sha}
 `);
       }
     };
@@ -2152,13 +2475,13 @@ var State = class _State {
     const ticketStreakFile = `.fairness-ticket-streak-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync5(this.path(f), "utf8").trim() || null;
+        return readFileSync6(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
     };
     const clear2 = () => {
-      for (const f of [streakFile, ticketFile, sinceFile, ticketStreakFile]) rmSync2(this.path(f), { force: true });
+      for (const f of [streakFile, ticketFile, sinceFile, ticketStreakFile]) rmSync3(this.path(f), { force: true });
     };
     return {
       /** Consecutive cycles this route had actionable work and did not win. */
@@ -2185,18 +2508,18 @@ var State = class _State {
           clear2();
           return;
         }
-        writeFileSync(this.path(streakFile), `${this.readInt(streakFile) + 1}
+        writeFileSync2(this.path(streakFile), `${this.readInt(streakFile) + 1}
 `);
         const prior = read(ticketFile);
         if (topTicket && topTicket === prior) {
-          writeFileSync(this.path(ticketStreakFile), `${this.readInt(ticketStreakFile) + 1}
+          writeFileSync2(this.path(ticketStreakFile), `${this.readInt(ticketStreakFile) + 1}
 `);
         } else if (topTicket) {
-          writeFileSync(this.path(ticketFile), `${topTicket}
+          writeFileSync2(this.path(ticketFile), `${topTicket}
 `);
-          writeFileSync(this.path(sinceFile), `${(/* @__PURE__ */ new Date()).toISOString()}
+          writeFileSync2(this.path(sinceFile), `${(/* @__PURE__ */ new Date()).toISOString()}
 `);
-          writeFileSync(this.path(ticketStreakFile), "1\n");
+          writeFileSync2(this.path(ticketStreakFile), "1\n");
         }
       }
     };
@@ -2217,14 +2540,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync5(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync6(this.path(file), "utf8"));
           return parsed && typeof parsed === "object" ? parsed : {};
         } catch {
           return {};
         }
       },
       persist: (next) => {
-        writeFileSync(this.path(file), JSON.stringify(next));
+        writeFileSync2(this.path(file), JSON.stringify(next));
       }
     };
   }
@@ -2238,14 +2561,14 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync5(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync6(this.path(file), "utf8"));
           return Array.isArray(parsed) ? parsed : [];
         } catch {
           return [];
         }
       },
       persist: (next) => {
-        writeFileSync(this.path(file), JSON.stringify(next));
+        writeFileSync2(this.path(file), JSON.stringify(next));
       }
     };
   }
@@ -2258,7 +2581,7 @@ var State = class _State {
     const file = ".release-last-run";
     return {
       touch: () => {
-        writeFileSync(this.path(file), (/* @__PURE__ */ new Date()).toISOString());
+        writeFileSync2(this.path(file), (/* @__PURE__ */ new Date()).toISOString());
       },
       at: () => {
         try {
@@ -2271,7 +2594,7 @@ var State = class _State {
   }
   readInt(file) {
     try {
-      return Number.parseInt(readFileSync5(this.path(file), "utf8").trim(), 10) || 0;
+      return Number.parseInt(readFileSync6(this.path(file), "utf8").trim(), 10) || 0;
     } catch {
       return 0;
     }
@@ -2575,9 +2898,9 @@ function describeRelease(o, route) {
 }
 
 // src/install.ts
-import { dirname as dirname3, join as join6, extname } from "path";
-import { homedir as homedir3 } from "os";
-import { accessSync, constants, existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync6, statSync as statSync3, writeFileSync as writeFileSync2, unlinkSync, realpathSync } from "fs";
+import { dirname as dirname4, join as join7, extname } from "path";
+import { homedir as homedir4 } from "os";
+import { accessSync, constants, existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync7, statSync as statSync3, writeFileSync as writeFileSync3, unlinkSync, realpathSync } from "fs";
 import { spawnSync as spawnSync2 } from "child_process";
 import { createHash } from "crypto";
 
@@ -2589,7 +2912,7 @@ function isCompiledBinary(moduleUrl) {
 // src/install.ts
 function crewInvocation(crewHome) {
   if (isCompiledBinary(import.meta.url)) return [process.execPath];
-  return [process.execPath, join6(crewHome, "bin", "crew")];
+  return [process.execPath, join7(crewHome, "bin", "crew")];
 }
 var INTERVAL_SECONDS = 120;
 function labelFor(crewHome, job) {
@@ -2620,14 +2943,14 @@ function schedulerLogFor(crewLog, job) {
   return `${stem}.${suffix}${ext || ".log"}`;
 }
 function pathFor(ship) {
-  const nodeBinDir = dirname3(process.execPath);
+  const nodeBinDir = dirname4(process.execPath);
   const parts = [nodeBinDir];
   if (ship.extraPath) parts.push(ship.extraPath);
   parts.push("/usr/bin", "/bin", "/usr/sbin", "/sbin");
   return parts.join(":");
 }
 function findOnPath(bin, searchPath) {
-  const candidates = bin.includes("/") ? [bin] : searchPath.split(":").filter(Boolean).map((dir) => join6(dir, bin));
+  const candidates = bin.includes("/") ? [bin] : searchPath.split(":").filter(Boolean).map((dir) => join7(dir, bin));
   for (const candidate of candidates) {
     try {
       accessSync(candidate, constants.X_OK);
@@ -2637,19 +2960,19 @@ function findOnPath(bin, searchPath) {
   }
   return void 0;
 }
-var COMMON_DOCKER_DIRS = ["/usr/local/bin", "/opt/homebrew/bin", join6(homedir3(), ".docker", "bin")].join(":");
+var COMMON_DOCKER_DIRS = ["/usr/local/bin", "/opt/homebrew/bin", join7(homedir4(), ".docker", "bin")].join(":");
 function dockerPathProblem(ship, shellPath = process.env.PATH ?? "") {
   const schedulerPath = pathFor(ship);
   if (findOnPath("docker", schedulerPath)) return void 0;
   const inShell = findOnPath("docker", shellPath);
-  return inShell ? `\`docker\` is not on the scheduler PATH (${schedulerPath}) but is at ${inShell} in your shell; add ${dirname3(inShell)} to ship.extraPath in crew.yaml and run \`crew install\`` : `\`docker\` is not on the scheduler PATH (${schedulerPath}) or your shell PATH; install Docker, then add its directory to ship.extraPath in crew.yaml and run \`crew install\``;
+  return inShell ? `\`docker\` is not on the scheduler PATH (${schedulerPath}) but is at ${inShell} in your shell; add ${dirname4(inShell)} to ship.extraPath in crew.yaml and run \`crew install\`` : `\`docker\` is not on the scheduler PATH (${schedulerPath}) or your shell PATH; install Docker, then add its directory to ship.extraPath in crew.yaml and run \`crew install\``;
 }
 function xmlEscape(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function planLaunchd(ship, crewHome, job) {
   const label = labelFor(crewHome, job);
-  const unitPath = join6(homedir3(), "Library", "LaunchAgents", `${label}.plist`);
+  const unitPath = join7(homedir4(), "Library", "LaunchAgents", `${label}.plist`);
   const crewLog = ship.logFile;
   const schedulerLog = schedulerLogFor(crewLog, job);
   const persistent = job === "run";
@@ -2701,8 +3024,8 @@ ${scheduleKeys}
 }
 function planSystemd(ship, crewHome, job) {
   const label = labelFor(crewHome, job);
-  const unitDir = join6(homedir3(), ".config", "systemd", "user");
-  const servicePath = join6(unitDir, `${label}.service`);
+  const unitDir = join7(homedir4(), ".config", "systemd", "user");
+  const servicePath = join7(unitDir, `${label}.service`);
   const crewLog = ship.logFile;
   const schedulerLog = schedulerLogFor(crewLog, job);
   const description = job === "release" ? "Tablation crew \u2014 release" : job === "passengers" ? "Tablation crew \u2014 Host Passengers sync" : "Tablation crew \u2014 persistent supervisor loop";
@@ -2739,7 +3062,7 @@ WantedBy=default.target
       schedulerLog
     };
   }
-  const timerPath = join6(unitDir, `${label}.timer`);
+  const timerPath = join7(unitDir, `${label}.timer`);
   const service = `# Written by \`crew install\` \u2014 re-run it rather than hand-editing this file.
 [Unit]
 Description=${description}
@@ -2806,7 +3129,7 @@ function planInstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
 function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
   const label = labelFor(crewHome, job);
   if (hostShip === "macos") {
-    const unitPath = join6(homedir3(), "Library", "LaunchAgents", `${label}.plist`);
+    const unitPath = join7(homedir4(), "Library", "LaunchAgents", `${label}.plist`);
     return {
       mechanism: "launchd",
       unitPaths: [unitPath],
@@ -2816,18 +3139,18 @@ function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
     };
   }
   if (hostShip === "linux" && hasSystemd) {
-    const unitDir = join6(homedir3(), ".config", "systemd", "user");
+    const unitDir = join7(homedir4(), ".config", "systemd", "user");
     if (job === "run") {
       return {
         mechanism: "systemd",
-        unitPaths: [join6(unitDir, `${label}.service`)],
+        unitPaths: [join7(unitDir, `${label}.service`)],
         crontabLine: null,
         unloadCommands: [["systemctl", "--user", "disable", "--now", `${label}.service`]]
       };
     }
     return {
       mechanism: "systemd",
-      unitPaths: [join6(unitDir, `${label}.service`), join6(unitDir, `${label}.timer`)],
+      unitPaths: [join7(unitDir, `${label}.service`), join7(unitDir, `${label}.timer`)],
       crontabLine: null,
       unloadCommands: [["systemctl", "--user", "disable", "--now", `${label}.timer`]]
     };
@@ -2845,7 +3168,7 @@ function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
 function planDaemonControl(crewHome, hostShip, hasSystemd) {
   const label = labelFor(crewHome, "run");
   if (hostShip === "macos") {
-    const unitPath = join6(homedir3(), "Library", "LaunchAgents", `${label}.plist`);
+    const unitPath = join7(homedir4(), "Library", "LaunchAgents", `${label}.plist`);
     return {
       mechanism: "launchd",
       startCommand: ["launchctl", "load", unitPath],
@@ -2885,8 +3208,8 @@ async function applyInstall(plan, crewHome, dryRun, log) {
       log.emit(`would write ${path}`);
       continue;
     }
-    mkdirSync3(dirname3(path), { recursive: true });
-    writeFileSync2(path, plan.unitContent[path]);
+    mkdirSync4(dirname4(path), { recursive: true });
+    writeFileSync3(path, plan.unitContent[path]);
     log.emit(`wrote ${path}`);
   }
   if (plan.crontabLine) {
@@ -2940,7 +3263,7 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
     }
   }
   for (const path of plan.unitPaths) {
-    if (!existsSync5(path)) continue;
+    if (!existsSync6(path)) continue;
     if (dryRun) {
       log.emit(`would remove ${path}`);
       continue;
@@ -2959,7 +3282,7 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
 }
 var CREW_LAUNCHD_PREFIX = "com.tablation.crew";
 function launchAgentsDir() {
-  return join6(homedir3(), "Library", "LaunchAgents");
+  return join7(homedir4(), "Library", "LaunchAgents");
 }
 function xmlUnescape(s) {
   return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
@@ -2976,25 +3299,25 @@ function loadedCrewLabels() {
   return [...parseLaunchctlList(list.stdout ?? "").keys()].filter((l) => l.startsWith(CREW_LAUNCHD_PREFIX));
 }
 function listLaunchdUnits(dir = launchAgentsDir(), loaded = []) {
-  const files = existsSync5(dir) ? readdirSync(dir) : [];
+  const files = existsSync6(dir) ? readdirSync(dir) : [];
   const units = files.filter((f) => f.startsWith(CREW_LAUNCHD_PREFIX) && f.endsWith(".plist")).sort().map((f) => {
-    const plistPath = join6(dir, f);
+    const plistPath = join7(dir, f);
     let program = null;
     try {
-      program = programFromPlist(readFileSync6(plistPath, "utf8"));
+      program = programFromPlist(readFileSync7(plistPath, "utf8"));
     } catch {
     }
     return {
       label: f.slice(0, -".plist".length),
       plistPath,
       program,
-      programExists: program !== null && existsSync5(program)
+      programExists: program !== null && existsSync6(program)
     };
   });
   const seen = new Set(units.map((u) => u.label));
   for (const label of [...loaded].sort()) {
     if (!label.startsWith(CREW_LAUNCHD_PREFIX) || seen.has(label)) continue;
-    units.push({ label, plistPath: join6(dir, `${label}.plist`), program: null, programExists: false, orphan: true });
+    units.push({ label, plistPath: join7(dir, `${label}.plist`), program: null, programExists: false, orphan: true });
   }
   return units;
 }
@@ -3007,9 +3330,9 @@ function removeLaunchdUnit(unit, dryRun, log) {
     log.emit(`would unload and remove ${unit.label}`);
     return;
   }
-  if (existsSync5(unit.plistPath)) spawnSync2("launchctl", ["unload", unit.plistPath], { encoding: "utf8" });
+  if (existsSync6(unit.plistPath)) spawnSync2("launchctl", ["unload", unit.plistPath], { encoding: "utf8" });
   spawnSync2("launchctl", ["remove", unit.label], { encoding: "utf8" });
-  if (existsSync5(unit.plistPath)) unlinkSync(unit.plistPath);
+  if (existsSync6(unit.plistPath)) unlinkSync(unit.plistPath);
   log.emit(`removed ${unit.label} (${unit.plistPath})`);
 }
 function clearForeignLaunchdUnits(crewHome, replace, dryRun, log, dir, loaded) {
@@ -3092,15 +3415,15 @@ import { statfsSync } from "fs";
 // src/git.ts
 import { execFileSync } from "child_process";
 import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync5,
   openSync as openSync2,
   closeSync as closeSync2,
   writeSync,
   statSync as statSync4,
   unlinkSync as unlinkSync2
 } from "fs";
-import { dirname as dirname4, basename as basename4 } from "path";
+import { dirname as dirname5, basename as basename4 } from "path";
 var GitError = class extends Error {
 };
 function gitRaw(cwd, args) {
@@ -3464,13 +3787,13 @@ function cloneUrlFor(remote) {
   return `git@github.com:${remote}.git`;
 }
 function ensureRepoCheckout(dir, remote) {
-  if (existsSync6(`${dir}/.git`)) return false;
+  if (existsSync7(`${dir}/.git`)) return false;
   if (!remote) {
     throw new GitError(
       `${dir} does not exist and this repo has no discovered remote to clone from \u2014 re-run \`crew connect\`, or check out the repository yourself and point \`repos:\` at it`
     );
   }
-  mkdirSync4(dirname4(dir), { recursive: true });
+  mkdirSync5(dirname5(dir), { recursive: true });
   try {
     execFileSync("git", ["clone", cloneUrlFor(remote), dir], { stdio: ["ignore", "pipe", "pipe"] });
   } catch (e) {
@@ -3489,7 +3812,7 @@ function sleepSync(ms2) {
 }
 function acquireCheckoutLock(dir, timeoutMs = 3e4) {
   const lockPath = checkoutLockPath(dir);
-  mkdirSync4(dirname4(lockPath), { recursive: true });
+  mkdirSync5(dirname5(lockPath), { recursive: true });
   const deadline = Date.now() + timeoutMs;
   for (; ; ) {
     try {
@@ -5201,8 +5524,8 @@ function materializeBranchForTicket(dir, cfg, t, role) {
 }
 
 // src/poll.ts
-import { writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
+import { writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
 
 // src/stalled.ts
 var STALLED_AFTER_CYCLES = 30;
@@ -5474,7 +5797,7 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route, role) => join7(stateDir, `digest-${route}-${role}.md`);
+var digestPath = (stateDir, route, role) => join8(stateDir, `digest-${route}-${role}.md`);
 function writeDigest(o, d, role, stateDir) {
   const me = o.route.resolved?.seats[role];
   if (!me) return false;
@@ -5536,7 +5859,7 @@ function writeDigest(o, d, role, stateDir) {
     };
     const text = role === "qa" ? qaDigest(input) : buildingDigest(input);
     const path = digestPath(stateDir, routeSlug(o.route.route), role);
-    writeFileSync3(path, text);
+    writeFileSync4(path, text);
     o.emit.emit(`queue digest written for ${role} (${Buffer.byteLength(text)} bytes)`, {
       data: { role, bytes: Buffer.byteLength(text) }
     });
@@ -5844,9 +6167,9 @@ var alreadyReported = (ticket, g, comments) => comments.some((c) => c.ticket_id
 
 // src/agent.ts
 import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync7, existsSync as existsSync7, statSync as statSync5, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, createWriteStream } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync8, statSync as statSync5, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5, createWriteStream } from "fs";
 import { finished } from "stream/promises";
-import { join as join8, dirname as dirname5 } from "path";
+import { join as join9, dirname as dirname6 } from "path";
 import { createHash as createHash2 } from "crypto";
 
 // src/environment.ts
@@ -6244,23 +6567,23 @@ var AgentError = class extends Error {
 var AgentSpawnError = class extends AgentError {
 };
 function planAgentRun(o) {
-  const briefPath = join8(o.route.promptsDir, "personas", `lane-${o.role}.md`);
-  if (!existsSync7(briefPath)) {
+  const briefPath = join9(o.route.promptsDir, "personas", `lane-${o.role}.md`);
+  if (!existsSync8(briefPath)) {
     throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
   }
-  const commonPath = join8(o.route.promptsDir, "personas", "common.md");
-  if (!existsSync7(commonPath)) throw new AgentError(`no shared policy at ${commonPath}`);
+  const commonPath = join9(o.route.promptsDir, "personas", "common.md");
+  if (!existsSync8(commonPath)) throw new AgentError(`no shared policy at ${commonPath}`);
   const now = o.now ?? (() => Date.now());
   const routeLabel = routeSlug(o.route.route);
-  const digestPath2 = join8(o.stateDir, `digest-${routeLabel}-${o.role}.md`);
+  const digestPath2 = join9(o.stateDir, `digest-${routeLabel}-${o.role}.md`);
   let digest;
   let ageSeconds;
-  if (existsSync7(digestPath2)) {
+  if (existsSync8(digestPath2)) {
     ageSeconds = Math.floor((now() - statSync5(digestPath2).mtimeMs) / 1e3);
-    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync7(digestPath2, "utf8");
+    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync8(digestPath2, "utf8");
   }
-  const common = readFileSync7(commonPath, "utf8");
-  const brief = readFileSync7(briefPath, "utf8");
+  const common = readFileSync8(commonPath, "utf8");
+  const brief = readFileSync8(briefPath, "utf8");
   const effectiveCommon = o.divergedPrompt ? "" : common;
   const effectiveBrief = o.divergedPrompt ?? brief;
   const prompt = assemblePrompt({
@@ -6271,7 +6594,7 @@ function planAgentRun(o) {
     digest
   });
   const promptSha = createHash2("sha256").update(`${effectiveCommon}${effectiveBrief}`).digest("hex");
-  const streamsDir = join8(o.stateDir, "streams");
+  const streamsDir = join9(o.stateDir, "streams");
   const base = `${routeLabel}-${o.role}-${o.cycle}`;
   const seat = resolveSeat(o.ship, o.route, o.role, o.agentPersona ?? (o.agentModel ? { model: o.agentModel } : {}));
   const { toolchain, model } = seat;
@@ -6326,8 +6649,8 @@ function planAgentRun(o) {
     digestAttached: digest !== void 0,
     digestAgeSeconds: ageSeconds,
     model,
-    streamPath: join8(streamsDir, `${base}.jsonl`),
-    eventsPath: join8(streamsDir, `${base}.events.jsonl`),
+    streamPath: join9(streamsDir, `${base}.jsonl`),
+    eventsPath: join9(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
     agentLog,
     promptVersion: o.route.resolved?.agentPersonas?.[o.role]?.historyId,
@@ -6354,7 +6677,7 @@ function describePlan(p) {
 }
 function openSink(path) {
   try {
-    mkdirSync5(dirname5(path), { recursive: true });
+    mkdirSync6(dirname6(path), { recursive: true });
     return createWriteStream(path, { flags: "a" });
   } catch {
     return void 0;
@@ -6463,7 +6786,7 @@ function spawnAgent(plan, emit) {
         provider: plan.provider ?? LEGACY_TOOLCHAIN_PROVIDER
       };
       try {
-        writeFileSync4(`${plan.streamPath}.meta.json`, JSON.stringify({
+        writeFileSync5(`${plan.streamPath}.meta.json`, JSON.stringify({
           route: plan.route,
           role: plan.role,
           ticket: plan.ticket ?? null,
@@ -6522,13 +6845,13 @@ function spawnAgent(plan, emit) {
 }
 
 // src/run-worktree.ts
-import { existsSync as existsSync9 } from "fs";
-import { dirname as dirname6, join as join10 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { dirname as dirname7, join as join11 } from "path";
 
 // src/ports.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join10 } from "path";
 var run = (cmd, args) => {
   try {
     return execFileSync2(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
@@ -6573,7 +6896,7 @@ function ticketForPort(port, s = DEFAULT_PORTS) {
 }
 function worktreeExists(parent, prefix, n) {
   for (const name of [`${prefix}${n}`, `${prefix}${String(n).padStart(3, "0")}`]) {
-    if (existsSync8(join9(parent, name, ".git"))) return true;
+    if (existsSync9(join10(parent, name, ".git"))) return true;
   }
   return false;
 }
@@ -6647,7 +6970,7 @@ function planRunWorktree(dir, cfg, t, role) {
   const existing = worktreeForNumber(dir, num);
   const located = locateBranchForTicket(dir, cfg, t, role);
   const baseRef = hasRemote ? `${remote}/${base}` : base;
-  if (existing && !existing.prunable && existsSync9(existing.path)) {
+  if (existing && !existing.prunable && existsSync10(existing.path)) {
     const branch = existing.branch;
     if (status(existing.path).length > 0) return { action: "leave-dirty", path: existing.path, branch };
     if (!branch) return { action: "leave-unpushed", path: existing.path, branch: "(detached HEAD)" };
@@ -6661,7 +6984,7 @@ function planRunWorktree(dir, cfg, t, role) {
     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 = join10(dirname6(dir), worktreeForTicket(dir, cfg, t, role));
+  const path = join11(dirname7(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 };
   }
@@ -6708,7 +7031,7 @@ function worktreeHoldsUnpushed(path, remote) {
 }
 async function finishRunWorktree(dir, cfg, branch) {
   const wt = worktrees(dir).find((w) => w.branch === branch && !w.prunable && w.path !== dir);
-  if (!wt || !existsSync9(wt.path)) return { kind: "none" };
+  if (!wt || !existsSync10(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)) {
@@ -6720,7 +7043,7 @@ async function finishRunWorktree(dir, cfg, branch) {
     if (pids.length) await killGently(pids);
   }
   gitOk(dir, ["worktree", "remove", wt.path]);
-  return existsSync9(wt.path) ? { kind: "kept-dirty", path: wt.path } : { kind: "removed", path: wt.path };
+  return existsSync10(wt.path) ? { kind: "kept-dirty", path: wt.path } : { kind: "removed", path: wt.path };
 }
 
 // src/handoff-guard.ts
@@ -6869,13 +7192,13 @@ async function retireRunWorktree(tracker, dir, cfg, t, role, seatId, shipName2,
 }
 
 // src/connect-wizard.ts
-import { delimiter, dirname as dirname7, join as join11 } from "path";
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync10, mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "fs";
+import { delimiter, dirname as dirname8, join as join12 } from "path";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync11, mkdirSync as mkdirSync7, writeFileSync as writeFileSync6 } from "fs";
 import { stringify } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
 function shouldRunWizard(opts) {
   if (!opts.isTTY) return false;
-  const exists = opts.configExists ?? existsSync10;
+  const exists = opts.configExists ?? existsSync11;
   return !configSearchPath(opts.crewHome).some((p) => exists(p));
 }
 function firstRunConfigPath() {
@@ -6892,7 +7215,7 @@ function defaultIsExecutable(p) {
 function findOnPath2(name, pathEnv, isExecutable = defaultIsExecutable) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join11(dir, name);
+    const candidate = join12(dir, name);
     if (isExecutable(candidate)) return candidate;
   }
   return void 0;
@@ -6918,9 +7241,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 = dirname7(env.nodePath);
+  const nodeDir = dirname8(env.nodePath);
   const pnpmPath = findOnPath2("pnpm", env.pathEnv, isExec);
-  const baseDirs = [nodeDir, pnpmPath ? dirname7(pnpmPath) : void 0];
+  const baseDirs = [nodeDir, pnpmPath ? dirname8(pnpmPath) : void 0];
   p.say(
     `
 Host Passengers lets this machine run the agent sessions that other people's
@@ -6931,7 +7254,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 ? dirname7(dockerPath) : void 0]);
+  const extraPath = deriveExtraPath([...baseDirs, dockerPath ? dirname8(dockerPath) : void 0]);
   if (extraPath) {
     p.say(`Hooks will get ${extraPath} on their PATH (where node, pnpm${dockerPath ? " and docker" : ""} live).`);
   }
@@ -6953,9 +7276,9 @@ routes:
 ${routeBlock}`;
 }
 function writeNewConfig(path, text) {
-  mkdirSync6(dirname7(path), { recursive: true });
+  mkdirSync7(dirname8(path), { recursive: true });
   try {
-    writeFileSync5(path, text, { mode: 384, flag: "wx" });
+    writeFileSync6(path, text, { mode: 384, flag: "wx" });
     return true;
   } catch (e) {
     if (e.code === "EEXIST") return false;
@@ -6987,8 +7310,8 @@ Wrote ${o.configPath}.
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync11, copyFileSync, mkdirSync as mkdirSync7, mkdtempSync, rmSync as rmSync3 } from "fs";
-import { dirname as dirname8, join as join12 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, existsSync as existsSync12, copyFileSync, mkdirSync as mkdirSync8, mkdtempSync, rmSync as rmSync4 } from "fs";
+import { dirname as dirname9, join as join13 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 
 // src/release.ts
@@ -7646,13 +7969,13 @@ async function bump(o, size) {
     }
     return printed;
   }
-  const files = o.repo.release.versionFiles.map((f) => join12(o.cwd, f));
+  const files = o.repo.release.versionFiles.map((f) => join13(o.cwd, f));
   const first = files[0];
-  if (!existsSync11(first)) {
+  if (!existsSync12(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
     return null;
   }
-  const current = JSON.parse(readFileSync8(first, "utf8")).version;
+  const current = JSON.parse(readFileSync9(first, "utf8")).version;
   if (!current) {
     o.emit.error(`no version field in ${o.repo.release.versionFiles[0]}`);
     return null;
@@ -7665,27 +7988,27 @@ async function bump(o, size) {
     return version;
   }
   for (const f of files) {
-    const src = readFileSync8(f, "utf8");
+    const src = readFileSync9(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;
     }
-    writeFileSync6(f, out);
+    writeFileSync7(f, out);
   }
   return version;
 }
 function writeChangelog(o, version, entries) {
   const file = o.repo.release.changelog;
   if (!file || entries.length === 0) return;
-  const path = join12(o.cwd, file);
+  const path = join13(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 = existsSync11(path) ? readFileSync8(path, "utf8") : "# Changelog\n";
-  writeFileSync6(path, insertChangelogSection(existing, section));
+  const existing = existsSync12(path) ? readFileSync9(path, "utf8") : "# Changelog\n";
+  writeFileSync7(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
   if (!o.repo.hooks.released) return void 0;
@@ -7766,11 +8089,11 @@ async function confirmLastRelease(o, decision) {
 function openReleaseCheckout(o) {
   const { remote, base } = o.repo.branch;
   const branch = `crew/release-${Date.now()}`;
-  const root = mkdtempSync(join12(tmpdir2(), "crew-release-"));
-  const dir = join12(root, "checkout");
+  const root = mkdtempSync(join13(tmpdir2(), "crew-release-"));
+  const dir = join13(root, "checkout");
   const close = () => {
     gitOk(o.cwd, ["worktree", "remove", "--force", dir]);
-    rmSync3(root, { recursive: true, force: true });
+    rmSync4(root, { recursive: true, force: true });
     gitOk(o.cwd, ["worktree", "prune"]);
     gitOk(o.cwd, ["branch", "-D", branch]);
   };
@@ -7781,10 +8104,10 @@ function openReleaseCheckout(o) {
     throw e;
   }
   for (const f of o.repo.worktrees.copy) {
-    const src = join12(o.cwd, f);
-    if (!existsSync11(src)) continue;
-    mkdirSync7(dirname8(join12(dir, f)), { recursive: true });
-    copyFileSync(src, join12(dir, f));
+    const src = join13(o.cwd, f);
+    if (!existsSync12(src)) continue;
+    mkdirSync8(dirname9(join13(dir, f)), { recursive: true });
+    copyFileSync(src, join13(dir, f));
   }
   return { dir, branch, close };
 }
@@ -8253,7 +8576,7 @@ function missingReleaserWarning(repo, release, ships, now = Date.now()) {
 }
 
 // src/watch.ts
-import { watch as watchFile, existsSync as existsSync12, statSync as statSync6, openSync as openSync3, readSync, closeSync as closeSync3 } from "fs";
+import { watch as watchFile, existsSync as existsSync13, statSync as statSync6, openSync as openSync3, readSync, closeSync as closeSync3 } from "fs";
 var E = "\x1B[";
 var dim = (s) => `${E}2m${s}${E}0m`;
 var bold = (s) => `${E}1m${s}${E}0m`;
@@ -8354,7 +8677,7 @@ function renderHeaders(states, now = Date.now()) {
   return states.map((s) => renderHeader(s, now)).join("");
 }
 function readFrom(file, from) {
-  if (!existsSync12(file)) return { events: [], offset: from };
+  if (!existsSync13(file)) return { events: [], offset: from };
   const size = statSync6(file).size;
   if (size < from) return readFrom(file, 0);
   if (size === from) return { events: [], offset: from };
@@ -8594,8 +8917,8 @@ function nextRoles(decision, ran) {
 }
 
 // src/agents.ts
-import { readFileSync as readFileSync9, existsSync as existsSync13 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync14 } from "fs";
+import { join as join14 } from "path";
 import { TablationClient as TablationClient2, StaleWriteError as StaleWriteError6, TablationApiError } from "@tablation/client";
 var PERSONA_NAME = {
   dev: "Developer",
@@ -8609,12 +8932,12 @@ var CREW_AGENT_COLUMN = "agent_id";
 var AgentsSyncError = class extends Error {
 };
 function personaDefaultPrompt(promptsDir, role) {
-  const briefPath = join13(promptsDir, "personas", `lane-${role}.md`);
-  if (!existsSync13(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
-  if (role === "pair") return readFileSync9(briefPath, "utf8");
-  const commonPath = join13(promptsDir, "personas", "common.md");
-  if (!existsSync13(commonPath)) throw new AgentsSyncError(`no shared policy at ${commonPath}`);
-  return `${readFileSync9(commonPath, "utf8")}${readFileSync9(briefPath, "utf8")}`;
+  const briefPath = join14(promptsDir, "personas", `lane-${role}.md`);
+  if (!existsSync14(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
+  if (role === "pair") return readFileSync10(briefPath, "utf8");
+  const commonPath = join14(promptsDir, "personas", "common.md");
+  if (!existsSync14(commonPath)) throw new AgentsSyncError(`no shared policy at ${commonPath}`);
+  return `${readFileSync10(commonPath, "utf8")}${readFileSync10(briefPath, "utf8")}`;
 }
 async function resolveAgentId(route, role, opts) {
   const cached = route.resolved?.agentPersonas?.[role]?.agentId;
@@ -9291,14 +9614,14 @@ import {
 } from "@tablation/client";
 
 // src/skills.ts
-import { readFileSync as readFileSync10, readdirSync as readdirSync2, existsSync as existsSync14 } from "fs";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync11, readdirSync as readdirSync2, existsSync as existsSync15 } from "fs";
+import { join as join15 } from "path";
 import { parse as parseYaml } from "yaml";
 import { TablationClient as TablationClient3, StaleWriteError as StaleWriteError7, TablationApiError as TablationApiError2 } from "@tablation/client";
 var SkillSyncError = class extends Error {
 };
 function parseSkillFile(path) {
-  const text = readFileSync10(path, "utf8");
+  const text = readFileSync11(path, "utf8");
   const match = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/.exec(text);
   if (!match) throw new SkillSyncError(`${path}: missing YAML frontmatter (expected a leading --- block)`);
   const frontmatter = match[1];
@@ -9311,9 +9634,9 @@ function parseSkillFile(path) {
   return { name: meta.name, description: meta.description, prompt: body, file: path };
 }
 function listLocalSkills(promptsDir) {
-  const dir = join14(promptsDir, "skills");
-  if (!existsSync14(dir)) return [];
-  return readdirSync2(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join14(dir, f)));
+  const dir = join15(promptsDir, "skills");
+  if (!existsSync15(dir)) return [];
+  return readdirSync2(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join15(dir, f)));
 }
 async function syncSkills(route, opts) {
   if (!route.resolved) {
@@ -9492,7 +9815,7 @@ async function showLogEntry(route, entryId, opts = {}) {
 }
 
 // src/repos-cmd.ts
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { basename as basename7, resolve as resolve3 } from "path";
 import { isMap, isSeq, parseDocument, stringify as stringify2 } from "yaml";
 var ReposError = class extends Error {
@@ -9539,7 +9862,7 @@ function parseAddArgs(args, routes, isDir) {
   return { route, path: "." };
 }
 function expandDir(p, base) {
-  const home = p === "~" ? homedir4() : p.startsWith("~/") ? `${homedir4()}/${p.slice(2)}` : p;
+  const home = p === "~" ? homedir5() : p.startsWith("~/") ? `${homedir5()}/${p.slice(2)}` : p;
   return resolve3(base, home);
 }
 function routeMapOf(doc, route) {
@@ -9674,7 +9997,7 @@ function schedulerInstalled(plan, exists, crontab) {
 }
 
 // src/worktree-sweep.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { basename as basename8 } from "path";
 function planWorktreeSweep(target, tickets, contract) {
   const terminal = new Set(contract.statuses.resolved.filter((s) => s !== contract.statuses.verified));
@@ -9702,7 +10025,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin")
   let removed = 0;
   let keptBranches = 0;
   for (const a of actions) {
-    if (!dryRun && existsSync15(a.path)) {
+    if (!dryRun && existsSync16(a.path)) {
       let dirty = false;
       try {
         dirty = status(a.path).length > 0;
@@ -9716,7 +10039,7 @@ async function applyWorktreeSweep(cwd, actions, dryRun, log, remote = "origin")
         continue;
       }
     }
-    if (!dryRun && a.requirePushed && a.branch && existsSync15(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
+    if (!dryRun && a.requirePushed && a.branch && existsSync16(a.path) && remoteConfigured(cwd, remote) && worktreeHoldsUnpushed(a.path, remote)) {
       log.warn(
         `not removing worktree ${a.path} for ${a.ticket.issue_id} (${a.ticket.status}): ${a.branch} has commits that are not on ${remote}`,
         { ticket: a.ticket.issue_id, step: "worktree" }
@@ -9797,14 +10120,14 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 }
 
 // src/stream-sweep.ts
-import { existsSync as existsSync16, readdirSync as readdirSync3, rmSync as rmSync4, statSync as statSync7 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync3, rmSync as rmSync5, statSync as statSync7 } from "fs";
+import { join as join16 } from "path";
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join15(stateDir, "streams");
-  if (!existsSync16(dir)) return [];
+  const dir = join16(stateDir, "streams");
+  if (!existsSync17(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync3(dir).map((name) => join15(dir, name)).filter((path) => {
+  return readdirSync3(dir).map((name) => join16(dir, name)).filter((path) => {
     try {
       return statSync7(path).mtimeMs < cutoff;
     } catch {
@@ -9820,7 +10143,7 @@ function applyStreamSweep(paths, dryRun, log) {
       continue;
     }
     try {
-      rmSync4(path, { force: true });
+      rmSync5(path, { force: true });
       removed++;
       log.emit(`removed stream artifact ${path}`, { step: "worktree" });
     } catch (e) {
@@ -9830,9 +10153,9 @@ function applyStreamSweep(paths, dryRun, log) {
   return removed;
 }
 function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
-  if (!existsSync16(stateDir)) return [];
+  if (!existsSync17(stateDir)) return [];
   const cutoff = now - retentionDays * DAY_MS2;
-  return readdirSync3(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join15(stateDir, name)).filter((path) => {
+  return readdirSync3(stateDir).filter((name) => ROTATED_EVENTS_RE.test(name)).map((name) => join16(stateDir, name)).filter((path) => {
     try {
       return statSync7(path).mtimeMs < cutoff;
     } catch {
@@ -9842,24 +10165,24 @@ function planEventsSweep(stateDir, retentionDays, now = Date.now()) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync14, existsSync as existsSync20, mkdirSync as mkdirSync11, writeFileSync as writeFileSync9, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync2, statSync as statSync9 } from "fs";
+import { readFileSync as readFileSync15, existsSync as existsSync21, mkdirSync as mkdirSync12, writeFileSync as writeFileSync10, unlinkSync as unlinkSync5, copyFileSync as copyFileSync2, renameSync as renameSync2, statSync as statSync9 } from "fs";
 import { createInterface } from "readline/promises";
 import { dirname as dirOf, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync11, chmodSync } from "fs";
-import { dirname as dirname10, join as join16 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync12, chmodSync } from "fs";
+import { dirname as dirname11, join as join17 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join16(stateDir, "ssh", "id_ed25519");
+  return join17(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
   const publicKeyPath = `${privateKeyPath}.pub`;
-  if (!existsSync17(privateKeyPath)) {
-    mkdirSync8(dirname10(privateKeyPath), { recursive: true });
+  if (!existsSync18(privateKeyPath)) {
+    mkdirSync9(dirname11(privateKeyPath), { recursive: true });
     try {
       execFileSync3("ssh-keygen", [
         "-t",
@@ -9879,10 +10202,10 @@ function ensureShipSshKeypair(stateDir) {
     }
     chmodSync(privateKeyPath, 384);
   }
-  if (!existsSync17(publicKeyPath)) {
+  if (!existsSync18(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync11(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync12(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -10096,9 +10419,9 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3, readdirSync as readdirSync4 } from "fs";
 import { randomInt } from "crypto";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn3(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -10165,21 +10488,21 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join17(stateDir, "passengers", `${workspaceId}.json`);
+  return join18(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
-  if (!existsSync18(path)) return void 0;
+  if (!existsSync19(path)) return void 0;
   try {
-    return JSON.parse(readFileSync12(path, "utf8"));
+    return JSON.parse(readFileSync13(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync9(join17(stateDir, "passengers"), { recursive: true });
-  writeFileSync7(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync10(join18(stateDir, "passengers"), { recursive: true });
+  writeFileSync8(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function updatePersistedTunnel(stateDir, workspaceId, patch2) {
@@ -10276,8 +10599,8 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join17(stateDir, "passengers");
-  if (!existsSync18(dir)) return [];
+  const dir = join18(stateDir, "passengers");
+  if (!existsSync19(dir)) return [];
   return readdirSync4(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
@@ -10398,8 +10721,8 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn4 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync8, unlinkSync as unlinkSync4, readdirSync as readdirSync5 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync9, unlinkSync as unlinkSync4, readdirSync as readdirSync5 } from "fs";
+import { join as join19 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -10488,21 +10811,21 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join18(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join19(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
-  if (!existsSync19(path)) return void 0;
+  if (!existsSync20(path)) return void 0;
   try {
-    return JSON.parse(readFileSync13(path, "utf8"));
+    return JSON.parse(readFileSync14(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync10(join18(stateDir, "passengers"), { recursive: true });
-  writeFileSync8(path, `${JSON.stringify(state, null, 2)}
+  mkdirSync11(join19(stateDir, "passengers"), { recursive: true });
+  writeFileSync9(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 function removePersistedSyncDaemon(stateDir, workspaceId) {
@@ -10522,8 +10845,8 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join18(stateDir, "passengers");
-  if (!existsSync19(dir)) return [];
+  const dir = join19(stateDir, "passengers");
+  if (!existsSync20(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync5(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
@@ -10581,7 +10904,7 @@ function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
 
 // src/daemon.ts
 import { readdirSync as readdirSync6, statSync as statSync8 } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
 var defaultSleep = (ms2) => new Promise((resolve5) => setTimeout(resolve5, ms2));
@@ -10620,7 +10943,7 @@ function latestMtime(path) {
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
   for (const entry of readdirSync6(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join19(path, entry.name)));
+    latest = Math.max(latest, latestMtime(join20(path, entry.name)));
   }
   return latest;
 }
@@ -10906,7 +11229,7 @@ async function buildEnvironment(route, ship, ticket) {
 }
 
 // src/cli.ts
-var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname11(process.execPath) : resolve4(dirname11(fileURLToPath(import.meta.url)), "..");
+var CREW_HOME = isCompiledBinary(import.meta.url) ? dirname12(process.execPath) : resolve4(dirname12(fileURLToPath(import.meta.url)), "..");
 var RELEASE_LOCK_TTL_MS = 20 * 60 * 1e3;
 var CYCLE_SECONDS2 = 120;
 var STALE_CYCLES = 3;
@@ -11040,8 +11363,9 @@ function usage() {
   crew log [route]               tail the log
   crew inbox [--member NAME]    your tickets across every workspace (or a colleague's)
   crew connect                  resolve a workspace's ids into a crew.yaml block (--no-mcp skips registering the Tablation MCP server with Claude Code; --mcp replace overwrites a different one)
+  crew disconnect               remove what connect installed for Pair (Claude MCP; Codex/Gemini instructions block and MCP entry per ship.pair)
   crew agents sync [route] [--force]   push crew's personas AND skill files into the workspace Agents/Agent Skills tables (--force overwrites even a diverged persona)
-  crew agents prompt R [route] print one persona's current prompt (e.g. R=pair, for a SessionStart hook)
+  crew agents prompt R [route] print one persona's current prompt (e.g. R=pair, for a SessionStart hook; --harness H adds which CLI it serves)
   crew skills sync [route]      push only crew's skill files (e.g. grill-me) into the workspace Agent Skills table
   crew repos add [ROUTE] [NAME] [PATH]  attach a local checkout to a route in crew.yaml (--dry-run previews)
   crew repos list ROUTE         the checkouts a route has, with the tracker's Repos row each matches
@@ -11080,7 +11404,7 @@ var value = (name) => {
 var positional = argv.filter((a, i) => !a.startsWith("--") && !argv[i - 1]?.startsWith("--"));
 var command = positional[0];
 if (!command) usage();
-var STATE_WRITING_COMMANDS = /* @__PURE__ */ new Set(["connect", "install", "uninstall", "release", "merge", "deploy"]);
+var STATE_WRITING_COMMANDS = /* @__PURE__ */ new Set(["connect", "disconnect", "install", "uninstall", "release", "merge", "deploy"]);
 var STATE_WRITING_SUBCOMMANDS = {
   agents: /* @__PURE__ */ new Set(["sync"]),
   skills: /* @__PURE__ */ new Set(["sync"])
@@ -11190,7 +11514,7 @@ if (command === "passenger-sync-daemon") {
   const releaseFleetWide = ["merge", "deploy", "release"].includes(command) && flag("fleet");
   const DAEMON_SUBCOMMANDS = /* @__PURE__ */ new Set(["start", "stop", "status", "restart"]);
   const named = command === "daemon" && DAEMON_SUBCOMMANDS.has(positional[1] ?? "") ? positional[2] : positional[1];
-  const fleetWide = command === "inbox" || command === "connect" || command === "agents" || command === "skills" || command === "logbook" || command === "repos" || command === "projects" || releaseFleetWide || command === "pause" || command === "resume" || FLEET_CAPABLE.has(command) && !named && cfg.routes.length > 1;
+  const fleetWide = command === "inbox" || command === "connect" || command === "disconnect" || command === "agents" || command === "skills" || command === "logbook" || command === "repos" || command === "projects" || releaseFleetWide || command === "pause" || command === "resume" || FLEET_CAPABLE.has(command) && !named && cfg.routes.length > 1;
   let route;
   try {
     route = fleetWide ? cfg.routes[0] : findRoute(cfg, named);
@@ -11396,8 +11720,8 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join20(homedir5(), ".config", "systemd", "user", `${label}.timer`);
-      if (existsSync20(staleTimer)) {
+      const staleTimer = join21(homedir6(), ".config", "systemd", "user", `${label}.timer`);
+      if (existsSync21(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
@@ -11423,7 +11747,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 (!existsSync20(r.dir)) problems.push(`repo ${r.name}: ${r.dir} is missing on disk`);
+      if (!existsSync21(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}`);
       problems.push(...validateEffective(r.config).map((p) => `repo ${r.name}: ${p}`));
     }
@@ -11441,7 +11765,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) => existsSync20(p);
+    const unitExists = (p) => existsSync21(p);
     const crontab = o.host === "linux" ? spawnSync3("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
     const schedulerAbsent = o.host !== "windows" ? !schedulerInstalled(planInstall(cfg.ship, CREW_HOME, o.host, detectSystemd(), "run"), unitExists, crontab) : true;
     const plan = planFix({ routes, schedulerAbsent, host: o.host });
@@ -11458,7 +11782,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;
-          writeFileSync9(cfg.configFile, planEnable(readFileSync14(cfg.configFile, "utf8"), a.route));
+          writeFileSync10(cfg.configFile, planEnable(readFileSync15(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -12355,7 +12679,7 @@ ${changed2.map((c) => `  - ${c}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join20(CREW_HOME, "src"), join20(CREW_HOME, "dist"), join20(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join21(CREW_HOME, "src"), join21(CREW_HOME, "dist"), join21(CREW_HOME, "bin")];
       const spawnBreaker = new SpawnBreaker();
       const stopReason = await runDaemonLoop({
         runPass: () => runOnePass({
@@ -12441,7 +12765,7 @@ ${changed2.map((c) => `  - ${c}
         }
         try {
           const prompt = await currentPersonaPrompt(promptTarget, role, { userAgent: cfg.ship.userAgent });
-          process.stdout.write(prompt);
+          process.stdout.write(prompt + (role === "pair" ? harnessPromptNote(value("harness")) : ""));
         } catch (e) {
           if (e instanceof AgentsSyncError) {
             process.stderr.write(`crew agents prompt: ${e.message}
@@ -12504,11 +12828,11 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync20(resolvedPath) ? JSON.parse(readFileSync14(resolvedPath, "utf8")) : {};
+        const raw = existsSync21(resolvedPath) ? JSON.parse(readFileSync15(resolvedPath, "utf8")) : {};
         raw.agentPersonas = personaResult.agentPersonas;
         raw.agentSkills = skillResult.agentSkills;
-        mkdirSync11(dirOf(resolvedPath), { recursive: true });
-        writeFileSync9(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        mkdirSync12(dirOf(resolvedPath), { recursive: true });
+        writeFileSync10(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (personaResult.outcomes.some((o) => o.action === "diverged") || skillResult.outcomes.some((o) => o.action === "diverged")) {
@@ -12553,10 +12877,10 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync20(resolvedPath) ? JSON.parse(readFileSync14(resolvedPath, "utf8")) : {};
+        const raw = existsSync21(resolvedPath) ? JSON.parse(readFileSync15(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
-        mkdirSync11(dirOf(resolvedPath), { recursive: true });
-        writeFileSync9(resolvedPath, `${JSON.stringify(raw, null, 2)}
+        mkdirSync12(dirOf(resolvedPath), { recursive: true });
+        writeFileSync10(resolvedPath, `${JSON.stringify(raw, null, 2)}
 `);
       }
       if (result.outcomes.some((o) => o.action === "diverged")) process.exitCode = 1;
@@ -12569,14 +12893,14 @@ ${changed2.map((c) => `  - ${c}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list") usage2();
-      const configText = readFileSync14(cfg.configFile, "utf8");
+      const configText = readFileSync15(cfg.configFile, "utf8");
       let routeName = positional[2];
       let addPath = ".";
       let addName;
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync20(resolvePath(p.replace(/^~(?=\/|$)/, homedir5()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync21(resolvePath(p.replace(/^~(?=\/|$)/, homedir6()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -12591,15 +12915,15 @@ ${changed2.map((c) => `  - ${c}
       }
       const resolvedFile = resolvedPathFor(cfg.ship.stateDir, routeName);
       let resolvedRemotes;
-      if (existsSync20(resolvedFile)) {
+      if (existsSync21(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync14(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync15(resolvedFile, "utf8"));
         } catch {
         }
       }
       const originOf = (dir) => gitOk(dir, ["remote", "get-url", "origin"]) ?? void 0;
       const text = configText;
-      const base = dirname11(cfg.configFile);
+      const base = dirname12(cfg.configFile);
       try {
         if (sub === "list") {
           const repos = configuredRepos(text, routeName, base);
@@ -12608,14 +12932,14 @@ ${changed2.map((c) => `  - ${c}
           for (const r of repos) {
             const origin2 = originOf(r.dir);
             const row = matchRepoName(origin2, resolvedRemotes);
-            const note = !existsSync20(r.dir) ? "missing on disk" : row ? `Repos row: ${row}` : `no Repos row matches ${normalizeRemote(origin2) ?? "this checkout (no origin remote)"}`;
+            const note = !existsSync21(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}
 `);
           }
           break;
         }
-        const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir5()));
-        const top = existsSync20(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
+        const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir6()));
+        const top = existsSync21(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({
@@ -12663,15 +12987,15 @@ ${changed2.map((c) => `  - ${c}
           const created = await rowTracker.createRepoRow(rowPayload);
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
-          if (existsSync20(resolvedFile)) {
-            const raw = JSON.parse(readFileSync14(resolvedFile, "utf8"));
+          if (existsSync21(resolvedFile)) {
+            const raw = JSON.parse(readFileSync15(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
-            writeFileSync9(resolvedFile, `${JSON.stringify(raw, null, 2)}
+            writeFileSync10(resolvedFile, `${JSON.stringify(raw, null, 2)}
 `);
           }
         }
-        writeFileSync9(cfg.configFile, plan.text);
+        writeFileSync10(cfg.configFile, plan.text);
         process.stdout.write(`added ${top} to ${routeName} as ${plan.mode === "dir" ? "dir" : `repos.${plan.name}`} in ${cfg.configFile}
 `);
       } catch (e) {
@@ -12910,10 +13234,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           operator = await pickOperator(found.holds);
         }
         let previous;
-        const hadPreviousFile = existsSync20(resolvedPath);
+        const hadPreviousFile = existsSync21(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync14(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync15(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -12974,10 +13298,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 {
-          mkdirSync11(dirname11(resolvedPath), { recursive: true });
+          mkdirSync12(dirname12(resolvedPath), { recursive: true });
           if (hadPreviousFile) copyFileSync2(resolvedPath, `${resolvedPath}.bak`);
           const tmpPath = `${resolvedPath}.tmp${process.pid}`;
-          writeFileSync9(tmpPath, `${JSON.stringify(resolved, null, 2)}
+          writeFileSync10(tmpPath, `${JSON.stringify(resolved, null, 2)}
 `);
           renameSync2(tmpPath, resolvedPath);
           process.stderr.write(`Resolved ids written to ${resolvedPath}
@@ -12991,8 +13315,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 {
-            mkdirSync11(dirname11(apiKeyFile), { recursive: true });
-            writeFileSync9(apiKeyFile, `${apiKeyVar}=${apiKey}
+            mkdirSync12(dirname12(apiKeyFile), { recursive: true });
+            writeFileSync10(apiKeyFile, `${apiKeyVar}=${apiKey}
 `, { mode: 384 });
             process.stderr.write(`API key written to ${apiKeyFile}
 `);
@@ -13001,7 +13325,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         const keyPersisted = keychainBacked || apiKeyFile !== void 0;
         const wizard = firstRun;
         const writeFirstRun = wizard !== void 0 && !dryRun && keyPersisted;
-        const routeDir = value("dir") ?? (writeFirstRun ? join20(DEFAULT_REPOS_BASE_PATH, found.workspaceSlug) : void 0);
+        const routeDir = value("dir") ?? (writeFirstRun ? join21(DEFAULT_REPOS_BASE_PATH, found.workspaceSlug) : void 0);
         const routeBlock = renderConnection(
           found,
           route2,
@@ -13029,6 +13353,10 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             if (seen.has(id)) continue;
             seen.add(id);
             process.stderr.write(`${adapterFor(tc.harness).ensureMcp({ bin: tc.bin, url: mcpUrlFor(baseUrl), key: apiKey, replace, dryRun })}
+`);
+          }
+          for (const h of shipPair(cfg.ship).filter((x) => x !== "claude")) {
+            process.stderr.write(`${pairInstallerFor(h).installPair({ url: mcpUrlFor(baseUrl), replace, dryRun })}
 `);
           }
         }
@@ -13482,6 +13810,14 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
 `);
       break;
     }
+    case "disconnect": {
+      const url = mcpUrlFor(value("base-url") ?? cfg.routes[0]?.baseUrl ?? DEFAULT_BASE_URL);
+      for (const h of shipPair(cfg.ship)) {
+        process.stderr.write(`${pairInstallerFor(h).removePair({ url, bin: cfg.ship.agent.bin, dryRun })}
+`);
+      }
+      break;
+    }
     case "install": {
       if (!await installScheduler({ replace: flag("replace") })) process.exit(2);
       break;
@@ -13521,7 +13857,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
     }
     case "log": {
       try {
-        const text = readFileSync14(cfg.ship.logFile, "utf8").split("\n");
+        const text = readFileSync15(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -13729,7 +14065,7 @@ routes:            ${cfg.routes.map((c) => c.route).join(", ")}
       );
       try {
         const evFile = eventFileFor(cfg.ship.stateDir);
-        const evSize = existsSync20(evFile) ? statSync9(evFile).size : 0;
+        const evSize = existsSync21(evFile) ? statSync9(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"
@@ -13889,6 +14225,13 @@ crew manifest:     ${seats2.length ? seats2.map((c) => c.name).join(", ") : "non
           );
         }
       }
+      for (const h of shipPair(cfg.ship).filter((x) => x !== "claude")) {
+        const inst = pairInstallerFor(h);
+        const v = inst.verifyPair({ url: mcpUrlFor(route.baseUrl) });
+        process.stdout.write(`pair ${h}:`.padEnd(19) + (v.ok ? ` installed (${v.detail})
+` : ` NOT installed \u2014 ${v.detail}; run crew connect
+`));
+      }
       const shipVendors = new Set(shipToolchains(cfg.ship).map(toolchainVendor));
       if (route.apiKey && route.resolved) {
         let flagged = 0;