@tablation/crew 0.32.0 → 0.34.0

package/crew.example.yaml

@@ -29,8 +29,7 @@ ship:
 
   # Optional (CREW-1511): named toolchains — a harness adapter plus the binary
   # and model to run it with. The `agent:` block above keeps working and
-  # defines an implicit toolchain named `claude`. Only the `claude` harness
-  # exists today. See docs/toolchains.md.
+  # defines an implicit toolchain named `claude`. Harnesses: claude, gemini. See docs/toolchains.md.
   # toolchain: claude              # the ship's default; a route may override it
   # toolchains:
   #   claude-wrapped:
@@ -42,6 +41,7 @@ ship:
   #       deep: { model: claude-opus-5-5 }
   #     args: []                   # appended to the harness argv
   #     env: {}                    # added to the session environment
+  #   gemini: { harness: gemini, bin: gemini, model: gemini-2.5-pro }
 
   # shell: bash                      # defaults per platform
   extraPath: "/opt/homebrew/bin"     # prepended for hooks

package/dist/cli.js

@@ -4,7 +4,7 @@
 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 homedir6 } from "os";
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 
 // src/config.ts
 import { readFileSync as readFileSync5, existsSync as existsSync4 } from "fs";
@@ -159,6 +159,7 @@ var eventFileFor = (stateDir) => join(stateDir, "events.jsonl");
 
 // src/pair-install.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync2, writeFileSync } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join3 } from "path";
 
@@ -615,6 +616,28 @@ function geminiMcpState(s, 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" };
 }
