@tablation/crew 0.7.1 → 0.8.0

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve4, dirname as dirname9, join as join18, basename as basename7 } from "path";
+import { resolve as resolve4, dirname as dirname9, join as join19, basename as basename7 } from "path";
 import { fileURLToPath } from "url";
-import { hostname as hostname2, homedir as homedir4 } from "os";
-import { spawnSync as spawnSync2 } from "child_process";
+import { hostname as hostname2, homedir as homedir5 } from "os";
+import { spawnSync as spawnSync3 } from "child_process";
 
 // src/config.ts
 import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
@@ -7668,6 +7668,72 @@ function resolveRepoProject(projects, opt, routeAreaId) {
   );
 }
 
+// src/claude-mcp.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { readFileSync as readFileSync9 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join13 } 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(readFileSync9(join13(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;
@@ -7819,13 +7885,13 @@ function applyRemoteBranchCleanup(cwd, remote, branches2, dryRun, log) {
 
 // src/stream-sweep.ts
 import { existsSync as existsSync15, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync6 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 var DAY_MS = 24 * 60 * 60 * 1e3;
 function planStreamSweep(stateDir, retentionDays, now = Date.now()) {
-  const dir = join13(stateDir, "streams");
+  const dir = join14(stateDir, "streams");
   if (!existsSync15(dir)) return [];
   const cutoff = now - retentionDays * DAY_MS;
-  return readdirSync2(dir).map((name) => join13(dir, name)).filter((path) => {
+  return readdirSync2(dir).map((name) => join14(dir, name)).filter((path) => {
     try {
       return statSync6(path).mtimeMs < cutoff;
     } catch {
@@ -7852,18 +7918,18 @@ function applyStreamSweep(paths, dryRun, log) {
 }
 
 // src/cli.ts
-import { readFileSync as readFileSync12, existsSync as existsSync19, mkdirSync as mkdirSync10, writeFileSync as writeFileSync9, unlinkSync as unlinkSync5, copyFileSync, renameSync } from "fs";
+import { readFileSync as readFileSync13, existsSync as existsSync19, mkdirSync as mkdirSync10, writeFileSync as writeFileSync9, unlinkSync as unlinkSync5, copyFileSync, renameSync } from "fs";
 import { createInterface } from "readline/promises";
 import { dirname as dirOf, resolve as resolvePath } from "path";
 
 // src/ssh-keys.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync9, chmodSync } from "fs";
-import { dirname as dirname8, join as join14 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync10, chmodSync } from "fs";
+import { dirname as dirname8, join as join15 } from "path";
 var SshKeyError = class extends Error {
 };
 function shipSshKeyPathFor(stateDir) {
-  return join14(stateDir, "ssh", "id_ed25519");
+  return join15(stateDir, "ssh", "id_ed25519");
 }
 function ensureShipSshKeypair(stateDir) {
   const privateKeyPath = shipSshKeyPathFor(stateDir);
@@ -7892,7 +7958,7 @@ function ensureShipSshKeypair(stateDir) {
   if (!existsSync16(publicKeyPath)) {
     throw new SshKeyError(`${privateKeyPath} exists but ${publicKeyPath} does not \u2014 regenerate or restore it`);
   }
-  const publicKey = readFileSync9(publicKeyPath, "utf8").trim();
+  const publicKey = readFileSync10(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -8106,9 +8172,9 @@ function syncAllPassengerCheckouts(cfg) {
 
 // src/tunnel.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, readdirSync as readdirSync3 } from "fs";
 import { randomInt } from "crypto";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 var DEFAULT_SPAWN_OPTIONS = { stdio: "ignore", detached: true };
 var defaultSpawn = (cmd, args) => spawn3(cmd, args, DEFAULT_SPAWN_OPTIONS);
 var SLUG_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
@@ -8175,20 +8241,20 @@ function startTunnel(opts) {
   };
 }
 function tunnelStatePath(stateDir, workspaceId) {
-  return join15(stateDir, "passengers", `${workspaceId}.json`);
+  return join16(stateDir, "passengers", `${workspaceId}.json`);
 }
 function readPersistedTunnel(stateDir, workspaceId) {
   const path = tunnelStatePath(stateDir, workspaceId);
   if (!existsSync17(path)) return void 0;
   try {
-    return JSON.parse(readFileSync10(path, "utf8"));
+    return JSON.parse(readFileSync11(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedTunnel(stateDir, state) {
   const path = tunnelStatePath(stateDir, state.workspaceId);
-  mkdirSync8(join15(stateDir, "passengers"), { recursive: true });
+  mkdirSync8(join16(stateDir, "passengers"), { recursive: true });
   writeFileSync7(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -8286,7 +8352,7 @@ function syncPassengerTunnels(plans, relayHost, relayPort, privateKeyPath, state
   }
 }
 function readAllPersistedWorkspaceIds(stateDir) {
-  const dir = join15(stateDir, "passengers");
+  const dir = join16(stateDir, "passengers");
   if (!existsSync17(dir)) return [];
   return readdirSync3(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
@@ -8408,8 +8474,8 @@ async function unregisterEndpoint(workspaceId, info, d) {
 import { createServer as createHttpServer } from "http";
 import { spawn as spawn4 } from "child_process";
 import { randomBytes } from "crypto";
-import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync8, unlinkSync as unlinkSync4, readdirSync as readdirSync4 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync8, unlinkSync as unlinkSync4, readdirSync as readdirSync4 } from "fs";
+import { join as join17 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -8498,20 +8564,20 @@ var defaultSpawn2 = (cmd, args, env) => {
   return child;
 };
 function syncDaemonStatePath(stateDir, workspaceId) {
-  return join16(stateDir, "passengers", `${workspaceId}-sync.json`);
+  return join17(stateDir, "passengers", `${workspaceId}-sync.json`);
 }
 function readPersistedSyncDaemon(stateDir, workspaceId) {
   const path = syncDaemonStatePath(stateDir, workspaceId);
   if (!existsSync18(path)) return void 0;
   try {
-    return JSON.parse(readFileSync11(path, "utf8"));
+    return JSON.parse(readFileSync12(path, "utf8"));
   } catch {
     return void 0;
   }
 }
 function writePersistedSyncDaemon(stateDir, state) {
   const path = syncDaemonStatePath(stateDir, state.workspaceId);
-  mkdirSync9(join16(stateDir, "passengers"), { recursive: true });
+  mkdirSync9(join17(stateDir, "passengers"), { recursive: true });
   writeFileSync8(path, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -8532,7 +8598,7 @@ function waitForExit(pid, alive, timeoutMs = 5e3) {
   }
 }
 function readAllPersistedSyncWorkspaceIds(stateDir) {
-  const dir = join16(stateDir, "passengers");
+  const dir = join17(stateDir, "passengers");
   if (!existsSync18(dir)) return [];
   const suffix = "-sync.json";
   return readdirSync4(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
@@ -8591,7 +8657,7 @@ function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
 
 // src/daemon.ts
 import { readdirSync as readdirSync5, statSync as statSync7 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var DEFAULT_FLOOR_MS = 5e3;
 var DEFAULT_CEILING_MS = INTERVAL_SECONDS * 1e3;
 var defaultSleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
@@ -8630,7 +8696,7 @@ function latestMtime(path) {
   if (!stat.isDirectory()) return 0;
   let latest = stat.mtimeMs;
   for (const entry of readdirSync5(path, { withFileTypes: true })) {
-    latest = Math.max(latest, latestMtime(join17(path, entry.name)));
+    latest = Math.max(latest, latestMtime(join18(path, entry.name)));
   }
   return latest;
 }
@@ -9006,7 +9072,7 @@ function usage() {
                                  resume with no argument clears only the whole-crew pause; a role or release pause needs its own resume
   crew log [route]               tail the log
   crew inbox [--member NAME]    your tickets across every workspace (or a colleague's)
-  crew connect                  resolve a workspace's ids into a crew.yaml block
+  crew connect                  resolve a workspace's ids into a crew.yaml block (--no-mcp skips registering the Tablation MCP server with Claude Code; --mcp replace overwrites a different one)
   crew agents sync [route] [--force]   push crew's personas AND skill files into the workspace Agents/Agent Skills tables (--force overwrites even a diverged persona)
   crew agents prompt R [route] print one persona's current prompt (e.g. R=pair, for a SessionStart hook)
   crew skills sync [route]      push only crew's skill files (e.g. grill-me) into the workspace Agent Skills table
@@ -9350,14 +9416,14 @@ if (command === "passenger-sync-daemon") {
     }
     if (host === "linux" && hasSystemd) {
       const label = labelFor(CREW_HOME, "run");
-      const staleTimer = join18(homedir4(), ".config", "systemd", "user", `${label}.timer`);
+      const staleTimer = join19(homedir5(), ".config", "systemd", "user", `${label}.timer`);
       if (existsSync19(staleTimer)) {
         process.stdout.write(
           `removing stale run timer from before the persistent-service cutover: ${staleTimer}${dryRun ? " (dry run)" : ""}
 `
         );
         if (!dryRun) {
-          spawnSync2("systemctl", ["--user", "disable", "--now", `${label}.timer`], { cwd: CREW_HOME });
+          spawnSync3("systemctl", ["--user", "disable", "--now", `${label}.timer`], { cwd: CREW_HOME });
           try {
             unlinkSync5(staleTimer);
           } catch {
@@ -9395,7 +9461,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) => existsSync19(p);
-    const crontab = o.host === "linux" ? spawnSync2("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
+    const crontab = o.host === "linux" ? spawnSync3("crontab", ["-l"], { encoding: "utf8" }).stdout ?? "" : "";
     const schedulerAbsent = o.host !== "windows" ? !schedulerInstalled(planInstall(cfg.ship, CREW_HOME, o.host, detectSystemd(), "run"), unitExists, crontab) : true;
     const plan = planFix({ routes, schedulerAbsent, host: o.host });
     for (const n of plan.notes) process.stdout.write(`fix: ${n}
@@ -9411,7 +9477,7 @@ if (command === "passenger-sync-daemon") {
       for (const a of plan.actions) {
         if (a.kind === "enable") {
           if (prompter && !await prompter.confirm(`Route ${a.route} passes every check \u2014 set enabled: true in ${cfg.configFile}?`, false)) continue;
-          writeFileSync9(cfg.configFile, planEnable(readFileSync12(cfg.configFile, "utf8"), a.route));
+          writeFileSync9(cfg.configFile, planEnable(readFileSync13(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
@@ -10121,7 +10187,7 @@ ${changed2.map((c) => `  - ${c}
           }
           let failed = false;
           for (const cmd2 of commands) {
-            const res2 = spawnSync2(cmd2[0], cmd2.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
+            const res2 = spawnSync3(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)) {
@@ -10139,7 +10205,7 @@ ${changed2.map((c) => `  - ${c}
 `);
           break;
         }
-        const res = spawnSync2(cmd[0], cmd.slice(1), { cwd: CREW_HOME, encoding: "utf8" });
+        const res = spawnSync3(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)) {
@@ -10162,7 +10228,7 @@ ${changed2.map((c) => `  - ${c}
         process.exit(1);
       }
       requireArmed("run the daemon loop");
-      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join18(CREW_HOME, "src"), join18(CREW_HOME, "dist"), join18(CREW_HOME, "bin")];
+      const watchPaths = isCompiledBinary(import.meta.url) ? [process.execPath] : [join19(CREW_HOME, "src"), join19(CREW_HOME, "dist"), join19(CREW_HOME, "bin")];
       const spawnBreaker = new SpawnBreaker();
       const stopReason = await runDaemonLoop({
         runPass: () => runOnePass({
@@ -10310,7 +10376,7 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync19(resolvedPath) ? JSON.parse(readFileSync12(resolvedPath, "utf8")) : {};
+        const raw = existsSync19(resolvedPath) ? JSON.parse(readFileSync13(resolvedPath, "utf8")) : {};
         raw.agentPersonas = personaResult.agentPersonas;
         raw.agentSkills = skillResult.agentSkills;
         mkdirSync10(dirOf(resolvedPath), { recursive: true });
@@ -10359,7 +10425,7 @@ ${changed2.map((c) => `  - ${c}
 `);
       if (!dryRun) {
         const resolvedPath = resolvedPathFor(cfg.ship.stateDir, target.route);
-        const raw = existsSync19(resolvedPath) ? JSON.parse(readFileSync12(resolvedPath, "utf8")) : {};
+        const raw = existsSync19(resolvedPath) ? JSON.parse(readFileSync13(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
         mkdirSync10(dirOf(resolvedPath), { recursive: true });
         writeFileSync9(resolvedPath, `${JSON.stringify(raw, null, 2)}
@@ -10375,14 +10441,14 @@ ${changed2.map((c) => `  - ${c}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list") usage2();
-      const configText = readFileSync12(cfg.configFile, "utf8");
+      const configText = readFileSync13(cfg.configFile, "utf8");
       let routeName = positional[2];
       let addPath = ".";
       let addName;
       if (sub === "list" && !routeName) usage2();
       if (sub === "add") {
         try {
-          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync19(resolvePath(p.replace(/^~(?=\/|$)/, homedir4()))));
+          const a = parseAddArgs(positional.slice(2), routeNamesOf(configText), (p) => existsSync19(resolvePath(p.replace(/^~(?=\/|$)/, homedir5()))));
           routeName = a.route;
           addPath = a.path;
           addName = a.name;
@@ -10399,7 +10465,7 @@ ${changed2.map((c) => `  - ${c}
       let resolvedRemotes;
       if (existsSync19(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync12(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync13(resolvedFile, "utf8"));
         } catch {
         }
       }
@@ -10420,7 +10486,7 @@ ${changed2.map((c) => `  - ${c}
           }
           break;
         }
-        const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir4()));
+        const target = resolvePath(addPath.replace(/^~(?=\/|$)/, homedir5()));
         const top = existsSync19(target) ? gitOk(target, ["rev-parse", "--show-toplevel"]) : null;
         if (!top) throw new ReposError(`${target} is not a git checkout`);
         const origin = originOf(top);
@@ -10470,7 +10536,7 @@ ${changed2.map((c) => `  - ${c}
           process.stdout.write(`created Repos row ${String(rowPayload.name)} (${String(rowPayload.remote)}) ${created.id}
 `);
           if (existsSync19(resolvedFile)) {
-            const raw = JSON.parse(readFileSync12(resolvedFile, "utf8"));
+            const raw = JSON.parse(readFileSync13(resolvedFile, "utf8"));
             raw.repoNames = { ...raw.repoNames, [created.id]: String(rowPayload.name) };
             raw.repoRemotes = { ...raw.repoRemotes, [created.id]: String(rowPayload.remote) };
             writeFileSync9(resolvedFile, `${JSON.stringify(raw, null, 2)}
@@ -10705,7 +10771,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         const hadPreviousFile = existsSync19(resolvedPath);
         if (hadPreviousFile) {
           try {
-            previous = JSON.parse(readFileSync12(resolvedPath, "utf8"));
+            previous = JSON.parse(readFileSync13(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -10793,7 +10859,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
         const keyPersisted = keychainBacked || apiKeyFile !== void 0;
         const wizard = firstRun;
         const writeFirstRun = wizard !== void 0 && !dryRun && keyPersisted;
-        const routeDir = value("dir") ?? (writeFirstRun ? join18(DEFAULT_REPOS_BASE_PATH, found.workspaceSlug) : void 0);
+        const routeDir = value("dir") ?? (writeFirstRun ? join19(DEFAULT_REPOS_BASE_PATH, found.workspaceSlug) : void 0);
         const routeBlock = renderConnection(
           found,
           route2,
@@ -10813,6 +10879,11 @@ 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 })}
+`);
+        }
         if (found.provisioning.length) {
           process.stderr.write(`
   Provisioned for this machine (${ship.name}):
@@ -11231,7 +11302,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
     }
     case "log": {
       try {
-        const text = readFileSync12(cfg.ship.logFile, "utf8").split("\n");
+        const text = readFileSync13(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -11440,6 +11511,17 @@ git:               ${gitPath ? `OK (${gitPath})` : "NOT FOUND on the scheduler P
       if (!agentBinPath || !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\`.
+`
+        );
+      }
+      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
+` : m.state === "different" ? `mcp:               tablation registered but not for this route \u2014 ${m.detail}
+` : `mcp:               not registered \u2014 run crew connect
 `
         );
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.7.1",
+  "version": "0.8.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",