@tablation/crew 0.27.0 → 0.28.0

package/dist/cli.js

@@ -7,9 +7,9 @@ import { hostname as hostname2, homedir as homedir5 } from "os";
 import { spawnSync as spawnSync3 } from "child_process";
 
 // src/config.ts
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
-import { resolve, dirname as dirname2, isAbsolute, join as join3, basename as basename2 } from "path";
-import { homedir, tmpdir } from "os";
+import { readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
+import { resolve, dirname as dirname2, isAbsolute, join as join4, basename as basename2 } from "path";
+import { homedir as homedir2, tmpdir } from "os";
 import { parse as parse2 } from "yaml";
 
 // src/events.ts
@@ -157,6 +157,261 @@ var Emitter = class _Emitter {
 };
 var eventFileFor = (stateDir) => join(stateDir, "events.jsonl");
 
+// src/stream.ts
+function toolTarget(name, input) {
+  if (!input) return void 0;
+  for (const key of ["file_path", "path", "notebook_path", "url", "pattern"]) {
+    const v = input[key];
+    if (typeof v === "string" && v) return v;
+  }
+  if (name === "Bash" && typeof input.command === "string") {
+    return input.command.trim().split(/\s+/)[0];
+  }
+  return void 0;
+}
+function mapStreamLine(line) {
+  const obj = line;
+  if (!obj || obj.type !== "assistant") return [];
+  const content = obj.message?.content;
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const block of content) {
+    if (block.type === "thinking") out.push({ kind: "thought", text: block.thinking });
+    else if (block.type === "text") out.push({ kind: "text", text: block.text });
+    else if (block.type === "tool_use") {
+      out.push({ kind: "tool", tool: block.name, target: toolTarget(block.name, block.input) });
+    }
+  }
+  return out;
+}
+function extractTurnTokens(line) {
+  const obj = line;
+  if (!obj || obj.type !== "assistant") return void 0;
+  const usage2 = obj.message?.usage;
+  if (!usage2) return void 0;
+  return (usage2.input_tokens ?? 0) + (usage2.output_tokens ?? 0) + (usage2.cache_read_input_tokens ?? 0) + (usage2.cache_creation_input_tokens ?? 0);
+}
+function extractResult(line) {
+  const obj = line;
+  if (!obj || obj.type !== "result") return void 0;
+  return {
+    sessionId: obj.session_id,
+    numTurns: obj.num_turns,
+    totalCostUsd: obj.total_cost_usd,
+    inputTokens: obj.usage?.input_tokens,
+    outputTokens: obj.usage?.output_tokens,
+    cacheReadTokens: obj.usage?.cache_read_input_tokens,
+    cacheCreationTokens: obj.usage?.cache_creation_input_tokens
+  };
+}
+
+// src/claude-mcp.ts
+import { spawnSync } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var MCP_SERVER_NAME = "tablation";
+var redact = (s, key) => key ? s.split(key).join("sk_***") : s;
+function mcpUrlFor(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "")}/api/mcp`;
+}
+function runClaude(bin, args) {
+  const r = spawnSync(bin, args, { encoding: "utf8", timeout: 3e4 });
+  const missing = r.error?.code === "ENOENT";
+  return { status: r.status, missing, stderr: r.stderr ?? "" };
+}
+function userScopeEntry(home) {
+  try {
+    const j = JSON.parse(readFileSync2(join2(home, ".claude.json"), "utf8"));
+    return j.mcpServers?.[MCP_SERVER_NAME];
+  } catch {
+    return void 0;
+  }
+}
+function inspectClaudeMcp(o) {
+  const got = runClaude(o.bin, ["mcp", "get", MCP_SERVER_NAME]);
+  if (got.missing) return { state: "no-claude" };
+  if (got.status !== 0) return { state: "missing" };
+  const entry = userScopeEntry(o.home ?? homedir());
+  if (!entry) {
+    return { state: "different", detail: `a "${MCP_SERVER_NAME}" server exists, but not in user scope (~/.claude.json) \u2014 a project or local registration` };
+  }
+  if (entry.url !== o.url) return { state: "different", detail: `it points at ${entry.url ?? "(no url)"}, not ${o.url}` };
+  const auth = Object.entries(entry.headers ?? {}).find(([k]) => k.toLowerCase() === "authorization")?.[1];
+  if (auth !== `Bearer ${o.key}`) return { state: "different", detail: `it is registered with a different key than this route's` };
+  return { state: "registered", url: o.url };
+}
+function ensureClaudeMcp(o) {
+  const manual = `claude mcp add --transport http ${MCP_SERVER_NAME} ${o.url} --header "Authorization: Bearer <key>" --scope user`;
+  const st = inspectClaudeMcp(o);
+  if (st.state === "no-claude") return `mcp: \`${o.bin}\` not found, so Claude Code was not configured. To do it by hand: ${manual}`;
+  if (st.state === "registered") return `mcp: ${MCP_SERVER_NAME} already registered with Claude Code \u2192 ${st.url}`;
+  if (st.state === "different" && !o.replace) {
+    return `mcp: left Claude Code's "${MCP_SERVER_NAME}" server alone \u2014 ${st.detail}. Re-run with --mcp replace to overwrite it.`;
+  }
+  if (o.dryRun) return `(dry run) would register the ${MCP_SERVER_NAME} MCP server with Claude Code \u2192 ${o.url}`;
+  if (st.state === "different") {
+    runClaude(o.bin, ["mcp", "remove", MCP_SERVER_NAME, "--scope", "user"]);
+  }
+  const add = runClaude(o.bin, [
+    "mcp",
+    "add",
+    "--transport",
+    "http",
+    MCP_SERVER_NAME,
+    o.url,
+    "--header",
+    `Authorization: Bearer ${o.key}`,
+    "--scope",
+    "user"
+  ]);
+  if (add.status !== 0) {
+    return `mcp: \`claude mcp add\` failed (${redact(add.stderr.trim(), o.key) || `exit ${add.status}`}). To do it by hand: ${manual}`;
+  }
+  return `mcp: registered the ${MCP_SERVER_NAME} MCP server with Claude Code \u2192 ${o.url} (user scope, ~/.claude.json)`;
+}
+
+// src/capability.ts
+function profileFor(role) {
+  if (role === "triage") return { level: "read", designTools: false };
+  if (role === "qa") return { level: "write", designTools: false };
+  return { level: "edit", designTools: role === "design" };
+}
+
+// src/adapters/claude.ts
+var BILLING_VARS_TO_UNSET = [
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "CLAUDE_CODE_USE_VERTEX",
+  "ANTHROPIC_VERTEX_PROJECT_ID",
+  "ANTHROPIC_VERTEX_REGION",
+  "CLOUD_ML_REGION",
+  "ANTHROPIC_MODEL"
+];
+var DISALLOWED_TOOLS = [
+  "Bash(rm -rf:*)",
+  "Bash(rm -fr:*)",
+  "Bash(git push --force*)",
+  "Bash(git push -f*)",
+  "Bash(curl*| sh)",
+  "Bash(curl*|sh)",
+  "Bash(curl*| bash)",
+  "Bash(curl*|bash)",
+  "Bash(sudo:*)"
+];
+function claudeToolsFor(p) {
+  const tablation = "mcp__tablation__*";
+  if (p.level === "read") return ["Bash", "Read", tablation];
+  if (p.level === "write") return ["Bash", "Read", "Write", "Grep", "Glob", tablation];
+  const base = ["Bash", "Read", "Edit", "Write", "Grep", "Glob", tablation];
+  return p.designTools ? [...base, "Skill", "Artifact"] : base;
+}
+function allowedTools(role) {
+  return claudeToolsFor(profileFor(role));
+}
+var claudeAdapter = {
+  harness: "claude",
+  displayName: "Claude Code",
+  defaultBin: "claude",
+  defaultModel: "claude-sonnet-5",
+  defaultTiers: {
+    light: { model: "claude-haiku-4-5-20251001" },
+    standard: { model: "claude-sonnet-5-5" },
+    deep: { model: "claude-opus-5-5" }
+  },
+  limitations: [
+    "Bash is not sandboxed: the deny list refuses known destructive patterns, but a one-liner reaching the same end another way is not caught",
+    "the write profile (QA) withholds the Edit tool, not file writes \u2014 Bash can still write files",
+    "git push is not blocked, only forced pushes"
+  ],
+  invocation(spec, o) {
+    const args = [
+      "-p",
+      "--allowedTools",
+      ...allowedTools(o.role),
+      "--disallowedTools",
+      ...DISALLOWED_TOOLS,
+      "--model",
+      o.model,
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      // Registers the tracker's own MCP tool surface for this run only —
+      // `${CREW_API_KEY}` is interpolated by the CLI from the environment,
+      // so the resolved key is never written to an argv string or a config
+      // file on disk. Skipped when there's no key to send: a route `crew
+      // connect` hasn't resolved yet has nothing to authenticate with.
+      ...o.mcp ? ["--mcp-config", JSON.stringify({
+        mcpServers: {
+          tablation: {
+            type: "http",
+            url: o.mcp.url,
+            headers: { Authorization: `Bearer \${${o.mcp.keyVar}}` }
+          }
+        }
+      })] : [],
+      ...spec.args
+    ];
+    return spec.launcher ? { bin: spec.launcher, args: [spec.bin, ...args] } : { bin: spec.bin, args };
+  },
+  runEnv(spec) {
+    return {
+      // Extended thinking is what makes the CLI emit `thinking` stream
+      // blocks at all — without it, Agent Log Cycles reporting has nothing
+      // to report (ISSUE-558).
+      ...spec.maxThinkingTokens > 0 ? { MAX_THINKING_TOKENS: String(spec.maxThinkingTokens) } : {},
+      ...spec.env
+    };
+  },
+  unsetEnv: BILLING_VARS_TO_UNSET,
+  mapStreamLine,
+  extractResult,
+  extractTurnTokens,
+  inspectMcp(o) {
+    const s = inspectClaudeMcp(o);
+    return s.state === "no-claude" ? { state: "no-binary" } : s;
+  },
+  ensureMcp: ensureClaudeMcp
+};
+
+// src/toolchain.ts
+var TIERS = ["light", "standard", "deep"];
+var ADAPTERS = {
+  [claudeAdapter.harness]: claudeAdapter
+};
+var HARNESS_NAMES = Object.keys(ADAPTERS);
+function isHarness(name) {
+  return Object.hasOwn(ADAPTERS, name);
+}
+function adapterFor(harness) {
+  const a = Object.hasOwn(ADAPTERS, harness) ? ADAPTERS[harness] : void 0;
+  if (!a) throw new Error(`unknown harness "${harness}" (have: ${HARNESS_NAMES.join(", ")})`);
+  return a;
+}
+var LEGACY_TOOLCHAIN = "claude";
+function shipToolchains(ship) {
+  const explicit = ship.toolchains ?? [];
+  if (explicit.some((t) => t.name === LEGACY_TOOLCHAIN)) return explicit;
+  const a = claudeAdapter;
+  const legacy = {
+    name: LEGACY_TOOLCHAIN,
+    harness: a.harness,
+    bin: ship.agent.bin,
+    model: ship.agent.model,
+    tiers: a.defaultTiers,
+    args: [],
+    env: {},
+    maxThinkingTokens: ship.agent.maxThinkingTokens
+  };
+  return [legacy, ...explicit];
+}
+function resolveToolchain(ship, route) {
+  const name = route?.toolchain ?? ship.toolchain ?? LEGACY_TOOLCHAIN;
+  const found = shipToolchains(ship).find((t) => t.name === name);
+  if (!found) throw new Error(`toolchain "${name}" is not defined (have: ${shipToolchains(ship).map((t) => t.name).join(", ")})`);
+  return found;
+}
+
 // src/config.ts
 import { getSessionStore, hostFromUrl } from "@tablation/client";
 
