@tablation/crew 0.7.1 → 0.9.0

package/README.md

@@ -213,8 +213,8 @@ crew inbox [--member NAME]    your tickets across every workspace
 crew connect WS[/PROJECT]     resolve a workspace/project's ids into the state tree
 crew repos add [ROUTE] [NAME] [PATH]  attach a local checkout to a route in crew.yaml, creating its Repos row if missing (--dry-run previews)
 crew repos list ROUTE         the checkouts a route has, and the tracker Repos row each matches
-crew install                  write and load this platform's scheduler unit
-crew uninstall                unload and remove it
+crew install [--replace]     write and load this platform's scheduler unit (macOS: clears a crew installed from another path)
+crew uninstall [--all]        unload and remove it (--all: every crew launchd unit, whichever path it came from)
 ```
 
 Every command that could change something takes `--dry-run`.

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";
@@ -1930,7 +1930,7 @@ 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, statSync as statSync2, writeFileSync as writeFileSync2, unlinkSync, realpathSync } from "fs";
+import { accessSync, constants, existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync5, statSync as statSync2, writeFileSync as writeFileSync2, unlinkSync, realpathSync } from "fs";
 import { spawnSync } from "child_process";
 import { createHash } from "crypto";
 
@@ -2164,7 +2164,8 @@ function planUninstall(ship, crewHome, hostShip, hasSystemd, job = "run") {
       mechanism: "launchd",
       unitPaths: [unitPath],
       crontabLine: null,
-      unloadCommands: [["launchctl", "unload", unitPath]]
+      unloadCommands: [["launchctl", "unload", unitPath]],
+      removeLabel: label
     };
   }
   if (hostShip === "linux" && hasSystemd) {
@@ -2282,6 +2283,15 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
       if (!ok) log.warn("unload command failed \u2014 it may not have been loaded; continuing to remove files");
     }
   }
+  if (plan.removeLabel) {
+    if (dryRun) {
+      log.emit(`would run: launchctl remove ${plan.removeLabel}`);
+    } else {
+      if (spawnSync("launchctl", ["remove", plan.removeLabel], { encoding: "utf8" }).status === 0) {
+        log.emit(`removed loaded job ${plan.removeLabel}`);
+      }
+    }
+  }
   for (const path of plan.unitPaths) {
     if (!existsSync5(path)) continue;
     if (dryRun) {
@@ -2300,6 +2310,91 @@ async function applyUninstall(plan, crewHome, dryRun, log) {
     }
   }
 }
+var CREW_LAUNCHD_PREFIX = "com.tablation.crew";
+function launchAgentsDir() {
+  return join5(homedir2(), "Library", "LaunchAgents");
+}
+function xmlUnescape(s) {
+  return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+function programFromPlist(text) {
+  const block = /<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(text);
+  if (!block) return null;
+  const args = [...block[1].matchAll(/<string>([\s\S]*?)<\/string>/g)].map((m) => xmlUnescape(m[1]));
+  return args.find((a) => a.endsWith("/bin/crew")) ?? args[0] ?? null;
+}
+function listLaunchdUnits(dir = launchAgentsDir()) {
+  if (!existsSync5(dir)) return [];
+  return readdirSync(dir).filter((f) => f.startsWith(CREW_LAUNCHD_PREFIX) && f.endsWith(".plist")).sort().map((f) => {
+    const plistPath = join5(dir, f);
+    let program = null;
+    try {
+      program = programFromPlist(readFileSync5(plistPath, "utf8"));
+    } catch {
+    }
+    return {
+      label: f.slice(0, -".plist".length),
+      plistPath,
+      program,
+      programExists: program !== null && existsSync5(program)
+    };
+  });
+}
+function foreignLaunchdUnits(crewHome, dir) {
+  const own = new Set(["run", "release", "passengers"].map((job) => labelFor(crewHome, job)));
+  return listLaunchdUnits(dir).filter((u) => !own.has(u.label));
+}
+function removeLaunchdUnit(unit, dryRun, log) {
+  if (dryRun) {
+    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)) unlinkSync(unit.plistPath);
+  log.emit(`removed ${unit.label} (${unit.plistPath})`);
+}
+function clearForeignLaunchdUnits(crewHome, replace, dryRun, log, dir) {
+  const foreign = foreignLaunchdUnits(crewHome, dir);
+  const blocking = foreign.filter((u) => u.program === null || u.programExists);
+  if (blocking.length > 0 && !replace) {
+    log.warn(
+      `two crew installs target this machine: ${blocking.map((u) => `${u.label} runs ${u.program ?? "an unreadable ProgramArguments"}`).join("; ")}. Run \`crew uninstall\` from the other one, or pass --replace.`
+    );
+    return false;
+  }
+  for (const unit of foreign) {
+    const why = unit.program === null ? "replacing a unit with no readable ProgramArguments" : unit.programExists ? "replacing a live other install" : "removing a stale unit whose program is gone";
+    log.emit(`${why}: ${unit.label}`);
+    removeLaunchdUnit(unit, dryRun, log);
+  }
+  return true;
+}
+function removeAllLaunchdUnits(dryRun, log, dir) {
+  for (const unit of listLaunchdUnits(dir)) removeLaunchdUnit(unit, dryRun, log);
+}
+function parseLaunchctlList(text) {
+  const jobs = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n")) {
+    const cols = line.split("	");
+    if (cols.length !== 3 || cols[2] === "Label") continue;
+    jobs.set(cols[2], { pid: cols[0], lastExit: cols[1] });
+  }
+  return jobs;
+}
+function describeForeignLaunchdUnits(crewHome, dir) {
+  const foreign = foreignLaunchdUnits(crewHome, dir);
+  if (foreign.length === 0) return [];
+  const list = spawnSync("launchctl", ["list"], { encoding: "utf8" });
+  const jobs = parseLaunchctlList(list.status === 0 ? list.stdout ?? "" : "");
+  return foreign.map((u) => {
+    const status2 = jobs.get(u.label);
+    const loaded = status2 ? `loaded, last exit ${status2.lastExit}` : "not loaded";
+    const program = u.program ? `${u.program} (${u.programExists ? "present" : "GONE"})` : "no readable ProgramArguments";
+    const stale = status2 && !u.programExists ? " \u2014 stale: `crew install` removes it" : "";
+    return `  ${u.label}: ${loaded}; runs ${program}${stale}`;
+  });
+}
 function readCrontab() {
   const res = spawnSync("crontab", ["-l"], { encoding: "utf8" });
   return res.status === 0 ? res.stdout ?? "" : "";
@@ -4511,7 +4606,7 @@ var alreadyReported = (ticket, g, comments) => comments.some((c) => c.ticket_id
 
 // src/agent.ts
 import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync5, existsSync as existsSync7, statSync as statSync4, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, createWriteStream } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync7, statSync as statSync4, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, createWriteStream } from "fs";
 import { finished } from "stream/promises";
 import { join as join7, dirname as dirname5 } from "path";
 import { createHash as createHash2 } from "crypto";
