patchcord 0.5.116 → 0.5.118

package/bin/patchcord.mjs

@@ -66,12 +66,20 @@ function detectFolder(dir) {
 }
 
 
-if (cmd === "help" || cmd === "--help" || cmd === "-h") {
+// A trailing --help/-h on ANY subcommand must show help and exit — never run the
+// command. (patchcord orchestrator --help used to PROVISION an orchestrator;
+// patchcord login --help hung on the browser login. Side-effecting --help is a
+// footgun.) We short-circuit here, before any account/provision/login dispatch.
+if (
+  cmd === "help" || cmd === "--help" || cmd === "-h" ||
+  process.argv.slice(3).some((a) => a === "--help" || a === "-h")
+) {
   console.log(`patchcord — cross-agent messaging + team orchestration for AI coding agents
 
 Two layers: THIS AGENT (a per-project identity, by bearer token) and your ACCOUNT
-(user-level; provisions agents, runs teams + schedules). Account/team/schedule
-commands authenticate the CLI in your browser automatically on first use.
+(user-level; provisions agents, runs teams + schedules). Run \`patchcord login\`
+once to authenticate the CLI; account/team/schedule commands then use that token
+(they never open a browser on their own).
 
 SETUP (per agent / project)
   patchcord                                  Set up this project's agent (browser)
@@ -89,12 +97,12 @@ THIS AGENT — identity + messaging
 ACCOUNT — log in to the CLI (commands below log in on demand)
   patchcord login                            Authenticate the CLI (your account)
 
-TEAMLEAD — set up the team-lead agent (the shepherd) in this folder
-  patchcord teamlead [--namespace <ns>] [--tool <harness>]
-                                             Provision the teamlead here; launch it
+ORCHESTRATOR — set up the orchestrator agent (the shepherd) in this folder
+  patchcord orchestrator [--namespace <ns>] [--tool <harness>]
+                                             Provision the orchestrator here; launch it
                                              to adopt this project or build a new team
 
-TEAM — the teamlead's tools (run from the project root)
+TEAM — the orchestrator's tools (run from the project root)
   patchcord provision <agent> --tool <X> --role <Y> --namespace <ns> [--dir <sub/>]
                                              Create a worker agent (identity + config)
   patchcord pull <agent> --tool <X> --namespace <ns> [--dir <sub/>]
@@ -341,8 +349,12 @@ async function _resolveBearer(options = {}) {
     );
   })();
 
-  const kimiGlobalReader = () => readJsonAt(join(HOME, ".kimi", "mcp.json"), ["mcpServers", "patchcord"], "kimi");
-  const kimiCodeGlobalReader = () => readJsonAt(join(process.env.KIMI_CODE_HOME || join(HOME, ".kimi-code"), "mcp.json"), ["mcpServers", "patchcord"], "kimi");
+  // NO global kimi/kimi-code reader. Kimi is a PER-PROJECT identity
+  // (.kimi-code/mcp.json in the worktree); a global ~/.kimi(-code)/mcp.json would
+  // make a leftover token hijack every kimi session everywhere. A kimi outside a
+  // patchcord worktree is simply not an agent. (The tools below are global-ONLY
+  // by nature — Windsurf/Gemini/Zed/etc. store MCP config globally — so they keep
+  // their global readers.)
   const defaultGlobalCandidates = [
     () => readJsonAt(join(HOME, ".codeium", "windsurf", "mcp_config.json"), ["mcpServers", "patchcord"], "windsurf"),
     () => readJsonAt(join(HOME, ".gemini", "settings.json"), ["mcpServers", "patchcord"], "gemini"),
@@ -352,9 +364,7 @@ async function _resolveBearer(options = {}) {
     () => readHermesShape(join(HOME, ".hermes", "config.yaml")),
     ...clinePaths.map((p) => () => readJsonAt(p, ["mcpServers", "patchcord"], "cline")),
   ];
-  const globalCandidates = preferKimi
-    ? [kimiGlobalReader, kimiCodeGlobalReader, ...defaultGlobalCandidates]
-    : [...defaultGlobalCandidates, kimiGlobalReader, kimiCodeGlobalReader];
+  const globalCandidates = defaultGlobalCandidates;
   for (const r of globalCandidates) {
     const found = r();
     if (found) { found.scope = "global"; return found; }
@@ -827,12 +837,12 @@ if (cmd === "subscribe") {
 // works the same as the space-form (--token foo). The internal flag parsing below
 // supports both. Non-flag commands (channel, init, skill, help, plugin-path) have
 // their own branches above and below.
-// ── CLI account auth + teamlead/team/provisioning/schedule ─────────────────
+// ── CLI account auth + orchestrator/team/provisioning/schedule ─────────────
 // These commands act on the user's ACCOUNT, so they require CLI login. The
 // account token (user-level, tied to NO agent) lives at ~/.patchcord/auth.json
 // (legacy: main.json / master.json) or $PATCHCORD_TOKEN (legacy: *_MAIN/MASTER).
 // `patchcord login` authenticates; everything else logs in on demand.
-if (cmd === "login" || cmd === "teamlead" || cmd === "provision" || cmd === "pull" || cmd === "team" || cmd === "schedule") {
+if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "provision" || cmd === "pull" || cmd === "team" || cmd === "schedule") {
   const M = { cyan: "\x1b[36m", green: "\x1b[32m", dim: "\x1b[2m", rst: "\x1b[0m" };
   const AUTH_CONFIG = join(HOME, ".patchcord", "auth.json");
   const LEGACY_CONFIGS = [join(HOME, ".patchcord", "main.json"), join(HOME, ".patchcord", "master.json")];
@@ -902,7 +912,19 @@ if (cmd === "login" || cmd === "teamlead" || cmd === "provision" || cmd === "pul
     return { token, baseUrl: DEFAULT_API };
   };
   // Auth on demand: any command needing the account logs in if not already.
-  const requireAuth = async () => readAuth() || await doLogin();
+  const requireAuth = async () => {
+    const a = readAuth();
+    if (a) return a;
+    // No account token. NEVER auto-drop into the interactive browser login here:
+    // doLogin() prints a URL and BLOCKS up to 15 minutes for a browser that never
+    // comes in a headless/agent context (the orchestrator misread that hang as
+    // "provision produced no output"). TTY detection is unreliable (a pty/agent
+    // shell can report isTTY=true), so we fail fast unconditionally. Only the
+    // explicit `patchcord login` command opens a browser.
+    console.error("No patchcord account token — no pcm- token in ~/.patchcord/auth.json or $PATCHCORD_TOKEN.");
+    console.error("Run `patchcord login` once (interactive), or set $PATCHCORD_TOKEN. Cannot continue.");
+    process.exit(1);
+  };
   // Account-authed request with stale-token recovery. If the server rejects the
   // stored token (401/403), forget it, re-log-in once, and retry. Returns the
   // _httpJSON result plus the auth used (for callers that need m.baseUrl).
@@ -910,9 +932,11 @@ if (cmd === "login" || cmd === "teamlead" || cmd === "provision" || cmd === "pul
     let m = await requireAuth();
     let r = await _httpJSON(method, `${m.baseUrl}${path}`, m.token, body);
     if (r.status === "401" || r.status === "403") {
+      // Stale/invalid account token. Forget it and fail fast — do NOT auto-relogin
+      // (would hang headless, see requireAuth). The user re-runs `patchcord login`.
       forgetAuth();
-      m = await doLogin();
-      r = await _httpJSON(method, `${m.baseUrl}${path}`, m.token, body);
+      console.error(`patchcord account token rejected (HTTP ${r.status}). Run \`patchcord login\` again. Cannot continue.`);
+      process.exit(1);
     }
     return { ...r, m };
   };
