patchcord 0.5.113 → 0.5.115

package/bin/patchcord.mjs

@@ -294,6 +294,7 @@ async function _resolveBearer(options = {}) {
     (cwd) => readJsonAt(join(cwd, ".cursor", "mcp.json"), ["mcpServers", "patchcord"], "cursor"),
     (cwd) => readJsonAt(join(cwd, ".vscode", "mcp.json"), ["servers", "patchcord"], "vscode"),
     (cwd) => readJsonAt(join(cwd, "opencode.json"), ["mcp", "patchcord"], "opencode"),
+    (cwd) => readJsonAt(join(cwd, ".agents", "mcp_config.json"), ["mcpServers", "patchcord"], "antigravity"),
     (cwd) => readCodexTomlShape(join(cwd, ".codex", "config.toml")),
   ];
   const projectReaders = preferKimi
@@ -944,6 +945,15 @@ if (cmd === "login" || cmd === "teamlead" || cmd === "provision" || cmd === "tea
         o.mcp.patchcord = { type: "remote", url: `${baseUrl}/mcp`, headers: hdr };
       });
     }
+    if (tool === "antigravity" || tool === "agy") {
+      // Antigravity CLI: PROJECT-scoped config at .agents/mcp_config.json (one
+      // project = one namespace = one agent). Remote HTTP uses `serverUrl`.
+      const adir = join(dir, ".agents"); mkdirSync(adir, { recursive: true });
+      return writeJson(join(adir, "mcp_config.json"), (o) => {
+        o.mcpServers = o.mcpServers || {};
+        o.mcpServers.patchcord = { serverUrl: `${baseUrl}/mcp`, headers: hdr };
+      });
+    }
     // default: claude_code. type:"http" is REQUIRED — without it Claude Code
     // defaults to stdio transport and rejects the entry ("command: expected
     // string, received undefined").
@@ -1075,7 +1085,7 @@ you design the team, provision its agents, launch them, and manage them.
       if (!manifest) { console.error("No .patchcord/team.json here — cd into the project root."); process.exit(1); }
       const ns = manifest.namespace;
       const real = (p) => run(`realpath -m ${JSON.stringify(p)}`) || p;
-      const AGENT_CMDS = /(^|\/)(claude|codex|kimi|kimi-code|opencode|gemini|node)$/;
+      const AGENT_CMDS = /(^|\/)(claude|codex|kimi|kimi-code|opencode|gemini|agy|node)$/;
 
       // Token reader for a specific folder + tool (folder IS the identity).
       const tokenInDir = (tool, dir) => {
@@ -1184,7 +1194,7 @@ you design the team, provision its agents, launch them, and manage them.
       const tmuxOut = run(`tmux list-panes -a -F '#{pane_current_path}\t#{pane_current_command}'`);
       if (tmuxOut) for (const l of tmuxOut.split("\n").filter(Boolean)) {
         const [path, cmd] = l.split("\t");
-        if (/(^|\/)(claude|codex|kimi|kimi-code|opencode|gemini|node)$/.test("/" + cmd)) running.add(real(path));
+        if (/(^|\/)(claude|codex|kimi|kimi-code|opencode|gemini|agy|node)$/.test("/" + cmd)) running.add(real(path));
       }
       for (const a of (manifest.agents || [])) {
         const dir = join(process.cwd(), a.dir || a.agent);
@@ -1192,7 +1202,7 @@ you design the team, provision its agents, launch them, and manage them.
           console.log(`  ${M.dim}skip ${a.agent} — already running in ${dir}; relaunch-for-identity must resume in place, not fresh-launch (see team-ops skill).${M.rst}`);
           continue;
         }
-        const muxTool = a.tool === "claude_code" ? "claude" : (a.tool === "kimi-code" ? "kimi" : a.tool);
+        const muxTool = a.tool === "claude_code" ? "claude" : (a.tool === "kimi-code" ? "kimi" : (a.tool === "antigravity" || a.tool === "agy") ? "agy" : a.tool);
         console.log(`  launching ${a.agent} (${muxTool}) in ${dir}`);
         spawnSync("mux", ["new", muxTool, "--dir", dir], { stdio: "inherit" });
       }
@@ -1618,6 +1628,27 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     }
   }
 