@@ -4954,10 +5049,10 @@ function planAgentRun(o) {
   let ageSeconds;
   if (existsSync7(digestPath2)) {
     ageSeconds = Math.floor((now() - statSync4(digestPath2).mtimeMs) / 1e3);
-    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync5(digestPath2, "utf8");
+    if (ageSeconds <= DIGEST_MAX_AGE_SECONDS) digest = readFileSync6(digestPath2, "utf8");
   }
-  const common = readFileSync5(commonPath, "utf8");
-  const brief = readFileSync5(briefPath, "utf8");
+  const common = readFileSync6(commonPath, "utf8");
+  const brief = readFileSync6(briefPath, "utf8");
   const effectiveCommon = o.divergedPrompt ? "" : common;
   const effectiveBrief = o.divergedPrompt ?? brief;
   const prompt = assemblePrompt({
@@ -5337,7 +5432,7 @@ Wrote ${o.configPath}.
 }
 
 // src/release-run.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync9 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, existsSync as existsSync9 } from "fs";
 import { join as join9 } from "path";
 
 // src/release.ts
@@ -5802,7 +5897,7 @@ async function bump(o, size) {
     o.emit.error(`no ${o.repo.release.versionFiles[0]} to read a version from`);
     return null;
   }
-  const current = JSON.parse(readFileSync6(first, "utf8")).version;
+  const current = JSON.parse(readFileSync7(first, "utf8")).version;
   if (!current) {
     o.emit.error(`no version field in ${o.repo.release.versionFiles[0]}`);
     return null;
@@ -5815,7 +5910,7 @@ async function bump(o, size) {
     return version;
   }
   for (const f of files) {
-    const src = readFileSync6(f, "utf8");
+    const src = readFileSync7(f, "utf8");
     const out = src.replace(/("version"\s*:\s*")[^"]*(")/, `$1${version}$2`);
     if (out === src) {
       o.emit.error(`no version field in ${f}`);
@@ -5834,7 +5929,7 @@ function writeChangelog(o, version, entries) {
     o.emit.emit(`would prepend ${entries.length} entr(ies) to ${file}`);
     return;
   }
-  const existing = existsSync9(path) ? readFileSync6(path, "utf8") : "# Changelog\n";
+  const existing = existsSync9(path) ? readFileSync7(path, "utf8") : "# Changelog\n";
   writeFileSync6(path, insertChangelogSection(existing, section));
 }
 async function confirm(o, expected) {
@@ -6682,7 +6777,7 @@ function nextRoles(decision, ran) {
 }
 
 // src/agents.ts
-import { readFileSync as readFileSync7, existsSync as existsSync12 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync12 } from "fs";
 import { join as join11 } from "path";
 import { TablationClient as TablationClient2, StaleWriteError as StaleWriteError6, TablationApiError } from "@tablation/client";
 var PERSONA_NAME = {
@@ -6699,10 +6794,10 @@ var AgentsSyncError = class extends Error {
 function personaDefaultPrompt(promptsDir, role) {
   const briefPath = join11(promptsDir, "personas", `lane-${role}.md`);
   if (!existsSync12(briefPath)) throw new AgentsSyncError(`no brief at ${briefPath}`);
-  if (role === "pair") return readFileSync7(briefPath, "utf8");
+  if (role === "pair") return readFileSync8(briefPath, "utf8");
   const commonPath = join11(promptsDir, "personas", "common.md");
   if (!existsSync12(commonPath)) throw new AgentsSyncError(`no shared policy at ${commonPath}`);
-  return `${readFileSync7(commonPath, "utf8")}${readFileSync7(briefPath, "utf8")}`;
+  return `${readFileSync8(commonPath, "utf8")}${readFileSync8(briefPath, "utf8")}`;
 }
 async function resolveAgentId(route, role, opts) {
   const cached = route.resolved?.agentPersonas?.[role]?.agentId;
@@ -7323,14 +7418,14 @@ import {
 } from "@tablation/client";
 
 // src/skills.ts
-import { readFileSync as readFileSync8, readdirSync, existsSync as existsSync13 } from "fs";
+import { readFileSync as readFileSync9, readdirSync as readdirSync2, existsSync as existsSync13 } from "fs";
 import { join as join12 } 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 = readFileSync8(path, "utf8");
+  const text = readFileSync9(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];
@@ -7345,7 +7440,7 @@ function parseSkillFile(path) {
 function listLocalSkills(promptsDir) {
   const dir = join12(promptsDir, "skills");
   if (!existsSync13(dir)) return [];
-  return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join12(dir, f)));
+  return readdirSync2(dir).filter((f) => f.endsWith(".md")).map((f) => parseSkillFile(join12(dir, f)));
 }
 async function syncSkills(route, opts) {
   if (!route.resolved) {
@@ -7668,6 +7763,72 @@ 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 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(readFileSync10(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;
@@ -7818,14 +7979,14 @@ 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 { existsSync as existsSync15, readdirSync as readdirSync3, rmSync as rmSync2, statSync as statSync6 } from "fs";
+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 readdirSync3(dir).map((name) => join14(dir, name)).filter((path) => {
     try {
       return statSync6(path).mtimeMs < cutoff;
     } catch {
@@ -7852,18 +8013,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 readFileSync14, 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 readFileSync11, 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 +8053,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 = readFileSync11(publicKeyPath, "utf8").trim();
   return { privateKeyPath, publicKeyPath, publicKey };
 }
 function sshKeygenAvailable() {
@@ -8106,9 +8267,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 readFileSync12, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, readdirSync as readdirSync4 } 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 +8336,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(readFileSync12(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,9 +8447,9 @@ 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));
+  return readdirSync4(dir).filter((f) => f.endsWith(".json") && !f.endsWith("-sync.json")).map((f) => f.slice(0, -".json".length));
 }
 
 // src/mcp-endpoint-registry.ts
@@ -8408,8 +8569,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 readFileSync13, writeFileSync as writeFileSync8, unlinkSync as unlinkSync4, readdirSync as readdirSync5 } from "fs";
+import { join as join17 } from "path";
 
 // src/secret-compare.ts
 import { timingSafeEqual } from "crypto";
@@ -8498,20 +8659,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(readFileSync13(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,10 +8693,10 @@ 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));
+  return readdirSync5(dir).filter((f) => f.endsWith(suffix)).map((f) => f.slice(0, -suffix.length));
 }
 function syncPassengerSyncDaemons(plans, cfg, stateDir, deps = {}) {
   const alive = deps.isPidAlive ?? isPidAlive;
@@ -8590,8 +8751,8 @@ 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 { readdirSync as readdirSync6, statSync as statSync7 } from "fs";
+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));
@@ -8629,8 +8790,8 @@ function latestMtime(path) {
   if (stat.isFile()) return stat.mtimeMs;
   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)));
+  for (const entry of readdirSync6(path, { withFileTypes: true })) {
+    latest = Math.max(latest, latestMtime(join18(path, entry.name)));
   }
   return latest;
 }
@@ -9006,7 +9167,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
@@ -9308,12 +9469,21 @@ if (command === "passenger-sync-daemon") {
     const trimmed = typeof raw === "string" ? raw.trim() : "";
     return trimmed ? `${trimmed.toLowerCase()}-` : void 0;
   }
-  async function installScheduler() {
+  async function installScheduler(opts = {}) {
     const host = hostPlatform();
     if (host === "windows") {
       process.stderr.write("crew install: no scheduler support yet for Windows (Task Scheduler is planned, not built)\n");
       process.exit(2);
     }
+    if (host === "macos") {
+      const ok = clearForeignLaunchdUnits(CREW_HOME, !!opts.replace, dryRun, {
+        emit: (m) => process.stdout.write(`${m}
+`),
+        warn: (m) => process.stderr.write(`crew install: ${m}
+`)
+      });
+      if (!ok) return false;
+    }
     const installPathProblem = cfg.routes.some((r) => r.enabled && r.hostPassengers) ? dockerPathProblem(cfg.ship) : void 0;
     if (installPathProblem) {
       process.stderr.write(`crew install: Host Passengers is on but ${installPathProblem}
@@ -9350,14 +9520,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 {
@@ -9365,6 +9535,7 @@ if (command === "passenger-sync-daemon") {
         }
       }
     }
+    return true;
   }
   async function routeProblems(c) {
     const host = hostPlatform();
@@ -9395,7 +9566,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,14 +9582,13 @@ 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(readFileSync14(cfg.configFile, "utf8"), a.route));
           enabledSound.add(a.route);
           changed2.push(`enabled route ${a.route} in ${cfg.configFile}`);
         } else {
           if (enabledSound.size === 0) continue;
           if (prompter && !await prompter.confirm("No scheduler is installed for this ship \u2014 run `crew install` now?", false)) continue;
-          await installScheduler();
-          changed2.push("ran `crew install` (scheduler units written and loaded)");
+          if (await installScheduler()) changed2.push("ran `crew install` (scheduler units written and loaded)");
         }
       }
     } finally {
@@ -10121,7 +10291,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 +10309,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 +10332,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 +10480,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(readFileSync14(resolvedPath, "utf8")) : {};
         raw.agentPersonas = personaResult.agentPersonas;
         raw.agentSkills = skillResult.agentSkills;
         mkdirSync10(dirOf(resolvedPath), { recursive: true });
@@ -10359,7 +10529,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(readFileSync14(resolvedPath, "utf8")) : {};
         raw.agentSkills = result.agentSkills;
         mkdirSync10(dirOf(resolvedPath), { recursive: true });
         writeFileSync9(resolvedPath, `${JSON.stringify(raw, null, 2)}
@@ -10375,14 +10545,14 @@ ${changed2.map((c) => `  - ${c}
         process.exit(2);
       };
       if (sub !== "add" && sub !== "list") usage2();
-      const configText = readFileSync12(cfg.configFile, "utf8");
+      const configText = readFileSync14(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 +10569,7 @@ ${changed2.map((c) => `  - ${c}
       let resolvedRemotes;
       if (existsSync19(resolvedFile)) {
         try {
-          resolvedRemotes = JSON.parse(readFileSync12(resolvedFile, "utf8"));
+          resolvedRemotes = JSON.parse(readFileSync14(resolvedFile, "utf8"));
         } catch {
         }
       }
@@ -10420,7 +10590,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 +10640,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(readFileSync14(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 +10875,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(readFileSync14(resolvedPath, "utf8"));
           } catch {
           }
         }
@@ -10793,7 +10963,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 +10983,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}):
@@ -11203,7 +11378,7 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
       break;
     }
     case "install": {
-      await installScheduler();
+      if (!await installScheduler({ replace: flag("replace") })) process.exit(2);
       break;
     }
     case "uninstall": {
@@ -11220,6 +11395,16 @@ Signed in as ${result.identity.email} \u2014 minted an API key in workspace "${r
           emit: (m) => process.stdout.write(`${m}
 `),
           warn: (m) => process.stderr.write(`crew uninstall: ${m}
+`)
+        });
+      }
+      if (flag("all") && host === "macos") {
+        process.stdout.write(`uninstalling every crew launchd unit${dryRun ? " (dry run)" : ""}
+`);
+        removeAllLaunchdUnits(dryRun, {
+          emit: (m) => process.stdout.write(`${m}
+`),
+          warn: (m) => process.stderr.write(`crew uninstall: ${m}
 `)
         });
       }
@@ -11231,7 +11416,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 = readFileSync14(cfg.ship.logFile, "utf8").split("\n");
         process.stdout.write(`${text.slice(-(Number(value("tail")) || 40)).join("\n")}
 `);
       } catch {
@@ -11440,6 +11625,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
 `
         );
       }
@@ -11475,6 +11671,14 @@ git:               ${gitPath ? `OK (${gitPath})` : "NOT FOUND on the scheduler P
         process.stdout.write(`attention:         ${i.kind} \u2014 ${i.message} (since ${i.since})
 `);
       }
+      if (host === "macos") {
+        const foreign = describeForeignLaunchdUnits(CREW_HOME);
+        if (foreign.length > 0) {
+          process.stdout.write(`foreign launchd units (not this checkout's \u2014 \`crew install\` or \`crew uninstall --all\` clears them):
+${foreign.join("\n")}
+`);
+        }
+      }
       const passengerRoutes = cfg.routes.filter((r) => r.enabled && r.hostPassengers);
       if (passengerRoutes.length === 0) {
         process.stdout.write("host passengers:   off (no enabled route sets hostPassengers: true)\n");

package/package.json

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