+function inspectGeminiMcp(o) {
+  const p = geminiPaths(o.home ?? homedir2());
+  const settings = readGeminiSettings(p.config);
+  if (!settings) return { state: "different", detail: `${p.config} is not a JSON object` };
+  const st = geminiMcpState(settings, o.url);
+  return st.state === "registered" ? { state: "registered", url: o.url } : st;
+}
+function ensureGeminiMcp(o) {
+  const p = geminiPaths(o.home ?? homedir2());
+  const settings = readGeminiSettings(p.config);
+  if (!settings) return `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 === "registered") return `gemini: ${SERVER} MCP server already registered in ${p.config}`;
+  if (st.state === "different" && !o.replace) {
+    return `gemini: left ${p.config} alone \u2014 a "${SERVER}" server exists and ${st.detail}. Re-run with --mcp replace to overwrite it.`;
+  }
+  if (!o.dryRun) {
+    writeFileMkdir(p.config, `${JSON.stringify({ ...settings, mcpServers: { ...settings.mcpServers, [SERVER]: geminiEntry(o.url) } }, null, 2)}
+`);
+  }
+  return `gemini: ${o.dryRun ? "(dry run) would register" : "registered"} ${SERVER} in ${p.config} (key read from $${PAIR_KEY_VAR})`;
+}
 var geminiPair = {
   harness: "gemini",
   displayName: "Gemini CLI",
@@ -668,10 +691,144 @@ var geminiPair = {
     return hadBlock || hadMcp ? `pair(gemini): ${o.dryRun ? "(dry run) would remove" : "removed"} ${what}${kept}` : `pair(gemini): nothing to remove${kept}`;
   }
 };
+var VSCODE_FLAVOURS = ["Code", "Code - Insiders"];
+function vscodeUserDirs(o) {
+  const home = o.home ?? homedir2();
+  const platform2 = o.platform ?? process.platform;
+  const root = platform2 === "darwin" ? join3(home, "Library", "Application Support") : platform2 === "win32" ? process.env.APPDATA ?? join3(home, "AppData", "Roaming") : join3(home, ".config");
+  const all = VSCODE_FLAVOURS.map((f) => join3(root, f, "User"));
+  const present = all.filter((d) => existsSync2(d));
+  return present.length > 0 ? present : [all[0]];
+}
+var COPILOT_FRONTMATTER = '---\napplyTo: "**"\n---\n\n';
+function readVscodeMcp(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 COPILOT_AUTH = `Bearer \${env:${PAIR_KEY_VAR}}`;
+var copilotEntry = (url) => ({ type: "http", url, headers: { Authorization: COPILOT_AUTH } });
+function copilotMcpState(s, url) {
+  const e = s.servers?.[SERVER];
+  if (!e) return { state: "missing" };
+  if (e.url !== url) return { state: "different", detail: `it points at ${e.url ?? "(no url)"}, not ${url}` };
+  if (e.headers?.Authorization !== COPILOT_AUTH) return { state: "different", detail: `it does not read its key from \${env:${PAIR_KEY_VAR}}` };
+  return { state: "registered" };
+}
+function installCopilotInstructions(path, dryRun) {
+  const before = readIfExists(path);
+  const base = before ?? COPILOT_FRONTMATTER;
+  if (pairBlockIsBroken(base)) return { changed: false, error: `${path} has an unmatched ${PAIR_BLOCK_START}/${PAIR_BLOCK_END} marker \u2014 fix it by hand` };
+  const after = upsertPairBlock(base, pairBlock("copilot"));
+  if (after === before) return { changed: false };
+  if (!dryRun) writeFileMkdir(path, after);
+  return { changed: true };
+}
+function removeCopilotInstructions(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() === "" || after.trim() === COPILOT_FRONTMATTER.trim()) rmSync2(path);
+  else writeFileSync(path, after);
+  return true;
+}
+var copilotPair = {
+  harness: "copilot",
+  displayName: "GitHub Copilot (VS Code)",
+  installPair(o) {
+    const lines = [];
+    for (const dir of vscodeUserDirs(o)) {
+      const mcpPath = join3(dir, "mcp.json");
+      const instrPath = join3(dir, "prompts", "crew-pair.instructions.md");
+      const settings = readVscodeMcp(mcpPath);
+      if (!settings) {
+        lines.push(`pair(copilot): ${mcpPath} is not a plain JSON object (comments are not supported) \u2014 fix it by hand; nothing was written there`);
+        continue;
+      }
+      const st = copilotMcpState(settings, o.url);
+      if (st.state === "different" && !o.replace) {
+        lines.push(`pair(copilot): left ${mcpPath} alone \u2014 a "${SERVER}" server exists and ${st.detail}. Re-run with --mcp replace to overwrite it.`);
+        continue;
+      }
+      const instr = installCopilotInstructions(instrPath, o.dryRun);
+      if (instr.error) {
+        lines.push(`pair(copilot): ${instr.error}`);
+        continue;
+      }
+      const mcpChanged = st.state !== "registered";
+      if (mcpChanged && !o.dryRun) {
+        const next = { ...settings, servers: { ...settings.servers, [SERVER]: copilotEntry(o.url) } };
+        writeFileMkdir(mcpPath, `${JSON.stringify(next, null, 2)}
+`);
+      }
+      lines.push(!instr.changed && !mcpChanged ? `pair(copilot): already installed (${instrPath}, ${mcpPath})` : `pair(copilot): ${o.dryRun ? "(dry run) would install" : "installed"} the Pair instructions in ${instrPath} and ${SERVER} in ${mcpPath} (key read from \${env:${PAIR_KEY_VAR}})`);
+    }
+    return lines.join("\n");
+  },
+  verifyPair(o) {
+    const verdicts = vscodeUserDirs(o).map((dir) => {
+      const instrPath = join3(dir, "prompts", "crew-pair.instructions.md");
+      const mcpPath = join3(dir, "mcp.json");
+      const b = blockVerdict(instrPath, "copilot");
+      if (!b.ok) return b;
+      const settings = readVscodeMcp(mcpPath);
+      if (!settings) return { ok: false, detail: `${mcpPath} is not a plain JSON object` };
+      const st = copilotMcpState(settings, o.url);
+      if (st.state === "missing") return { ok: false, detail: `no ${SERVER} server in ${mcpPath}` };
+      if (st.state === "different") return { ok: false, detail: `${SERVER} in ${mcpPath} ${st.detail}` };
+      return { ok: true, detail: `${instrPath}, ${mcpPath}` };
+    });
+    return verdicts.find((v) => !v.ok) ?? { ok: true, detail: verdicts.map((v) => v.detail).join("; ") };
+  },
+  removePair(o) {
+    const lines = [];
+    for (const dir of vscodeUserDirs(o)) {
+      const mcpPath = join3(dir, "mcp.json");
+      const hadBlock = removeCopilotInstructions(join3(dir, "prompts", "crew-pair.instructions.md"), o.dryRun);
+      const settings = readVscodeMcp(mcpPath);
+      const st = settings ? copilotMcpState(settings, o.url) : { state: "missing" };
+      const hadMcp = st.state === "registered";
+      const kept = st.state === "different" ? `; left the existing ${SERVER} server alone \u2014 ${st.detail}` : "";
+      if (hadMcp && settings && !o.dryRun) {
+        const { [SERVER]: _gone, ...rest } = settings.servers ?? {};
+        const next = { ...settings };
+        if (Object.keys(rest).length > 0) next.servers = rest;
+        else delete next.servers;
+        if (Object.keys(next).length === 0) rmSync2(mcpPath);
+        else writeFileSync(mcpPath, `${JSON.stringify(next, null, 2)}
+`);
+      }
+      const what = hadBlock && hadMcp ? `the Pair instructions and ${SERVER} server` : hadBlock ? "the Pair instructions" : `the ${SERVER} server`;
+      lines.push(hadBlock || hadMcp ? `pair(copilot): ${o.dryRun ? "(dry run) would remove" : "removed"} ${what} (${dir})${kept}` : `pair(copilot): nothing to remove in ${dir}${kept}`);
+    }
+    return lines.join("\n");
+  },
+  /**
+   * VS Code launched from the Dock or Spotlight does not inherit a shell's
+   * exports, so `${env:CREW_API_KEY}` expands to nothing there. macOS only: the
+   * login environment is `launchctl`'s, and it is the one place we can ask.
+   */
+  envWarning(o) {
+    if ((o.platform ?? process.platform) !== "darwin") return void 0;
+    const get2 = o.loginEnv ?? ((name) => {
+      const r = spawnSync2("launchctl", ["getenv", name], { encoding: "utf8" });
+      return r.status === 0 ? r.stdout.trim() : void 0;
+    });
+    if (get2(PAIR_KEY_VAR)) return void 0;
+    return `$${PAIR_KEY_VAR} is not in the login environment, so VS Code started from the Dock will not send the tracker key. Launch VS Code from a terminal (\`code .\`), or run \`launchctl setenv ${PAIR_KEY_VAR} <key>\` once per login.`;
+  }
+};
 var PAIR_INSTALLERS = {
   [claudePair.harness]: claudePair,
   [codexPair.harness]: codexPair,
-  [geminiPair.harness]: geminiPair
+  [geminiPair.harness]: geminiPair,
+  [copilotPair.harness]: copilotPair
 };
 var PAIR_HARNESS_NAMES = Object.keys(PAIR_INSTALLERS);
 var DEFAULT_PAIR = ["claude"];