+  // Hermes — refresh patchcord skills to the current version on every run, so
+  // skill fixes land via `patchcord update` (the interactive choice 13 only
+  // installs them once). ~/.hermes/skills is Hermes-only, so no leak risk; only
+  // refresh when the integrations dir already exists (Hermes was set up before).
+  {
+    const hermesSkillsSrc = join(pluginRoot, "per-project-skills", "hermes");
+    const hermesSkillsDest = join(HOME, ".hermes", "skills", "integrations");
+    if (existsSync(hermesSkillsDest) && existsSync(hermesSkillsSrc)) {
+      let hermesChanged = false;
+      for (const name of readdirSync(hermesSkillsSrc)) {
+        const src = join(hermesSkillsSrc, name, "SKILL.md");
+        if (!existsSync(src)) continue;
+        const dest = join(hermesSkillsDest, name, "SKILL.md");
+        const want = readFileSync(src, "utf-8");
+        let cur = ""; try { cur = readFileSync(dest, "utf-8"); } catch {}
+        if (cur !== want) { mkdirSync(dirname(dest), { recursive: true }); writeFileSync(dest, want); hermesChanged = true; }
+      }
+      if (hermesChanged) globalChanges.push("Hermes patchcord skills refreshed");
+    }
+  }
+
   // Kimi CLI
   const hasKimi = run("which kimi");
   if (hasKimi) {
@@ -1854,7 +1885,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     if (!choice) {
       console.log(`\n${bold}Which tool are you setting up?${r}\n`);
       console.log(`  ${cyan}1.${r} Claude Code   ${cyan}5.${r} Gemini CLI   ${cyan}9.${r} OpenClaw`);
-      console.log(`  ${cyan}2.${r} Codex CLI     ${cyan}6.${r} VS Code      ${cyan}10.${r} Antigravity`);
+      console.log(`  ${cyan}2.${r} Codex CLI     ${cyan}6.${r} VS Code      ${cyan}10.${r} Antigravity CLI`);
       console.log(`  ${cyan}3.${r} Cursor        ${cyan}7.${r} Zed          ${cyan}11.${r} Cline`);
       console.log(`  ${cyan}4.${r} Windsurf      ${cyan}8.${r} OpenCode     ${cyan}12.${r} Kimi CLI`);
       console.log(`  ${cyan}13.${r} Hermes\n`);
@@ -1942,6 +1973,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       // Figure out which tool is already configured
       const existingToolName = existingConfigFile.includes(".kimi") ? "Kimi CLI"
         : existingConfigFile.includes(".codex") ? "Codex"
+        : existingConfigFile.includes(".agents") ? "Antigravity CLI"
         : existingConfigFile.includes("antigravity") ? "Antigravity"
         : existingConfigFile.includes("openclaw") ? "OpenClaw"
         : existingConfigFile.includes(".cursor") ? "Cursor"
@@ -2393,9 +2425,13 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     console.log(`  ${dim}for streamable-http. Update to v2026.3.31+ or use mcp-remote:${r}`);
     console.log(`  ${dim}openclaw mcp set patchcord '{"command":"npx","args":["mcp-remote","${serverUrl}/mcp","--header","Authorization: Bearer ${token}"],"transport":"stdio"}'${r}`);
   } else if (isAntigravity) {
-    // Antigravity: global ~/.gemini/antigravity/mcp_config.json → mcpServers
-    const agDir = join(HOME, ".gemini", "antigravity");
-    const agPath = join(agDir, "mcp_config.json");
+    // Antigravity CLI: PROJECT-scoped config at <project>/.agents/mcp_config.json
+    // (one project = one namespace = one agent identity — never global, which
+    // would give one shared agent cross-project visibility). Remote HTTP uses
+    // the `serverUrl` key. Skills are NOT seeded globally here: a stray skill in
+    // the shared ~/.gemini/skills makes bare agy sessions improvise. The MCP
+    // server injects its own instructions once connected.
+    const agPath = join(cwd, ".agents", "mcp_config.json");
     const agOk = updateJsonConfig(agPath, (obj) => {
       obj.mcpServers = obj.mcpServers || {};
       obj.mcpServers.patchcord = {
@@ -2407,16 +2443,9 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       };
     });
     if (agOk) {
-      console.log(`\n  ${green}✓${r} Antigravity configured: ${dim}${agPath}${r}`);
-      // Install global skills
-      const agSkillDir = join(agDir, "skills", "patchcord");
-      const agWaitDir = join(agDir, "skills", "patchcord-wait");
-      mkdirSync(agSkillDir, { recursive: true });
-      mkdirSync(agWaitDir, { recursive: true });
-      cpSync(join(pluginRoot, "skills", "inbox", "SKILL.md"), join(agSkillDir, "SKILL.md"));
-      cpSync(join(pluginRoot, "skills", "wait", "SKILL.md"), join(agWaitDir, "SKILL.md"));
-      console.log(`  ${green}✓${r} Skills installed: ${dim}patchcord${r}, ${dim}patchcord-wait${r}`);
-      console.log(`  ${yellow}Global config — all Antigravity projects share this agent.${r}`);
+      console.log(`\n  ${green}✓${r} Antigravity CLI configured: ${dim}${agPath}${r}`);
+      console.log(`  ${yellow}Project config — this agent is scoped to ${cwd}.${r}`);
+      console.log(`  ${dim}Verify in agy with the /mcp slash command.${r}`);
     }
   } else if (isCline) {
     // Cline VS Code extension: global cline_mcp_settings.json
@@ -2815,9 +2844,9 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
   // Auto-add per-project configs with tokens to .gitignore (don't just warn —
   // a committed token gets clobbered/reverted by git and silently breaks auth).
   // Hermes is global config (~/.hermes/config.yaml) — no per-project file to ignore.
-  if (!isWindsurf && !isGemini && !isZed && !isOpenClaw && !isAntigravity && !isCline && !isHermes) {
+  if (!isWindsurf && !isGemini && !isZed && !isOpenClaw && !isCline && !isHermes) {
     const gitignorePath = join(cwd, ".gitignore");
-    const configFile = isKimiCode ? ".kimi-code/mcp.json" : isKimi ? ".kimi/mcp.json" : isCodex ? ".codex/config.toml" : isCursor ? ".cursor/mcp.json" : isVSCode ? ".vscode/mcp.json" : isOpenCode ? "opencode.json" : ".mcp.json";
+    const configFile = isKimiCode ? ".kimi-code/mcp.json" : isKimi ? ".kimi/mcp.json" : isCodex ? ".codex/config.toml" : isCursor ? ".cursor/mcp.json" : isVSCode ? ".vscode/mcp.json" : isOpenCode ? "opencode.json" : isAntigravity ? ".agents/mcp_config.json" : ".mcp.json";
     // Forms that already cover this config (its file or its dir)
     const patterns = [configFile];
     if (isKimiCode) patterns.push(".kimi-code/");
@@ -2825,6 +2854,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     else if (isCodex) patterns.push(".codex/");
     else if (isCursor) patterns.push(".cursor/");
     else if (isVSCode) patterns.push(".vscode/");
+    else if (isAntigravity) patterns.push(".agents/");
 
     const hasGitignore = existsSync(gitignorePath);
     // Only touch .gitignore inside a real git repo, or where one already exists.
@@ -2844,9 +2874,9 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     }
   }
 
-  const toolName = isHermes ? "Hermes" : isKimiCode ? "Kimi Code" : isKimi ? "Kimi CLI" : isAntigravity ? "Antigravity" : isCline ? "Cline" : isOpenClaw ? "OpenClaw" : isOpenCode ? "OpenCode" : isZed ? "Zed" : isVSCode ? "VS Code" : isGemini ? "Gemini CLI" : isWindsurf ? "Windsurf" : isCursor ? "Cursor" : isCodex ? "Codex" : "Claude Code";
+  const toolName = isHermes ? "Hermes" : isKimiCode ? "Kimi Code" : isKimi ? "Kimi CLI" : isAntigravity ? "Antigravity CLI" : isCline ? "Cline" : isOpenClaw ? "OpenClaw" : isOpenCode ? "OpenCode" : isZed ? "Zed" : isVSCode ? "VS Code" : isGemini ? "Gemini CLI" : isWindsurf ? "Windsurf" : isCursor ? "Cursor" : isCodex ? "Codex" : "Claude Code";
 
-  if (!isWindsurf && !isGemini && !isZed && !isOpenClaw && !isAntigravity && !isCline && !isKimi && !isHermes) {
+  if (!isWindsurf && !isGemini && !isZed && !isOpenClaw && !isCline && !isKimi && !isHermes) {
     console.log(`\n  ${dim}To connect a second agent:${r}`);
     console.log(`  ${dim}cd into another project and run${r} ${bold}npx patchcord@latest${r} ${dim}there.${r}`);
   }

package/package.json

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

package/per-project-skills/hermes/patchcord-inbox/SKILL.md

@@ -9,6 +9,8 @@ metadata:
 ---
 # Patchcord — inbox
 
+Applies only when the patchcord MCP tools (`mcp_patchcord_*`) are available this session. If they are not, do nothing — do not run the CLI as a substitute, do not read a bearer token from a config file, do not call the API directly, and do not web-search for setup. Just proceed with the user's request.
+
 ## When to use
 The user mentions patchcord / other agents / checking messages, or a Patchcord webhook fired ("new Patchcord messages").
 

package/per-project-skills/hermes/patchcord-subscribe/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: patchcord-subscribe
-description: Set up real-time Patchcord delivery so new messages wake this agent automatically via the gateway webhook bridge.
-version: 1.0.0
+description: Real-time Patchcord delivery options for Hermes. Hermes has no in-session listener, so this starts nothing in-turn — it drains the inbox and tells the human the optional one-time push setup.
+version: 2.0.0
 platforms: [macos, linux]
 metadata:
   hermes:
@@ -10,21 +10,19 @@ metadata:
 ---
 # Patchcord — subscribe (real-time)
 
-Hermes has no per-turn background-listener tool. Real-time delivery uses the
-gateway webhook plus the patchcord bridge: the bridge holds one realtime
-connection and POSTs to a Hermes webhook on each new message, and the always-on
-gateway injects a prompt that wakes the agent. No re-arm.
+Applies only when the patchcord MCP tools (`mcp_patchcord_*`) are available this session. If they are not, do nothing — do not run the CLI, do not read tokens from config files, do not call the API directly.
 
-## One-time setup
-1. Register a webhook route on the gateway:
-   `hermes webhook subscribe patchcord --prompt "You have new Patchcord messages. Run /patchcord-inbox now."`
-   Note the route URL it prints (e.g. `https://<gateway-host>/webhooks/patchcord`).
-2. Start the bridge under the gateway/tmux/systemd:
-   `PATCHCORD_HERMES_WEBHOOK=<route-url> patchcord subscribe --hermes`
-   It self-reconnects and survives JWT cycles — leave it running.
+**Hermes has no per-turn background-listener tool. There is nothing to start in this turn.** Do NOT web-search, do NOT fetch docs, do NOT guess or invent `hermes ...` commands.
 
-## When the webhook fires
-The gateway injects the prompt → run the **patchcord-inbox** skill: read inbox, reply to each message, report to the user.
+When invoked, do exactly this and stop:
+1. Run the **patchcord-inbox** skill now (drain anything pending).
+2. Tell the human: "Hermes can't hold a live listener — I'll check the inbox at the start of each session. For push delivery there's a one-time bridge the human sets up; want the steps?"
+3. Do not configure anything yourself.
 
-## No webhook available
-Fall back to polling: `hermes cron create` a job that runs `/patchcord-inbox` every few minutes.
+## One-time push setup (the HUMAN runs this, only if they ask)
+Real-time needs the patchcord bridge holding one realtime connection and POSTing to a Hermes webhook the human controls. Hand these to the human — never run them or invent command names yourself:
+- In Hermes, create a webhook route that, when it fires, injects the prompt: `You have new Patchcord messages. Run /patchcord-inbox now.` (Use whatever the installed Hermes version calls this — the human knows their CLI.)
+- Start the bridge pointed at that route URL and leave it running:
+  `PATCHCORD_HERMES_WEBHOOK=<route-url> patchcord subscribe --hermes`
+
+Once the bridge runs, each new message fires the webhook → the gateway wakes the agent → run **patchcord-inbox**. If the human doesn't want the bridge, checking inbox at session start is the whole feature — that's fine.

package/per-project-skills/hermes/patchcord-wait/SKILL.md

@@ -9,6 +9,8 @@ metadata:
 ---
 # Patchcord — wait
 
+Applies only when the patchcord MCP tools (`mcp_patchcord_*`) are available this session. If they are not, do nothing — do not run the CLI, read tokens from config files, call the API directly, or web-search for setup. Proceed with the user's request.
+
 ## When to use
 You sent a message and expect a reply, or the user asks you to wait for an incoming Patchcord message.