@@ -957,6 +981,31 @@ if (cmd === "login" || cmd === "teamlead" || cmd === "provision" || cmd === "pul
         o.mcpServers.patchcord = { serverUrl: `${baseUrl}/mcp`, headers: hdr };
       });
     }
+    if (tool === "hermes") {
+      // Hermes reads MCP servers ONLY from its GLOBAL ~/.hermes/config.yaml
+      // (mcp_servers key) — it ignores a project-local .mcp.json. So unlike the
+      // other tools we cannot write into `dir`; we upsert the global config,
+      // mirroring the `npx patchcord` installer's Hermes path. NOTE: global =
+      // one patchcord identity per machine, so provisioning a second hermes
+      // worker in another namespace overwrites the first's token. Single-hermes
+      // teams only until Hermes gains project-scoped MCP config.
+      const hermesPath = join(HOME, ".hermes", "config.yaml");
+      mkdirSync(dirname(hermesPath), { recursive: true });
+      let existingYaml = "";
+      try { existingYaml = existsSync(hermesPath) ? readFileSync(hermesPath, "utf-8") : ""; } catch {}
+      writeFileSync(hermesPath, upsertHermesConfig(existingYaml, `${baseUrl}/mcp`, token));
+      // Install the Hermes patchcord skills (inbox/subscribe/wait) so the worker
+      // knows the messaging flow, same as the installer does.
+      try {
+        const hermesSkillsSrc = join(pluginRoot, "per-project-skills", "hermes");
+        if (existsSync(hermesSkillsSrc)) {
+          const hermesSkillsDest = join(HOME, ".hermes", "skills", "integrations");
+          mkdirSync(hermesSkillsDest, { recursive: true });
+          cpSync(hermesSkillsSrc, hermesSkillsDest, { recursive: true });
+        }
+      } catch {}
+      return hermesPath;
+    }
     // default: claude_code. type:"http" is REQUIRED — without it Claude Code
     // defaults to stdio transport and rejects the entry ("command: expected
     // string, received undefined").