@@ -693,9 +850,120 @@ function harnessPromptNote(harness) {
 
 // src/toolchain.ts
 import { basename } from "path";
+
+// src/adapters/gemini.ts
+var BILLING_VARS_TO_UNSET2 = [
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "GOOGLE_GENAI_USE_VERTEXAI",
+  "GOOGLE_GENAI_USE_GCA",
+  "GOOGLE_CLOUD_PROJECT",
+  "GOOGLE_CLOUD_PROJECT_ID",
+  "GOOGLE_CLOUD_LOCATION",
+  "GOOGLE_APPLICATION_CREDENTIALS",
+  "GOOGLE_GEMINI_BASE_URL",
+  "GEMINI_MODEL"
+];
+var READ_TOOLS = ["read_file", "read_many_files", "list_directory", "glob", "search_file_content"];
+function geminiGrantFor(p) {
+  if (p.level === "read") return { approvalMode: "default", allowed: [...READ_TOOLS, "run_shell_command"] };
+  if (p.level === "write") return { approvalMode: "default", allowed: [...READ_TOOLS, "run_shell_command", "write_file"] };
+  return { approvalMode: "yolo", allowed: [] };
+}
+function geminiGrantArgs(role) {
+  const g = geminiGrantFor(profileFor(role));
+  return ["--approval-mode", g.approvalMode, ...g.allowed.length ? ["--allowed-tools", g.allowed.join(",")] : []];
+}
+function mapGeminiLine(line) {
+  const obj = line;
+  if (!obj || typeof obj !== "object") return [];
+  if (obj.type === "message" && obj.role === "assistant" && obj.content) return [{ kind: "text", text: obj.content }];
+  if (obj.type === "tool_use") return [{ kind: "tool", tool: obj.tool_name, target: toolTarget(obj.tool_name === "run_shell_command" ? "Bash" : obj.tool_name, obj.parameters) }];
+  return [];
+}
+function createGeminiStreamMapper() {
+  let pending = "";
+  const flush = () => {
+    const text = pending;
+    pending = "";
+    return text ? [{ kind: "text", text }] : [];
+  };
+  return {
+    flush,
+    map(line) {
+      const obj = line;
+      if (obj && typeof obj === "object" && obj.type === "message" && obj.role === "assistant") {
+        if (obj.content) pending += obj.content;
+        return [];
+      }
+      return [...flush(), ...mapGeminiLine(line)];
+    }
+  };
+}
+function extractGeminiResult(line) {
+  const obj = line;
+  if (obj?.type === "init") return obj.session_id ? { sessionId: obj.session_id } : void 0;
+  if (!obj || obj.type !== "result") return void 0;
+  const s = obj.stats;
+  return {
+    inputTokens: s?.input_tokens,
+    outputTokens: s?.output_tokens,
+    cacheReadTokens: s?.cached
+  };
+}
+var geminiAdapter = {
+  harness: "gemini",
+  displayName: "Gemini CLI",
+  vendor: "google",
+  ownsModel: (model) => model.startsWith("gemini-"),
+  // Gemini CLI has no per-run reasoning knob, so a tier's `reasoning` is ignored.
+  defaultBin: "gemini",
+  defaultModel: "gemini-2.5-pro",
+  defaultTiers: {
+    light: { model: "gemini-2.5-flash" },
+    standard: { model: "gemini-2.5-pro" },
+    deep: { model: "gemini-2.5-pro" }
+  },
+  limitations: [
+    "the tool grant is an allow list of tools that skip confirmation, not a sandbox: run_shell_command is allowed in every profile and sub-commands cannot be restricted",
+    "there is no deny list: destructive shell patterns (rm -rf, forced pushes, curl | sh) are not refused at the tool layer, unlike the Claude adapter",
+    "the edit profile runs in yolo mode (auto-approves every tool); the write profile (QA) withholds replace, not shell writes",
+    "design tools (skills, design canvas) are unavailable on this harness",
+    "the tracker MCP server is read from ~/.gemini/settings.json (there is no per-run --mcp-config), and MCP tool calls in the read and write profiles are not on the allow list",
+    "the stream carries no thinking blocks and streams assistant text in fragments, so the runner coalesces fragments into one Agent Log cycle per assistant turn; no turn count or cost is reported"
+  ],
+  invocation(spec, o) {
+    const args = [
+      // The prompt arrives on stdin; `-p` puts the CLI in non-interactive mode.
+      "-p",
+      "",
+      "--model",
+      o.model,
+      "--output-format",
+      "stream-json",
+      ...geminiGrantArgs(o.role),
+      ...spec.args
+    ];
+    return spec.launcher ? { bin: spec.launcherBin ?? spec.launcher, args: [spec.bin, ...args] } : { bin: spec.bin, args };
+  },
+  runEnv: (spec) => ({ ...spec.env }),
+  provider: () => "google",
+  unsetEnv: BILLING_VARS_TO_UNSET2,
+  mapStreamLine: mapGeminiLine,
+  createStreamMapper: createGeminiStreamMapper,
+  extractResult: extractGeminiResult,
+  extractTurnTokens: () => void 0,
+  inspectMcp(o) {
+    return inspectGeminiMcp(o);
+  },
+  ensureMcp: (o) => ensureGeminiMcp(o)
+};
+
+// src/toolchain.ts
 var TIERS = ["light", "standard", "deep"];
 var ADAPTERS = {
-  [claudeAdapter.harness]: claudeAdapter
+  [claudeAdapter.harness]: claudeAdapter,
+  [geminiAdapter.harness]: geminiAdapter
 };
 var HARNESS_NAMES = Object.keys(ADAPTERS);
 function isHarness(name) {
@@ -2908,7 +3176,7 @@ function describeRelease(o, route) {
 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 { spawnSync as spawnSync3 } from "child_process";
 import { createHash } from "crypto";
 
 // src/runtime-info.ts
@@ -3199,7 +3467,7 @@ function planDaemonControl(crewHome, hostShip, hasSystemd) {
 }
 function runAll(commands, cwd, log) {
   for (const [bin, ...args] of commands) {
-    const res = spawnSync2(bin, args, { cwd, encoding: "utf8" });
+    const res = spawnSync3(bin, args, { cwd, encoding: "utf8" });
     if (res.error || res.status !== 0) {
       log.warn(`${bin} ${args.join(" ")} exited ${res.status ?? "error"}`, {
         output: `${res.stdout ?? ""}${res.stderr ?? ""}${res.error ? String(res.error) : ""}`
@@ -3264,7 +3532,7 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
     if (dryRun) {
       log.emit(`would run: launchctl remove ${plan.removeLabel}`);
     } else {
-      if (spawnSync2("launchctl", ["remove", plan.removeLabel], { encoding: "utf8" }).status === 0) {
+      if (spawnSync3("launchctl", ["remove", plan.removeLabel], { encoding: "utf8" }).status === 0) {
         log.emit(`removed loaded job ${plan.removeLabel}`);
       }
     }
@@ -3301,7 +3569,7 @@ function programFromPlist(text) {
   return args.find((a) => a.endsWith("/bin/crew")) ?? args[0] ?? null;
 }
 function loadedCrewLabels() {
-  const list = spawnSync2("launchctl", ["list"], { encoding: "utf8" });
+  const list = spawnSync3("launchctl", ["list"], { encoding: "utf8" });
   if (list.status !== 0) return [];
   return [...parseLaunchctlList(list.stdout ?? "").keys()].filter((l) => l.startsWith(CREW_LAUNCHD_PREFIX));
 }
@@ -3337,8 +3605,8 @@ function removeLaunchdUnit(unit, dryRun, log) {
     log.emit(`would unload and remove ${unit.label}`);
     return;
   }
-  if (existsSync6(unit.plistPath)) spawnSync2("launchctl", ["unload", unit.plistPath], { encoding: "utf8" });
-  spawnSync2("launchctl", ["remove", unit.label], { encoding: "utf8" });
+  if (existsSync6(unit.plistPath)) spawnSync3("launchctl", ["unload", unit.plistPath], { encoding: "utf8" });
+  spawnSync3("launchctl", ["remove", unit.label], { encoding: "utf8" });
   if (existsSync6(unit.plistPath)) unlinkSync(unit.plistPath);
   log.emit(`removed ${unit.label} (${unit.plistPath})`);
 }
@@ -3371,7 +3639,7 @@ function parseLaunchctlList(text) {
   return jobs;
 }
 function describeForeignLaunchdUnits(crewHome, dir) {
-  const list = spawnSync2("launchctl", ["list"], { encoding: "utf8" });
+  const list = spawnSync3("launchctl", ["list"], { encoding: "utf8" });
   const jobs = parseLaunchctlList(list.status === 0 ? list.stdout ?? "" : "");
   const foreign = foreignLaunchdUnits(crewHome, dir, jobs.keys());
   return foreign.map((u) => {
@@ -3384,11 +3652,11 @@ function describeForeignLaunchdUnits(crewHome, dir) {
   });
 }
 function readCrontab() {
-  const res = spawnSync2("crontab", ["-l"], { encoding: "utf8" });
+  const res = spawnSync3("crontab", ["-l"], { encoding: "utf8" });
   return res.status === 0 ? res.stdout ?? "" : "";
 }
 function writeCrontab(text) {
-  spawnSync2("crontab", ["-"], { input: text, encoding: "utf8" });
+  spawnSync3("crontab", ["-"], { input: text, encoding: "utf8" });
 }
 function addCrontabLine(marker, line) {
   const existing = readCrontab();
@@ -3412,7 +3680,7 @@ function removeCrontabLine(marker) {
 }
 function detectSystemd() {
   if (process.platform !== "linux") return false;
-  const res = spawnSync2("systemctl", ["--user", "status"], { encoding: "utf8" });
+  const res = spawnSync3("systemctl", ["--user", "status"], { encoding: "utf8" });
   return !res.error;
 }
 
@@ -6712,6 +6980,7 @@ function spawnAgent(plan, emit) {
     let result;
     const cycles = [];
     const attribution = new TicketAttributionTracker();
+    const mapper = adapter.createStreamMapper?.() ?? { map: (p) => adapter.mapStreamLine(p), flush: () => [] };
     const handleLine = (line) => {
       if (!line) return;
       try {
@@ -6726,9 +6995,16 @@ function spawnAgent(plan, emit) {
         return;
       }
       try {
-        result = adapter.extractResult(parsed) ?? result;
+        const extracted = adapter.extractResult(parsed);
+        if (extracted) result = { ...result, ...extracted };
+        consume(parsed, mapper.map(parsed));
+      } catch {
+      }
+    };
+    const consume = (parsed, events) => {
+      {
         let turnText = "";
-        for (const ev of adapter.mapStreamLine(parsed)) {
+        for (const ev of events) {
           const e = {
             at: (/* @__PURE__ */ new Date()).toISOString(),
             cycle: emit.cycle,
@@ -6766,9 +7042,8 @@ function spawnAgent(plan, emit) {
 `);
           }
         }
-        const turnTokens = adapter.extractTurnTokens(parsed);
+        const turnTokens = parsed === void 0 ? void 0 : adapter.extractTurnTokens(parsed);
         if (turnTokens !== void 0) attribution.add(turnText, turnTokens);
-      } catch {
       }
     };
     child.stdout.on("data", (chunk) => {
@@ -6784,6 +7059,10 @@ function spawnAgent(plan, emit) {
     });
     child.on("close", async (code) => {
       if (buf) handleLine(buf);
+      try {
+        consume(void 0, mapper.flush());
+      } catch {
+      }
       await Promise.all([endSink(rawSink), endSink(eventsSink)]);
       if (spawnFailed) return;
       const attributedTicket = attribution.winner(plan.ticket);
@@ -11734,7 +12013,7 @@ if (command === "passenger-sync-daemon") {
 `
         );
         if (!dryRun) {
-          spawnSync3("systemctl", ["--user", "disable", "--now", `${label}.timer`], { cwd: CREW_HOME });
+          spawnSync4("systemctl", ["--user", "disable", "--now", `${label}.timer`], { cwd: CREW_HOME });
           try {
             unlinkSync5(staleTimer);
           } catch {
@@ -11773,7 +12052,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) => existsSync21(p);
-    const crontab = o.host === "linux" ? spawnSync3("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
+    const crontab = o.host === "linux" ? spawnSync4("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 });
     for (const n of plan.notes) process.stdout.write(`fix: ${n}
@@ -12645,7 +12924,7 @@ ${changed2.map((c) => `  - ${c}
           }
           let failed = false;
           for (const cmd2 of commands) {
-            const res2 = spawnSync3(cmd2[0], cmd2.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
+            const res2 = spawnSync4(cmd2[0], cmd2.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
             if (res2.stdout) process.stdout.write(res2.stdout);
             if (res2.stderr) process.stderr.write(res2.stderr);
             if (cmd2 === control.startCommand && (res2.error || res2.status !== 0)) {
@@ -12663,7 +12942,7 @@ ${changed2.map((c) => `  - ${c}
 `);
           break;
         }
-        const res = spawnSync3(cmd[0], cmd.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
+        const res = spawnSync4(cmd[0], cmd.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
         if (res.stdout) process.stdout.write(res.stdout);
         if (res.stderr) process.stderr.write(res.stderr);
         if (daemonSub !== "status" && (res.error || res.status !== 0)) {
@@ -14242,6 +14521,9 @@ crew manifest:     ${seats2.length ? seats2.map((c) => c.name).join(", ") : "non
         process.stdout.write(`pair ${h}:`.padEnd(19) + (v.ok ? ` installed (${v.detail})
 ` : ` NOT installed \u2014 ${v.detail}; run crew connect
 `));
+        const envWarn = inst.envWarning?.({ url: mcpUrlFor(route.baseUrl) });
+        if (envWarn) process.stdout.write(`pair ${h} env:`.padEnd(19) + ` WARN \u2014 ${envWarn}
+`);
       }
       const shipVendors = new Set(shipToolchains(cfg.ship).map(toolchainVendor));
       if (route.apiKey && route.resolved) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",