@@ -197,8 +452,8 @@ function explain(ship, required) {
 }
 
 // src/repo-config.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join2, basename } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
+import { join as join3, basename } from "path";
 import { parse } from "yaml";
 var SPEC_VERSION = 1;
 var REPO_CONFIG_FILENAMES = [".crew.yaml", ".crew.yml", ".crew.json"];
@@ -271,7 +526,7 @@ 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 = join2(dir, name);
+    const p = join3(dir, name);
     if (existsSync2(p)) return p;
   }
   return null;
@@ -502,7 +757,7 @@ function parseRepoConfig(text, file) {
 function loadRepoConfig(dir) {
   const file = findRepoConfig(dir);
   if (!file) return null;
-  return parseRepoConfig(readFileSync2(file, "utf8"), file);
+  return parseRepoConfig(readFileSync3(file, "utf8"), file);
 }
 function hookLabel(cfg, hook2) {
   return cfg.labels[hook2] ?? cfg.hooks[hook2] ?? hook2;
@@ -767,6 +1022,8 @@ var SHIP_KEYS = /* @__PURE__ */ new Set([
   "name",
   "platform",
   "agent",
+  "toolchains",
+  "toolchain",
   "shell",
   "extraPath",
   "useNvm",
@@ -806,7 +1063,8 @@ var ROUTE_KEYS = /* @__PURE__ */ new Set([
   "contract",
   "resolved",
   "promptSet",
-  "hostPassengers"
+  "hostPassengers",
+  "toolchain"
 ]);
 function parseWorktreeName(v, where, file) {
   const problem = typeof v === "string" ? worktreeNameProblem(v) : "must be a string";
@@ -910,16 +1168,16 @@ function mergeRouteRelease(route, override) {
   };
 }
 function expand(p, base) {
-  let out = p.startsWith("~") ? p.replace(/^~/, homedir()) : p;
-  out = out.replace(/\$\{?HOME\}?/g, homedir());
+  let out = p.startsWith("~") ? p.replace(/^~/, homedir2()) : p;
+  out = out.replace(/\$\{?HOME\}?/g, homedir2());
   return isAbsolute(out) ? out : resolve(base, out);
 }
 function resolvePromptsDir(promptSet, crewHome, base) {
-  if (!promptSet) return join3(crewHome, "prompts", "default");
+  if (!promptSet) return join4(crewHome, "prompts", "default");
   if (promptSet.includes("/") || promptSet.startsWith(".") || promptSet.startsWith("~")) {
     return expand(promptSet, base);
   }
-  return join3(crewHome, "prompts", promptSet);
+  return join4(crewHome, "prompts", promptSet);
 }
 var Missing = class {
   paths = [];
@@ -943,7 +1201,7 @@ var Missing = class {
 };
 function crewVersion(crewHome) {
   try {
-    const pkg = JSON.parse(readFileSync3(join3(crewHome, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync4(join4(crewHome, "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -953,8 +1211,8 @@ function configSearchPath(crewHome) {
   if (process.env.CREW_CONFIG) return [resolve(process.env.CREW_CONFIG)];
   const xdg = process.env.XDG_CONFIG_HOME;
   return [
-    ...xdg ? [join3(xdg, "crew", "crew.yaml")] : [],
-    join3(homedir(), ".config", "crew", "crew.yaml"),
+    ...xdg ? [join4(xdg, "crew", "crew.yaml")] : [],
+    join4(homedir2(), ".config", "crew", "crew.yaml"),
     resolve(crewHome, "crew.yaml")
   ];
 }
@@ -962,17 +1220,17 @@ function findConfigFile(crewHome) {
   const candidates = configSearchPath(crewHome);
   return candidates.find((c) => existsSync3(c)) ?? candidates[candidates.length - 1];
 }
-var defaultConfigPath = () => join3(process.env.XDG_CONFIG_HOME ?? join3(homedir(), ".config"), "crew", "crew.yaml");
+var defaultConfigPath = () => join4(process.env.XDG_CONFIG_HOME ?? join4(homedir2(), ".config"), "crew", "crew.yaml");
 function routeSlug(route) {
   return route.replace(/\//g, "-");
 }
 function resolvedPathFor(stateDir, route) {
   const [workspace, project] = splitRoute(route);
-  return join3(stateDir, "resolved", workspace, `${project}.json`);
+  return join4(stateDir, "resolved", workspace, `${project}.json`);
 }
 function apiKeyPathFor(stateDir, route) {
   const [workspace, project] = splitRoute(route);
-  return join3(stateDir, "keys", workspace, `${project}.env`);
+  return join4(stateDir, "keys", workspace, `${project}.env`);
 }
 function splitRoute(route) {
   const parts = route.split("/");
@@ -985,7 +1243,7 @@ function readResolvedFile(stateDir, route) {
   const path = resolvedPathFor(stateDir, route);
   if (!existsSync3(path)) return void 0;
   try {
-    return JSON.parse(readFileSync3(path, "utf8"));
+    return JSON.parse(readFileSync4(path, "utf8"));
   } catch (e) {
     throw new ConfigError(`${path}: not valid JSON \u2014 ${e.message}`);
   }
@@ -1047,12 +1305,12 @@ function loadConfig(crewHome, configFile, opts = {}) {
 ` + configSearchPath(crewHome).map((c) => `  - ${c}`).join("\n") + `
 
 Create the first of those:
-  mkdir -p ${dirname2(defaultConfigPath())} && cp ${join3(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
+  mkdir -p ${dirname2(defaultConfigPath())} && cp ${join4(crewHome, "crew.example.yaml")} ${defaultConfigPath()}`
     );
   }
   let raw;
   try {
-    raw = parse2(opts.text ?? readFileSync3(file, "utf8"));
+    raw = parse2(opts.text ?? readFileSync4(file, "utf8"));
   } catch (e) {
     throw new ConfigError(`${file}: not valid YAML \u2014 ${e.message}`);
   }
@@ -1082,6 +1340,12 @@ Create the first of those:
   if (!Number.isInteger(maxThinkingTokens) || maxThinkingTokens < 0) {
     missing.add(`ship.agent.maxThinkingTokens must be a non-negative integer (got "${shipRaw.agent?.maxThinkingTokens}")`);
   }
+  const toolchains = parseToolchains(shipRaw.toolchains, base, missing, file);
+  const toolchainNames = /* @__PURE__ */ new Set([LEGACY_TOOLCHAIN, ...toolchains.map((x) => x.name)]);
+  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(", ")})`);
+  }
   const stateDir = expand(shipRaw.stateDir ?? "state", base);
   const routesRaw = raw.routes;
   if (!opts.allowNoRoutes && (!Array.isArray(routesRaw) || routesRaw.length === 0)) {
@@ -1092,7 +1356,7 @@ Create the first of those:
     const where = `routes[${i}]`;
     const routeMissing = new Missing();
     try {
-      return [parseOneRoute(c, where, file, base, stateDir, raw, routeMissing, crewHome)];
+      return [parseOneRoute(c, where, file, base, stateDir, raw, routeMissing, crewHome, toolchainNames)];
     } catch (e) {
       const label = typeof c?.route === "string" && c.route ? `"${c.route}"` : where;
       routeWarnings.push(`route ${label} dropped \u2014 ${e.message}`);
@@ -1115,12 +1379,14 @@ Create the first of those:
         model: shipRaw.agent?.model ?? "claude-sonnet-5",
         maxThinkingTokens
       },
+      ...toolchains.length > 0 ? { toolchains } : {},
+      ...shipToolchain !== void 0 ? { toolchain: shipToolchain } : {},
       shell: shipRaw.shell,
       extraPath: shipRaw.extraPath,
       useNvm: shipRaw.useNvm !== false,
       nvmSh: shipRaw.nvmSh,
       stateDir,
-      logFile: expand(shipRaw.logFile ?? join3(tmpdir(), "crew.log"), base),
+      logFile: expand(shipRaw.logFile ?? join4(tmpdir(), "crew.log"), base),
       userAgent: shipRaw.userAgent ?? `Mozilla/5.0 CrewAgent/${crewVersion(crewHome)}`,
       maxConcurrentAgents,
       streamRetentionDays,
@@ -1138,8 +1404,70 @@ Create the first of those:
     warnings: routeWarnings
   };
 }
-function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome) {
+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 parseToolchains(raw, base, missing, file) {
+  if (raw === void 0 || raw === null) return [];
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    missing.add("ship.toolchains must be a mapping of name \u2192 toolchain");
+    return [];
+  }
+  const out = [];
+  for (const [name, entryRaw] of Object.entries(raw)) {
+    const where = `ship.toolchains.${name}`;
+    if (!entryRaw || typeof entryRaw !== "object" || Array.isArray(entryRaw)) {
+      missing.add(`${where} must be a mapping`);
+      continue;
+    }
+    rejectUnknownKeys(entryRaw, TOOLCHAIN_KEYS, where, file);
+    const harness = String(entryRaw.harness ?? "");
+    if (!isHarness(harness)) {
+      missing.add(`${where}.harness must be one of ${HARNESS_NAMES.join("|")} (got "${harness}")`);
+      continue;
+    }
+    const adapter = adapterFor(harness);
+    const tiers = { ...adapter.defaultTiers };
+    for (const [tier, v] of Object.entries(entryRaw.tiers ?? {})) {
+      if (!TIERS.includes(tier)) {
+        missing.add(`${where}.tiers.${tier} is not a tier (have: ${TIERS.join(", ")})`);
+        continue;
+      }
+      if (!v || typeof v.model !== "string" || !v.model) {
+        missing.add(`${where}.tiers.${tier}.model is required`);
+        continue;
+      }
+      tiers[tier] = { model: v.model, ...v.reasoning !== void 0 ? { reasoning: String(v.reasoning) } : {} };
+    }
+    const args = entryRaw.args ?? [];
+    if (!Array.isArray(args)) missing.add(`${where}.args must be a list of strings`);
+    const env = entryRaw.env ?? {};
+    if (typeof env !== "object" || Array.isArray(env)) missing.add(`${where}.env must be a mapping of name \u2192 value`);
+    const maxThinkingTokens = entryRaw.maxThinkingTokens === void 0 ? DEFAULT_MAX_THINKING_TOKENS : Number(entryRaw.maxThinkingTokens);
+    if (!Number.isInteger(maxThinkingTokens) || maxThinkingTokens < 0) {
+      missing.add(`${where}.maxThinkingTokens must be a non-negative integer (got "${entryRaw.maxThinkingTokens}")`);
+    }
+    out.push({
+      name,
+      harness,
+      bin: expandCommand(String(entryRaw.bin ?? adapter.defaultBin), base),
+      ...entryRaw.launcher ? { launcher: expandCommand(String(entryRaw.launcher), base) } : {},
+      model: String(entryRaw.model ?? tiers.standard?.model ?? adapter.defaultModel),
+      tiers,
+      args: Array.isArray(args) ? args.map(String) : [],
+      env: Object.fromEntries(Object.entries(env).map(([k, v]) => [k, String(v)])),
+      maxThinkingTokens
+    });
+  }
+  return out;
+}
+function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome, toolchainNames) {
   rejectUnknownKeys(c, ROUTE_KEYS, `${where}`, file);
+  const toolchain = c?.toolchain === void 0 ? void 0 : String(c.toolchain);
+  if (toolchain !== void 0 && !toolchainNames.has(toolchain)) {
+    missing.add(`${where}.toolchain "${toolchain}" is not defined in ship.toolchains (have: ${[...toolchainNames].join(", ")})`);
+  }
   const route = missing.req(c?.route, `${where}.route`);
   const routeParts = route ? route.split("/") : [];
   const routeWellFormed = routeParts.length === 2 && routeParts.every(Boolean);
@@ -1188,6 +1516,7 @@ function parseOneRoute(c, where, file, base, stateDir, raw, missing, crewHome) {
     reposBasePath: expand(String(c?.reposBasePath ?? raw.ship?.reposBasePath ?? DEFAULT_REPOS_BASE_PATH), base),
     repoOverrides,
     worktreePrefix: c?.worktreePrefix ? String(c.worktreePrefix) : void 0,
+    ...toolchain !== void 0 ? { toolchain } : {},
     promptsDir: resolvePromptsDir(c?.promptSet ? String(c.promptSet) : void 0, crewHome, base),
     weight,
     baseUrl: String(c?.baseUrl ?? raw.ship?.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, ""),
@@ -1256,7 +1585,7 @@ 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 readFileSync3(r.apiKeyFile, "utf8").split("\n")) {
+    for (const line of readFileSync4(r.apiKeyFile, "utf8").split("\n")) {
       const m = line.match(new RegExp(`^${r.apiKeyVar}=(.*)$`));
       if (m) return (m[1] ?? "").trim().replace(/^["']|["']$/g, "");
     }
@@ -1319,7 +1648,7 @@ function configuredMembers(rt) {
   return out;
 }
 function defaultRepoDir(basePath, workspace, repoName) {
-  return join3(basePath, workspace, repoName);
+  return join4(basePath, workspace, repoName);
 }
 function reposOf(r) {
   const named = Object.entries(r.repos);
@@ -1343,7 +1672,7 @@ function passengerRepoTargets(r) {
   return reposOf(r).filter((t) => r.repoOverrides[t.name]?.hostPassengers !== false);
 }
 function passengerCheckoutDir(basePath, workspace, repoName) {
-  return join3(basePath, workspace, ".passenger-checkouts", repoName);
+  return join4(basePath, workspace, ".passenger-checkouts", repoName);
 }
 function passengerCheckoutTargets(r) {
   if (!r.hostPassengers) return [];
@@ -1475,8 +1804,8 @@ function rosterMarkdown(roster, meId) {
 }
 
 // src/state.ts
-import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, rmSync as rmSync2, statSync as statSync2 } from "fs";
-import { join as join4 } from "path";
+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";
 var EPOCH = "1970-01-01T00:00:00.000Z";
 var State = class _State {
   dir;
@@ -1485,7 +1814,7 @@ var State = class _State {
     mkdirSync2(dir, { recursive: true });
   }
   path(...parts) {
-    return join4(this.dir, ...parts);
+    return join5(this.dir, ...parts);
   }
   /**
    * The timestamp every "new since last poll" check is measured against.
@@ -1496,7 +1825,7 @@ var State = class _State {
    */
   watermark() {
     try {
-      const v = readFileSync4(this.path(".poll-watermark"), "utf8").trim();
+      const v = readFileSync5(this.path(".poll-watermark"), "utf8").trim();
       return v || EPOCH;
     } catch {
       return EPOCH;
@@ -1582,7 +1911,7 @@ var State = class _State {
     const name = _State.safe(rawName);
     const file = this.path(`.${name}.lock`);
     try {
-      const existing = Number.parseInt(readFileSync4(file, "utf8").trim(), 10);
+      const existing = Number.parseInt(readFileSync5(file, "utf8").trim(), 10);
       if (Number.isFinite(existing) && existing > 0) {
         try {
           process.kill(existing, 0);
@@ -1676,7 +2005,7 @@ var State = class _State {
     const heldReported = `.release-held-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync4(this.path(f), "utf8").trim() || null;
+        return readFileSync5(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -1726,7 +2055,7 @@ var State = class _State {
       /** Whether the board was already told about this head's red gate. */
       heldReported: () => {
         try {
-          return readFileSync4(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
+          return readFileSync5(this.path(heldReported), "utf8").replace(/\n$/, "") || null;
         } catch {
           return null;
         }
@@ -1763,7 +2092,7 @@ var State = class _State {
     const ticketStreakFile = `.fairness-ticket-streak-${suffix}`;
     const read = (f) => {
       try {
-        return readFileSync4(this.path(f), "utf8").trim() || null;
+        return readFileSync5(this.path(f), "utf8").trim() || null;
       } catch {
         return null;
       }
@@ -1828,7 +2157,7 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync4(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync5(this.path(file), "utf8"));
           return parsed && typeof parsed === "object" ? parsed : {};
         } catch {
           return {};
@@ -1849,7 +2178,7 @@ var State = class _State {
     return {
       previous: () => {
         try {
-          const parsed = JSON.parse(readFileSync4(this.path(file), "utf8"));
+          const parsed = JSON.parse(readFileSync5(this.path(file), "utf8"));
           return Array.isArray(parsed) ? parsed : [];
         } catch {
           return [];
@@ -1882,7 +2211,7 @@ var State = class _State {
   }
   readInt(file) {
     try {
-      return Number.parseInt(readFileSync4(this.path(file), "utf8").trim(), 10) || 0;
+      return Number.parseInt(readFileSync5(this.path(file), "utf8").trim(), 10) || 0;
     } catch {
       return 0;
     }
@@ -2186,10 +2515,10 @@ function describeRelease(o, route) {
 }
 
 // src/install.ts
-import { dirname as dirname3, join as join5, extname } from "path";
-import { homedir as homedir2 } from "os";
-import { accessSync, constants, existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync5, statSync as statSync3, writeFileSync as writeFileSync2, unlinkSync, realpathSync } from "fs";
-import { spawnSync } from "child_process";
+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 { spawnSync as spawnSync2 } from "child_process";
 import { createHash } from "crypto";
 
 // src/runtime-info.ts
@@ -2200,7 +2529,7 @@ function isCompiledBinary(moduleUrl) {
 // src/install.ts
 function crewInvocation(crewHome) {
   if (isCompiledBinary(import.meta.url)) return [process.execPath];
-  return [process.execPath, join5(crewHome, "bin", "crew")];
+  return [process.execPath, join6(crewHome, "bin", "crew")];
 }
 var INTERVAL_SECONDS = 120;
 function labelFor(crewHome, job) {
@@ -2238,7 +2567,7 @@ function pathFor(ship) {
   return parts.join(":");
 }
 function findOnPath(bin, searchPath) {
-  const candidates = bin.includes("/") ? [bin] : searchPath.split(":").filter(Boolean).map((dir) => join5(dir, bin));
+  const candidates = bin.includes("/") ? [bin] : searchPath.split(":").filter(Boolean).map((dir) => join6(dir, bin));
   for (const candidate of candidates) {
     try {
       accessSync(candidate, constants.X_OK);
@@ -2248,7 +2577,7 @@ function findOnPath(bin, searchPath) {
   }
   return void 0;
 }
-var COMMON_DOCKER_DIRS = ["/usr/local/bin", "/opt/homebrew/bin", join5(homedir2(), ".docker", "bin")].join(":");
+var COMMON_DOCKER_DIRS = ["/usr/local/bin", "/opt/homebrew/bin", join6(homedir3(), ".docker", "bin")].join(":");
 function dockerPathProblem(ship, shellPath = process.env.PATH ?? "") {
   const schedulerPath = pathFor(ship);
   if (findOnPath("docker", schedulerPath)) return void 0;
@@ -2260,7 +2589,7 @@ function xmlEscape(s) {
 }
 function planLaunchd(ship, crewHome, job) {
   const label = labelFor(crewHome, job);
-  const unitPath = join5(homedir2(), "Library", "LaunchAgents", `${label}.plist`);
+  const unitPath = join6(homedir3(), "Library", "LaunchAgents", `${label}.plist`);
   const crewLog = ship.logFile;
   const schedulerLog = schedulerLogFor(crewLog, job);
   const persistent = job === "run";
@@ -2312,8 +2641,8 @@ ${scheduleKeys}
 }
 function planSystemd(ship, crewHome, job) {
   const label = labelFor(crewHome, job);
-  const unitDir = join5(homedir2(), ".config", "systemd", "user");
-  const servicePath = join5(unitDir, `${label}.service`);
+  const unitDir = join6(homedir3(), ".config", "systemd", "user");
+  const servicePath = join6(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";
@@ -2350,7 +2679,7 @@ WantedBy=default.target
       schedulerLog
     };
   }
-  const timerPath = join5(unitDir, `${label}.timer`);
+  const timerPath = join6(unitDir, `${label}.timer`);
   const service = `# Written by \`crew install\` \u2014 re-run it rather than hand-editing this file.
 [Unit]
 Description=${description}
@@ -2417,7 +2746,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 = join5(homedir2(), "Library", "LaunchAgents", `${label}.plist`);
+    const unitPath = join6(homedir3(), "Library", "LaunchAgents", `${label}.plist`);
     return {
       mechanism: "launchd",
       unitPaths: [unitPath],
@@ -2427,18 +2756,18 @@ function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
     };
   }
   if (hostShip === "linux" && hasSystemd) {
-    const unitDir = join5(homedir2(), ".config", "systemd", "user");
+    const unitDir = join6(homedir3(), ".config", "systemd", "user");
     if (job === "run") {
       return {
         mechanism: "systemd",
-        unitPaths: [join5(unitDir, `${label}.service`)],
+        unitPaths: [join6(unitDir, `${label}.service`)],
         crontabLine: null,
         unloadCommands: [["systemctl", "--user", "disable", "--now", `${label}.service`]]
       };
     }
     return {
       mechanism: "systemd",
-      unitPaths: [join5(unitDir, `${label}.service`), join5(unitDir, `${label}.timer`)],
+      unitPaths: [join6(unitDir, `${label}.service`), join6(unitDir, `${label}.timer`)],
       crontabLine: null,
       unloadCommands: [["systemctl", "--user", "disable", "--now", `${label}.timer`]]
     };
@@ -2456,7 +2785,7 @@ function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
 function planDaemonControl(crewHome, hostShip, hasSystemd) {
   const label = labelFor(crewHome, "run");
   if (hostShip === "macos") {
-    const unitPath = join5(homedir2(), "Library", "LaunchAgents", `${label}.plist`);
+    const unitPath = join6(homedir3(), "Library", "LaunchAgents", `${label}.plist`);
     return {
       mechanism: "launchd",
       startCommand: ["launchctl", "load", unitPath],
@@ -2480,7 +2809,7 @@ function planDaemonControl(crewHome, hostShip, hasSystemd) {
 }
 function runAll(commands, cwd, log) {
   for (const [bin, ...args] of commands) {
-    const res = spawnSync(bin, args, { cwd, encoding: "utf8" });
+    const res = spawnSync2(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) : ""}`
@@ -2545,7 +2874,7 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
     if (dryRun) {
       log.emit(`would run: launchctl remove ${plan.removeLabel}`);
     } else {
-      if (spawnSync("launchctl", ["remove", plan.removeLabel], { encoding: "utf8" }).status === 0) {
+      if (spawnSync2("launchctl", ["remove", plan.removeLabel], { encoding: "utf8" }).status === 0) {
         log.emit(`removed loaded job ${plan.removeLabel}`);
       }
     }
@@ -2570,7 +2899,7 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
 }
 var CREW_LAUNCHD_PREFIX = "com.tablation.crew";
 function launchAgentsDir() {
-  return join5(homedir2(), "Library", "LaunchAgents");
+  return join6(homedir3(), "Library", "LaunchAgents");
 }
 function xmlUnescape(s) {
   return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
@@ -2582,17 +2911,17 @@ function programFromPlist(text) {
   return args.find((a) => a.endsWith("/bin/crew")) ?? args[0] ?? null;
 }
 function loadedCrewLabels() {
-  const list = spawnSync("launchctl", ["list"], { encoding: "utf8" });
+  const list = spawnSync2("launchctl", ["list"], { encoding: "utf8" });
   if (list.status !== 0) return [];
   return [...parseLaunchctlList(list.stdout ?? "").keys()].filter((l) => l.startsWith(CREW_LAUNCHD_PREFIX));
 }
 function listLaunchdUnits(dir = launchAgentsDir(), loaded = []) {
   const files = existsSync5(dir) ? readdirSync(dir) : [];
   const units = files.filter((f) => f.startsWith(CREW_LAUNCHD_PREFIX) && f.endsWith(".plist")).sort().map((f) => {
-    const plistPath = join5(dir, f);
+    const plistPath = join6(dir, f);
     let program = null;
     try {
-      program = programFromPlist(readFileSync5(plistPath, "utf8"));
+      program = programFromPlist(readFileSync6(plistPath, "utf8"));
     } catch {
     }
     return {
@@ -2605,7 +2934,7 @@ function listLaunchdUnits(dir = launchAgentsDir(), loaded = []) {
   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: join5(dir, `${label}.plist`), program: null, programExists: false, orphan: true });
+    units.push({ label, plistPath: join6(dir, `${label}.plist`), program: null, programExists: false, orphan: true });
   }
   return units;
 }
@@ -2618,8 +2947,8 @@ function removeLaunchdUnit(unit, dryRun, log) {
     log.emit(`would unload and remove ${unit.label}`);
     return;
   }
-  if (existsSync5(unit.plistPath)) spawnSync("launchctl", ["unload", unit.plistPath], { encoding: "utf8" });
-  spawnSync("launchctl", ["remove", unit.label], { encoding: "utf8" });
+  if (existsSync5(unit.plistPath)) spawnSync2("launchctl", ["unload", unit.plistPath], { encoding: "utf8" });
+  spawnSync2("launchctl", ["remove", unit.label], { encoding: "utf8" });
   if (existsSync5(unit.plistPath)) unlinkSync(unit.plistPath);
   log.emit(`removed ${unit.label} (${unit.plistPath})`);
 }
@@ -2652,7 +2981,7 @@ function parseLaunchctlList(text) {
   return jobs;
 }
 function describeForeignLaunchdUnits(crewHome, dir) {
-  const list = spawnSync("launchctl", ["list"], { encoding: "utf8" });
+  const list = spawnSync2("launchctl", ["list"], { encoding: "utf8" });
   const jobs = parseLaunchctlList(list.status === 0 ? list.stdout ?? "" : "");
   const foreign = foreignLaunchdUnits(crewHome, dir, jobs.keys());
   return foreign.map((u) => {
@@ -2665,11 +2994,11 @@ function describeForeignLaunchdUnits(crewHome, dir) {
   });
 }
 function readCrontab() {
-  const res = spawnSync("crontab", ["-l"], { encoding: "utf8" });
+  const res = spawnSync2("crontab", ["-l"], { encoding: "utf8" });
   return res.status === 0 ? res.stdout ?? "" : "";
 }
 function writeCrontab(text) {
-  spawnSync("crontab", ["-"], { input: text, encoding: "utf8" });
+  spawnSync2("crontab", ["-"], { input: text, encoding: "utf8" });
 }
 function addCrontabLine(marker, line) {
   const existing = readCrontab();
@@ -2693,7 +3022,7 @@ function removeCrontabLine(marker) {
 }
 function detectSystemd() {
   if (process.platform !== "linux") return false;
-  const res = spawnSync("systemctl", ["--user", "status"], { encoding: "utf8" });
+  const res = spawnSync2("systemctl", ["--user", "status"], { encoding: "utf8" });
   return !res.error;
 }
 
@@ -4813,7 +5142,7 @@ function materializeBranchForTicket(dir, cfg, t, role) {
 
 // src/poll.ts
 import { writeFileSync as writeFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/stalled.ts
 var STALLED_AFTER_CYCLES = 30;
@@ -5085,7 +5414,7 @@ async function decideCycle(o) {
   }
   return decision;
 }
-var digestPath = (stateDir, route, role) => join6(stateDir, `digest-${route}-${role}.md`);
+var digestPath = (stateDir, route, role) => join7(stateDir, `digest-${route}-${role}.md`);
 function writeDigest(o, d, role, stateDir) {
   const me = o.route.resolved?.seats[role];
   if (!me) return false;
@@ -5455,9 +5784,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 readFileSync6, existsSync as existsSync7, statSync as statSync5, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, createWriteStream } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync7, statSync as statSync5, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, createWriteStream } from "fs";
 import { finished } from "stream/promises";
-import { join as join7, dirname as dirname5 } from "path";
+import { join as join8, dirname as dirname5 } from "path";
 import { createHash as createHash2 } from "crypto";
 
 // src/environment.ts
@@ -5742,54 +6071,6 @@ function renderEnvironment(i) {
   return lines.join("\n");
 }
 
-// src/stream.ts
-function toolTarget(name, input) {
-  if (!input) return void 0;
-  for (const key of ["file_path", "path", "notebook_path", "url", "pattern"]) {
-    const v = input[key];
-    if (typeof v === "string" && v) return v;
-  }
-  if (name === "Bash" && typeof input.command === "string") {
-    return input.command.trim().split(/\s+/)[0];
-  }
-  return void 0;
-}
-function mapStreamLine(line) {
-  const obj = line;
-  if (!obj || obj.type !== "assistant") return [];
-  const content = obj.message?.content;
-  if (!Array.isArray(content)) return [];
-  const out = [];
-  for (const block of content) {
-    if (block.type === "thinking") out.push({ kind: "thought", text: block.thinking });
-    else if (block.type === "text") out.push({ kind: "text", text: block.text });
-    else if (block.type === "tool_use") {
-      out.push({ kind: "tool", tool: block.name, target: toolTarget(block.name, block.input) });
-    }
-  }
-  return out;
-}
-function extractTurnTokens(line) {
-  const obj = line;
-  if (!obj || obj.type !== "assistant") return void 0;
-  const usage2 = obj.message?.usage;
-  if (!usage2) return void 0;
-  return (usage2.input_tokens ?? 0) + (usage2.output_tokens ?? 0) + (usage2.cache_read_input_tokens ?? 0) + (usage2.cache_creation_input_tokens ?? 0);
-}
-function extractResult(line) {
-  const obj = line;
-  if (!obj || obj.type !== "result") return void 0;
-  return {
-    sessionId: obj.session_id,
-    numTurns: obj.num_turns,
-    totalCostUsd: obj.total_cost_usd,
-    inputTokens: obj.usage?.input_tokens,
-    outputTokens: obj.usage?.output_tokens,
-    cacheReadTokens: obj.usage?.cache_read_input_tokens,
-    cacheCreationTokens: obj.usage?.cache_creation_input_tokens
-  };
-}
-
 // src/agent-log.ts
 async function post(target, path, body) {
   const url = `${target.baseUrl.replace(/\/+$/, "")}/api/workspaces/${target.workspaceId}${path}`;
@@ -5871,36 +6152,10 @@ var TicketAttributionTracker = class {
 
 // src/agent.ts
 var DIGEST_MAX_AGE_SECONDS = 600;
-function allowedTools(role) {
-  const tablation = "mcp__tablation__*";
-  if (role === "triage") return ["Bash", "Read", tablation];
-  if (role === "qa") return ["Bash", "Read", "Write", "Grep", "Glob", tablation];
-  const base = ["Bash", "Read", "Edit", "Write", "Grep", "Glob", tablation];
-  return role === "design" ? [...base, "Skill", "Artifact"] : base;
-}
-var DISALLOWED_TOOLS = [
-  "Bash(rm -rf:*)",
-  "Bash(rm -fr:*)",
-  "Bash(git push --force*)",
-  "Bash(git push -f*)",
-  "Bash(curl*| sh)",
-  "Bash(curl*|sh)",
-  "Bash(curl*| bash)",
-  "Bash(curl*|bash)",
-  "Bash(sudo:*)"
-];
-var BILLING_VARS_TO_UNSET = [
-  "ANTHROPIC_API_KEY",
-  "ANTHROPIC_AUTH_TOKEN",
-  "CLAUDE_CODE_USE_VERTEX",
-  "ANTHROPIC_VERTEX_PROJECT_ID",
-  "ANTHROPIC_VERTEX_REGION",
-  "CLOUD_ML_REGION",
-  "ANTHROPIC_MODEL"
-];
-function scrubbedEnv(env = process.env) {
+var LEGACY_TOOLCHAIN_HARNESS = "claude";
+function scrubbedEnv(env = process.env, harness = LEGACY_TOOLCHAIN_HARNESS) {
   const out = { ...env };
-  for (const v of BILLING_VARS_TO_UNSET) delete out[v];
+  for (const v of adapterFor(harness).unsetEnv) delete out[v];
   return out;
 }
 var CREW_LANE_ROLE_VAR = "CREW_LANE_ROLE";
@@ -5914,23 +6169,23 @@ var AgentError = class extends Error {
 var AgentSpawnError = class extends AgentError {
 };
 function planAgentRun(o) {
-  const briefPath = join7(o.route.promptsDir, "personas", `lane-${o.role}.md`);
+  const briefPath = join8(o.route.promptsDir, "personas", `lane-${o.role}.md`);
   if (!existsSync7(briefPath)) {
     throw new AgentError(`no brief at ${briefPath} \u2014 refusing to run an unscoped session`);
   }
-  const commonPath = join7(o.route.promptsDir, "personas", "common.md");
+  const commonPath = join8(o.route.promptsDir, "personas", "common.md");
   if (!existsSync7(commonPath)) throw new AgentError(`no shared policy at ${commonPath}`);
   const now = o.now ?? (() => Date.now());
   const routeLabel = routeSlug(o.route.route);
-  const digestPath2 = join7(o.stateDir, `digest-${routeLabel}-${o.role}.md`);
+  const digestPath2 = join8(o.stateDir, `digest-${routeLabel}-${o.role}.md`);
   let digest;
   let ageSeconds;
   if (existsSync7(digestPath2)) {
     ageSeconds = Math.floor((now() - statSync5(digestPath2).mtimeMs) / 1e3);
-    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync6(digestPath2, "utf8");
+    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync7(digestPath2, "utf8");
   }
-  const common = readFileSync6(commonPath, "utf8");
-  const brief = readFileSync6(briefPath, "utf8");
+  const common = readFileSync7(commonPath, "utf8");
+  const brief = readFileSync7(briefPath, "utf8");
   const effectiveCommon = o.divergedPrompt ? "" : common;
   const effectiveBrief = o.divergedPrompt ?? brief;
   const prompt = assemblePrompt({
@@ -5941,9 +6196,18 @@ function planAgentRun(o) {
     digest
   });
   const promptSha = createHash2("sha256").update(`${effectiveCommon}${effectiveBrief}`).digest("hex");
-  const streamsDir = join7(o.stateDir, "streams");
+  const streamsDir = join8(o.stateDir, "streams");
   const base = `${routeLabel}-${o.role}-${o.cycle}`;
-  const model = o.agentModel ?? o.ship.agent.model;
+  const toolchain = resolveToolchain(o.ship, o.route);
+  const adapter = adapterFor(toolchain.harness);
+  const model = o.agentModel ?? toolchain.model;
+  const invocation = adapter.invocation(toolchain, {
+    role: o.role,
+    model,
+    // Skipped when there's no key to send: a route `crew connect` hasn't
+    // resolved yet has nothing to authenticate the MCP connection with either.
+    mcp: o.apiKey ? { url: `${o.route.baseUrl}/api/mcp`, keyVar: API_KEY_VAR } : void 0
+  });
   const agentLog = o.route.resolved && o.apiKey ? {
     baseUrl: o.route.baseUrl,
     workspaceId: o.route.resolved.workspaceId,
@@ -5961,43 +6225,16 @@ function planAgentRun(o) {
     // (config.ts), and the digest's `repo` column is what actually places
     // the work. Kept deliberately rather than guessed at (ISSUE-349).
     cwd: o.route.dir,
-    bin: o.ship.agent.bin,
-    args: [
-      "-p",
-      "--allowedTools",
-      ...allowedTools(o.role),
-      "--disallowedTools",
-      ...DISALLOWED_TOOLS,
-      "--model",
-      model,
-      "--output-format",
-      "stream-json",
-      "--verbose",
-      // Registers the tracker's own MCP tool surface for this run only —
-      // `${CREW_API_KEY}` is interpolated by the CLI from the environment
-      // (set below), so the resolved key is never written to an argv string
-      // or a config file on disk. Skipped when there's no key to send: a
-      // route `crew connect` hasn't resolved yet has nothing to authenticate
-      // the MCP connection with either.
-      ...o.apiKey ? ["--mcp-config", JSON.stringify({
-        mcpServers: {
-          tablation: {
-            type: "http",
-            url: `${o.route.baseUrl}/api/mcp`,
-            headers: { Authorization: `Bearer \${${API_KEY_VAR}}` }
-          }
-        }
-      })] : []
-    ],
+    bin: invocation.bin,
+    args: invocation.args,
+    toolchain: toolchain.name,
+    harness: toolchain.harness,
     prompt,
     promptBytes: Buffer.byteLength(prompt, "utf8"),
-    unsetEnv: BILLING_VARS_TO_UNSET,
+    unsetEnv: adapter.unsetEnv,
     setEnv: {
       ...o.apiKey ? { [API_KEY_VAR]: o.apiKey } : {},
-      // Extended thinking is what makes the CLI emit `thinking` stream
-      // blocks at all — without it, `run.cycles` (below) is always empty
-      // and Agent Log Cycles reporting has nothing to report (ISSUE-558).
-      ...o.ship.agent.maxThinkingTokens > 0 ? { MAX_THINKING_TOKENS: String(o.ship.agent.maxThinkingTokens) } : {},
+      ...adapter.runEnv(toolchain),
       // The operator's global SessionStart hook (pair-context-hook.sh) injects
       // the interactive Pair persona's prompt for any session it can't tell
       // apart from a person's own terminal. Every headless lane run this
@@ -6011,8 +6248,8 @@ function planAgentRun(o) {
     digestAttached: digest !== void 0,
     digestAgeSeconds: ageSeconds,
     model,
-    streamPath: join7(streamsDir, `${base}.jsonl`),
-    eventsPath: join7(streamsDir, `${base}.events.jsonl`),
+    streamPath: join8(streamsDir, `${base}.jsonl`),
+    eventsPath: join8(streamsDir, `${base}.events.jsonl`),
     ticket: o.ticket,
     agentLog,
     promptVersion: o.route.resolved?.agentPersonas?.[o.role]?.historyId,
@@ -6022,6 +6259,8 @@ function planAgentRun(o) {
 function describePlan(p) {
   return [
     `role:    ${p.role}`,
+    // Only for a non-default toolchain, so a plain Claude run's output is unchanged.
+    ...p.toolchain && p.toolchain !== "claude" ? [`toolchain: ${p.toolchain} (${p.harness ?? "claude"})`] : [],
     `cwd:     ${p.cwd}`,
     `command: ${p.bin} ${p.args.join(" ")}`,
     `prompt:  ${p.promptBytes} bytes on stdin (never argv)`,
@@ -6047,6 +6286,7 @@ function endSink(sink) {
   return finished(sink).catch(() => void 0);
 }
 function spawnAgent(plan, emit) {
+  const adapter = adapterFor(plan.harness ?? LEGACY_TOOLCHAIN_HARNESS);
   const started = Date.now();
   const startedAt = new Date(started).toISOString();
   const rawSink = openSink(plan.streamPath);
@@ -6054,7 +6294,7 @@ function spawnAgent(plan, emit) {
   return new Promise((resolve5, reject) => {
     const child = spawn2(plan.bin, plan.args, {
       cwd: plan.cwd,
-      env: { ...scrubbedEnv(), ...plan.setEnv },
+      env: { ...scrubbedEnv(process.env, adapter.harness), ...plan.setEnv },
       stdio: ["pipe", "pipe", "inherit"]
     });
     let buf = "";
@@ -6075,9 +6315,9 @@ function spawnAgent(plan, emit) {
         return;
       }
       try {
-        result = extractResult(parsed) ?? result;
+        result = adapter.extractResult(parsed) ?? result;
         let turnText = "";
-        for (const ev of mapStreamLine(parsed)) {
+        for (const ev of adapter.mapStreamLine(parsed)) {
           const e = {
             at: (/* @__PURE__ */ new Date()).toISOString(),
             cycle: emit.cycle,
@@ -6115,7 +6355,7 @@ function spawnAgent(plan, emit) {
 `);
           }
         }
-        const turnTokens = extractTurnTokens(parsed);
+        const turnTokens = adapter.extractTurnTokens(parsed);
         if (turnTokens !== void 0) attribution.add(turnText, turnTokens);
       } catch {
       }
@@ -6193,12 +6433,12 @@ function spawnAgent(plan, emit) {
 
 // src/run-worktree.ts
 import { existsSync as existsSync9 } from "fs";
-import { dirname as dirname6, join as join9 } from "path";
+import { dirname as dirname6, join as join10 } from "path";
 
 // src/ports.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { existsSync as existsSync8 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var run = (cmd, args) => {
   try {
     return execFileSync2(cmd, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
@@ -6243,7 +6483,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(join8(parent, name, ".git"))) return true;
+    if (existsSync8(join9(parent, name, ".git"))) return true;
   }
   return false;
 }
@@ -6331,7 +6571,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 = join9(dirname6(dir), worktreeForTicket(dir, cfg, t, role));
+  const path = join10(dirname6(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 };
   }
@@ -6539,7 +6779,7 @@ async function retireRunWorktree(tracker, dir, cfg, t, role, seatId, shipName2,
 }
 
 // src/connect-wizard.ts
-import { delimiter, dirname as dirname7, join as join10 } from "path";
+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 { stringify } from "yaml";
 var HOST_PASSENGERS_DOCS_URL = "https://crew.tablation.dev/host-passengers";
@@ -6562,7 +6802,7 @@ function defaultIsExecutable(p) {
 function findOnPath2(name, pathEnv, isExecutable = defaultIsExecutable) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir) continue;
-    const candidate = join10(dir, name);
+    const candidate = join11(dir, name);
     if (isExecutable(candidate)) return candidate;
   }
   return void 0;
@@ -6657,8 +6897,8 @@ Wrote ${o.configPath}.
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync11, copyFileSync, mkdirSync as mkdirSync7, mkdtempSync, rmSync as rmSync3 } from "fs";
-import { dirname as dirname8, join as join11 } from "path";
+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 { tmpdir as tmpdir2 } from "os";
 
 // src/release.ts
@@ -7316,13 +7556,13 @@ async function bump(o, size) {
     }
     return printed;
   }
-  const files = o.repo.release.versionFiles.map((f) => join11(o.cwd, f));
+  const files = o.repo.release.versionFiles.map((f) => join12(o.cwd, f));
   const first = files[0];
   if (!existsSync11(first)) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
     return null;
   }
-  const current = JSON.parse(readFileSync7(first, "utf8")).version;
+  const current = JSON.parse(readFileSync8(first, "utf8")).version;
   if (!current) {
     o.emit.error(`no version field in ${o.repo.release.versionFiles[0]}`);
     return null;
@@ -7335,7 +7575,7 @@ async function bump(o, size) {
     return version;
   }
   for (const f of files) {
-    const src = readFileSync7(f, "utf8");
+    const src = readFileSync8(f, "utf8");
     const out = src.replace(/("version"\s*:\s*")[^"]*(")/, `$1${version}$2`);
     if (out === src) {
       o.emit.error(`no version field in ${f}`);
@@ -7348,13 +7588,13 @@ async function bump(o, size) {
 function writeChangelog(o, version, entries) {
   const file = o.repo.release.changelog;
   if (!file || entries.length === 0) return;
-  const path = join11(o.cwd, file);
+  const path = join12(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) ? readFileSync7(path, "utf8") : "# Changelog\n";
+  const existing = existsSync11(path) ? readFileSync8(path, "utf8") : "# Changelog\n";
   writeFileSync6(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
@@ -7436,8 +7676,8 @@ async function confirmLastRelease(o, decision) {
 function openReleaseCheckout(o) {
   const { remote, base } = o.repo.branch;
   const branch = `crew/release-${Date.now()}`;
-  const root = mkdtempSync(join11(tmpdir2(), "crew-release-"));
-  const dir = join11(root, "checkout");
+  const root = mkdtempSync(join12(tmpdir2(), "crew-release-"));
+  const dir = join12(root, "checkout");
   const close = () => {
     gitOk(o.cwd, ["worktree", "remove", "--force", dir]);
     rmSync3(root, { recursive: true, force: true });
@@ -7451,10 +7691,10 @@ function openReleaseCheckout(o) {
     throw e;
   }
   for (const f of o.repo.worktrees.copy) {
-    const src = join11(o.cwd, f);
+    const src = join12(o.cwd, f);
     if (!existsSync11(src)) continue;
-    mkdirSync7(dirname8(join11(dir, f)), { recursive: true });
-    copyFileSync(src, join11(dir, f));
+    mkdirSync7(dirname8(join12(dir, f)), { recursive: true });
+    copyFileSync(src, join12(dir, f));
   }
   return { dir, branch, close };
 }
@@ -8264,8 +8504,8 @@ function nextRoles(decision, ran) {
 }
 
 // src/agents.ts
-import { readFileSync as readFileSync8, existsSync as existsSync13 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync13 } from "fs";
+import { join as join13 } from "path";
 import { TablationClient as TablationClient2, StaleWriteError as StaleWriteError6, TablationApiError } from "@tablation/client";
 var PERSONA_NAME = {
   dev: "Developer",
@@ -8279,12 +8519,12 @@ var CREW_AGENT_COLUMN = "agent_id";
 var AgentsSyncError = class extends Error {
 };
 function personaDefaultPrompt(promptsDir, role) {
-  const briefPath = join12(promptsDir, "personas", `lane-${role}.md`);
+  const briefPath = join13(promptsDir, "personas", `lane-${role}.md`);
   if (!existsSync13(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
-  if (role === "pair") return readFileSync8(briefPath, "utf8");
-  const commonPath = join12(promptsDir, "personas", "common.md");
+  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 `${readFileSync8(commonPath, "utf8")}${readFileSync8(briefPath, "utf8")}`;
+  return `${readFileSync9(commonPath, "utf8")}${readFileSync9(briefPath, "utf8")}`;
 }
 async function resolveAgentId(route, role, opts) {
   const cached = route.resolved?.agentPersonas?.[role]?.agentId;
@@ -8950,14 +9190,14 @@ import {
 } from "@tablation/client";
 
 // src/skills.ts
-import { readFileSync as readFileSync9, readdirSync as readdirSync2, existsSync as existsSync14 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync10, readdirSync as readdirSync2, existsSync as existsSync14 } from "fs";
+import { join as join14 } 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 = readFileSync9(path, "utf8");
+  const text = readFileSync10(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];
@@ -8970,9 +9210,9 @@ function parseSkillFile(path) {
   return { name: meta.name, description: meta.description, prompt: body, file: path };
 }
 function listLocalSkills(promptsDir) {
-  const dir = join13(promptsDir, "skills");
+  const dir = join14(promptsDir, "skills");
   if (!existsSync14(dir)) return [];
-  return readdirSync2(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join13(dir, f)));
+  return readdirSync2(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join14(dir, f)));
 }
 async function syncSkills(route, opts) {
   if (!route.resolved) {
@@ -9151,7 +9391,7 @@ async function showLogEntry(route, entryId, opts = {}) {
 }
 
 // src/repos-cmd.ts
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { basename as basename6, resolve as resolve3 } from "path";
 import { isMap, isSeq, parseDocument, stringify as stringify2 } from "yaml";
 var ReposError = class extends Error {
@@ -9198,7 +9438,7 @@ function parseAddArgs(args, routes, isDir) {
   return { route, path: "." };
 }
 function expandDir(p, base) {
-  const home = p === "~" ? homedir3() : p.startsWith("~/") ? `${homedir3()}/${p.slice(2)}` : p;
+  const home = p === "~" ? homedir4() : p.startsWith("~/") ? `${homedir4()}/${p.slice(2)}` : p;
   return resolve3(base, home);
 }
 function routeMapOf(doc, route) {
@@ -9295,72 +9535,6 @@ function resolveRepoProject(projects, opt, routeAreaId) {
   );
 }
 
-// src/claude-mcp.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync10 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join14 } from "path";
-var MCP_SERVER_NAME = "tablation";
-var redact = (s, key) => key ? s.split(key).join("sk_***") : s;
-function mcpUrlFor(baseUrl) {
-  return `${baseUrl.replace(/\/+$/, "")}/api/mcp`;
-}
-function runClaude(bin, args) {
-  const r = spawnSync2(bin, args, { encoding: "utf8", timeout: 3e4 });
-  const missing = r.error?.code === "ENOENT";
-  return { status: r.status, missing, stderr: r.stderr ?? "" };
-}
-function userScopeEntry(home) {
-  try {
-    const j = JSON.parse(readFileSync10(join14(home, ".claude.json"), "utf8"));
-    return j.mcpServers?.[MCP_SERVER_NAME];
-  } catch {
-    return void 0;
-  }
-}
-function inspectClaudeMcp(o) {
-  const got = runClaude(o.bin, ["mcp", "get", MCP_SERVER_NAME]);
-  if (got.missing) return { state: "no-claude" };
-  if (got.status !== 0) return { state: "missing" };
-  const entry = userScopeEntry(o.home ?? homedir4());
-  if (!entry) {
-    return { state: "different", detail: `a "${MCP_SERVER_NAME}" server exists, but not in user scope (~/.claude.json) \u2014 a project or local registration` };
-  }
-  if (entry.url !== o.url) return { state: "different", detail: `it points at ${entry.url ?? "(no url)"}, not ${o.url}` };
-  const auth = Object.entries(entry.headers ?? {}).find(([k]) => k.toLowerCase() === "authorization")?.[1];
-  if (auth !== `Bearer ${o.key}`) return { state: "different", detail: `it is registered with a different key than this route's` };
-  return { state: "registered", url: o.url };
-}
-function ensureClaudeMcp(o) {
-  const manual = `claude mcp add --transport http ${MCP_SERVER_NAME} ${o.url} --header "Authorization: Bearer <key>" --scope user`;
-  const st = inspectClaudeMcp(o);
-  if (st.state === "no-claude") return `mcp: \`${o.bin}\` not found, so Claude Code was not configured. To do it by hand: ${manual}`;
-  if (st.state === "registered") return `mcp: ${MCP_SERVER_NAME} already registered with Claude Code \u2192 ${st.url}`;
-  if (st.state === "different" && !o.replace) {
-    return `mcp: left Claude Code's "${MCP_SERVER_NAME}" server alone \u2014 ${st.detail}. Re-run with --mcp replace to overwrite it.`;
-  }
-  if (o.dryRun) return `(dry run) would register the ${MCP_SERVER_NAME} MCP server with Claude Code \u2192 ${o.url}`;
-  if (st.state === "different") {
-    runClaude(o.bin, ["mcp", "remove", MCP_SERVER_NAME, "--scope", "user"]);
-  }
-  const add = runClaude(o.bin, [
-    "mcp",
-    "add",
-    "--transport",
-    "http",
-    MCP_SERVER_NAME,
-    o.url,
-    "--header",
-    `Authorization: Bearer ${o.key}`,
-    "--scope",
-    "user"
-  ]);
-  if (add.status !== 0) {
-    return `mcp: \`claude mcp add\` failed (${redact(add.stderr.trim(), o.key) || `exit ${add.status}`}). To do it by hand: ${manual}`;
-  }
-  return `mcp: registered the ${MCP_SERVER_NAME} MCP server with Claude Code \u2192 ${o.url} (user scope, ~/.claude.json)`;
-}
-
 // src/doctor-fix.ts
 import { parseDocument as parseDocument2 } from "yaml";
 var sound = (r) => r.hasRepos && r.problems.length === 0;
@@ -12746,8 +12920,14 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         if (!wroteConfig) process.stdout.write(routeBlock);
         if (!flag("no-mcp") && apiKey) {
           const replace = value("mcp") === "replace";
-          process.stderr.write(`${ensureClaudeMcp({ bin: cfg.ship.agent.bin, url: mcpUrlFor(baseUrl), key: apiKey, replace, dryRun })}
+          const seen = /* @__PURE__ */ new Set();
+          for (const tc of shipToolchains(cfg.ship)) {
+            const id = `${tc.harness}\0${tc.bin}`;
+            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 })}
 `);
+          }
         }
         if (found.holds.length) {
           process.stderr.write(
@@ -13303,6 +13483,16 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             name: cfg.ship.name,
             platform: cfg.ship.platform,
             agent: { bin: cfg.ship.agent.bin, model: cfg.ship.agent.model },
+            // Additive (CREW-1511): the configured toolchains and the ship's
+            // default. `agent` above stays for older crew-macos builds.
+            toolchain: resolveToolchain(cfg.ship).name,
+            toolchains: shipToolchains(cfg.ship).map((x) => ({
+              name: x.name,
+              harness: x.harness,
+              bin: x.bin,
+              launcher: x.launcher ?? null,
+              model: x.model
+            })),
             stateDir: cfg.ship.stateDir,
             logFile: cfg.ship.logFile,
             eventFile: eventFileFor(cfg.ship.stateDir),
@@ -13328,6 +13518,8 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
             dir: route.dir,
             enabled: route.enabled,
             area: route.area ?? null,
+            // Additive (CREW-1511): the toolchain this route's sessions run on.
+            toolchain: resolveToolchain(cfg.ship, route).name,
             baseUrl: route.baseUrl,
             repos: repos.map((r) => ({
               name: r.name,
@@ -13553,14 +13745,24 @@ crew manifest:     ${seats2.length ? seats2.map((c) => c.name).join(", ") : "non
         }
       }
       const schedulerPath = pathFor(cfg.ship);
-      const agentBinPath = findOnPath(cfg.ship.agent.bin, schedulerPath);
       const gitPath = findOnPath("git", schedulerPath);
-      process.stdout.write(
-        `agent binary:      ${cfg.ship.agent.bin} \u2014 ${agentBinPath ? `OK (${agentBinPath})` : "NOT FOUND on the scheduler PATH"}
-git:               ${gitPath ? `OK (${gitPath})` : "NOT FOUND on the scheduler PATH"}
+      const defaultToolchain = resolveToolchain(cfg.ship).name;
+      let allBinsFound = true;
+      for (const tc of shipToolchains(cfg.ship)) {
+        const adapter = adapterFor(tc.harness);
+        const binPath = findOnPath(tc.launcher ?? tc.bin, schedulerPath);
+        if (!binPath) allBinsFound = false;
+        const label = tc.name === defaultToolchain ? "agent binary:     " : `toolchain ${tc.name}:`.padEnd(18);
+        process.stdout.write(
+          `${label} ${tc.launcher ?? tc.bin} \u2014 ${binPath ? `OK (${binPath})` : "NOT FOUND on the scheduler PATH"}${tc.name === defaultToolchain ? "" : ` [${adapter.displayName}]`}
 `
-      );
-      if (!agentBinPath || !gitPath) {
+        );
+        for (const limit of adapter.limitations) process.stdout.write(`                   cannot enforce: ${limit}
+`);
+      }
+      process.stdout.write(`git:               ${gitPath ? `OK (${gitPath})` : "NOT FOUND on the scheduler PATH"}
+`);
+      if (!allBinsFound || !gitPath) {
         process.stdout.write(
           `                   scheduler PATH is ${schedulerPath} \u2014 add the directory holding the missing binary to ship.extraPath in crew.yaml, then re-run \`crew doctor\`.
 `
@@ -13568,14 +13770,21 @@ git:               ${gitPath ? `OK (${gitPath})` : "NOT FOUND on the scheduler P
       }
       if (route.apiKey) {
         const mcpUrl = mcpUrlFor(route.baseUrl);
-        const m = inspectClaudeMcp({ bin: cfg.ship.agent.bin, url: mcpUrl, key: route.apiKey });
-        process.stdout.write(
-          m.state === "registered" ? `mcp:               tablation registered (user scope) \u2192 ${m.url}
-` : m.state === "no-claude" ? `mcp:               claude not found \u2014 Claude Code was not checked
+        const seenMcp = /* @__PURE__ */ new Set();
+        for (const tc of shipToolchains(cfg.ship)) {
+          const id = `${tc.harness}\0${tc.bin}`;
+          if (seenMcp.has(id)) continue;
+          seenMcp.add(id);
+          const adapter = adapterFor(tc.harness);
+          const m = adapter.inspectMcp({ bin: tc.bin, url: mcpUrl, key: route.apiKey });
+          process.stdout.write(
+            m.state === "registered" ? `mcp:               tablation registered (user scope) \u2192 ${m.url}
+` : m.state === "no-binary" ? `mcp:               ${tc.bin} not found \u2014 ${adapter.displayName} was not checked
 ` : m.state === "different" ? `mcp:               tablation registered but not for this route \u2014 ${m.detail}
 ` : `mcp:               not registered \u2014 run crew connect
 `
-        );
+          );
+        }
       }
       for (const c of cfg.routes.filter((r) => r.enabled)) {
         let repos;