@@ -1046,27 +1095,34 @@ if (cmd === "login" || cmd === "teamlead" || cmd === "provision" || cmd === "pul
     process.exit(0);
   }
 
-  if (cmd === "teamlead") {
-    // Set up the TEAMLEAD agent in THIS folder. The teamlead is a distinct kind
-    // of agent — it shepherds a team: provisions, connects, and manages the
-    // other agents. It is NOT a normal agent: it gets its own identity, its own
-    // onboarding instruction, and on launch either ADOPTS this existing project
-    // or CREATES a new team by interviewing the user.
+  if (cmd === "orchestrator" || cmd === "teamlead") {
+    // Set up the ORCHESTRATOR agent in THIS folder. The orchestrator is a
+    // distinct kind of agent — it shepherds a team: provisions, connects, and
+    // manages the other agents. It is NOT a normal agent: it gets its own
+    // identity, its own onboarding instruction, and on launch either ADOPTS
+    // this existing project or CREATES a new team by interviewing the user.
+    // (`teamlead` is kept as a back-compat alias for the command name.)
     const root = process.cwd();
     const ns = (flagVal("namespace", basename(root)) || "team").replace(/[^a-z0-9-]/gi, "-").toLowerCase();
     const tool = flagVal("tool", "claude_code");
     const hostname = run("hostname -s") || run("hostname") || "unknown";
-    const { status, json, m } = await accountCall("POST", "/api/provision", { namespace_id: ns, agent_id: "teamlead", tool, role: "teamlead", label: "teamlead:self" });
-    if (status !== "200" || !json?.token) { console.error(`could not set up teamlead (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
+    const { status, json, m } = await accountCall("POST", "/api/provision", { namespace_id: ns, agent_id: "orchestrator", tool, role: "orchestrator", label: "orchestrator:self" });
+    if (status !== "200" || !json?.token) { console.error(`could not set up orchestrator (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
     const base = String(json.url || `${m.baseUrl}/mcp`).replace(/\/mcp$/, "");
     writeWorkerConfig(tool, root, base, json.token, hostname);
     mkdirSync(join(root, ".patchcord"), { recursive: true });
     const tj = join(root, ".patchcord", "team.json");
-    let manifest = { project: basename(root), namespace: ns, teamlead: { agent: "teamlead", tool }, agents: [] };
-    try { if (existsSync(tj)) manifest = { ...JSON.parse(readFileSync(tj, "utf-8")), namespace: ns, teamlead: { agent: "teamlead", tool } }; } catch {}
+    let manifest = { project: basename(root), namespace: ns, orchestrator: { agent: "orchestrator", tool }, agents: [] };
+    try {
+      if (existsSync(tj)) {
+        const prev = JSON.parse(readFileSync(tj, "utf-8"));
+        delete prev.teamlead; delete prev.main; delete prev.master; // drop pre-rename keys
+        manifest = { ...prev, namespace: ns, orchestrator: { agent: "orchestrator", tool } };
+      }
+    } catch {}
     writeFileSync(tj, JSON.stringify(manifest, null, 2) + "\n");
-    // The teamlead's onboarding instruction (read on launch).
-    writeFileSync(join(root, "TEAMLEAD.md"), `# You are the TEAMLEAD (${ns}:teamlead)
+    // The orchestrator's onboarding instruction (read on launch).
+    writeFileSync(join(root, "ORCHESTRATOR.md"), `# You are the ORCHESTRATOR (${ns}:orchestrator)
 
 You shepherd a team of patchcord agents in this folder. You are NOT a worker —
 you design the team, provision its agents, launch them, and manage them.
@@ -1079,14 +1135,16 @@ you design the team, provision its agents, launch them, and manage them.
    which roles/harnesses, how many — confirm the plan, then build it.
 
 ## Build / run
-- Provision each worker: \`patchcord provision <agent> --tool <claude_code|codex|opencode|kimi> --role <role> --namespace ${ns} --dir <agent>/\`
+- Provision each worker: \`patchcord provision <agent> --tool <claude_code|codex|opencode|kimi|agy> --role <role> --namespace ${ns} --dir <agent>/\`
+- Pull an existing agent into a folder: \`patchcord pull <agent> --tool <X> --namespace ${ns} --dir <agent>/\`
 - Launch: \`patchcord team launch\` (mux), verify with \`patchcord team status\`.
 - Coordinate over patchcord (inbox / send_message); manage at the meta level.
-- Your own identity here is ${ns}:teamlead — \`patchcord whoami\` confirms it.
+- Your own identity here is ${ns}:orchestrator — \`patchcord whoami\` confirms it.
 `);
-    console.log(`\n  ${M.green}✓${M.rst} Teamlead ready: ${M.green}${ns}:teamlead${M.rst} [${tool}] in ${root}`);
+    try { if (existsSync(join(root, "TEAMLEAD.md"))) unlinkSync(join(root, "TEAMLEAD.md")); } catch {} // remove pre-rename onboarding file
+    console.log(`\n  ${M.green}✓${M.rst} Orchestrator ready: ${M.green}${ns}:orchestrator${M.rst} [${tool}] in ${root}`);
     console.log(`  ${M.dim}Launch it here — it adopts this project or creates a new team, asking you:${M.rst}`);
-    console.log(`    mux new ${tool === "claude_code" ? "claude" : (tool === "kimi-code" ? "kimi" : tool)} --dir .`);
+    console.log(`    mux new ${tool === "claude_code" ? "claude" : (tool === "kimi-code" ? "kimi" : (tool === "antigravity" || tool === "agy") ? "agy" : tool)} --dir .`);
     process.exit(0);
   }
 
@@ -1160,10 +1218,10 @@ you design the team, provision its agents, launch them, and manage them.
         panes.push({ session, window, path: real(path), cmd, claimed: false });
       }
 
-      // Build the roster: teamlead first, then workers.
+      // Build the roster: orchestrator first, then workers.
       const roster = [];
-      const leadEntry = manifest.teamlead || manifest.main || manifest.master; // pre-rename names
-      if (leadEntry) roster.push({ ...leadEntry, role: "teamlead", dir: ".", _lead: true });
+      const leadEntry = manifest.orchestrator || manifest.teamlead || manifest.main || manifest.master; // pre-rename names
+      if (leadEntry) roster.push({ ...leadEntry, role: "orchestrator", dir: ".", _lead: true });
       for (const a of (manifest.agents || [])) roster.push(a);
 
       const rows = [];
@@ -3013,5 +3071,5 @@ if (cmd === "skill") {
   process.exit(0);
 }
 
-console.error(`Unknown command: ${cmd}. Available: install, whoami, agents, upload, subscribe, update, login, provision, pull, teamlead, team, schedule, --rename, --token, --agent-type, --version, --help`);
+console.error(`Unknown command: ${cmd}. Available: install, whoami, agents, upload, subscribe, update, login, provision, pull, orchestrator, team, schedule, --rename, --token, --agent-type, --version, --help`);
 process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchcord",
-  "version": "0.5.116",
+  "version": "0.5.118",
   "description": "Cross-machine agent messaging for Claude Code and Codex",
   "author": "ppravdin",
   "license": "MIT",

package/scripts/kimi-stop-hook.sh

@@ -18,23 +18,28 @@ INPUT=$(cat)
 STOP_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false' 2>/dev/null || echo "false")
 [ "$STOP_ACTIVE" = "true" ] && exit 0
 
-# Resolve MCP config: per-project first, then global
+# Resolve MCP config: PROJECT-scoped ONLY (walk up from cwd for .kimi/mcp.json).
+# NO global ~/.kimi/mcp.json fallback — a Kimi launched outside a patchcord
+# worktree is not that agent and must not be nagged. No MCP authed in the cwd
+# tree => no inbox check. (This Stop hook is registered globally in
+# ~/.kimi/config.toml, so the project-scoped token is the ONLY thing that should
+# make it act.)
 KIMI_MCP=""
 CWD=$(echo "$INPUT" | jq -r '.cwd // empty' 2>/dev/null || echo "")
 
 if [ -n "$CWD" ]; then
   dir="$CWD"
   while [ "$dir" != "/" ]; do
-    if [ -f "$dir/.kimi/mcp.json" ]; then
-      KIMI_MCP="$dir/.kimi/mcp.json"
+    if [ -f "$dir/.kimi-code/mcp.json" ]; then
+      KIMI_MCP="$dir/.kimi-code/mcp.json"
       break
     fi
     dir=$(dirname "$dir")
   done
 fi
 
-# Fallback to global config
-[ -z "$KIMI_MCP" ] && KIMI_MCP="${HOME}/.kimi/mcp.json"
+# No project-scoped .kimi-code/mcp.json in the cwd tree => not a patchcord agent here.
+[ -z "$KIMI_MCP" ] && exit 0
 
 TOKEN=""
 URL=""

package/scripts/kimi-subscribe.sh

@@ -14,25 +14,26 @@ set -euo pipefail
 
 command -v jq >/dev/null 2>&1 || { echo "jq required" >&2; exit 1; }
 
-# Resolve MCP config: per-project first, then global
+# Resolve MCP config: PROJECT-scoped ONLY (walk up from cwd for .kimi-code/mcp.json).
+# Kimi Code (the current product) uses .kimi-code/ — the legacy .kimi/ path is
+# deprecated and MUST NOT be used; it also mismatched where `patchcord provision`
+# writes the config (.kimi-code/mcp.json), so the listener never found it.
+# NO global fallback: auto-launched by the (global) SessionStart hook on EVERY
+# Kimi session, so a global fallback would start a listener for some leftover
+# identity in every folder. No project config in the cwd tree => no patchcord
+# agent here => exit quietly (0, not 1: must not spam stderr in non-patchcord dirs).
 KIMI_MCP=""
 dir="$PWD"
 while [ "$dir" != "/" ]; do
-  if [ -f "$dir/.kimi/mcp.json" ]; then
-    KIMI_MCP="$dir/.kimi/mcp.json"
+  if [ -f "$dir/.kimi-code/mcp.json" ]; then
+    KIMI_MCP="$dir/.kimi-code/mcp.json"
     break
   fi
   dir=$(dirname "$dir")
 done
 
-# Fallback to global config
-if [ -z "$KIMI_MCP" ]; then
-  KIMI_MCP="${HOME}/.kimi/mcp.json"
-fi
-
-if [ ! -f "$KIMI_MCP" ]; then
-  echo "Kimi MCP config not found at $KIMI_MCP or any parent — run npx patchcord@latest first" >&2
-  exit 1
+if [ -z "$KIMI_MCP" ] || [ ! -f "$KIMI_MCP" ]; then
+  exit 0
 fi
 
 TOKEN=$(jq -r '.mcpServers.patchcord.headers.Authorization // empty' "$KIMI_MCP" 2>/dev/null | sed 's/^Bearer //i' || true)