patchcord 0.5.91 → 0.5.94

package/bin/patchcord.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { existsSync, mkdirSync, cpSync, readdirSync } from "fs";
+import { existsSync, mkdirSync, cpSync, readdirSync, readFileSync } from "fs";
 import { join, dirname, basename } from "path";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
@@ -107,6 +107,64 @@ function _kimiContextRequested(options = {}) {
     || Boolean(process.env.KIMI_MCP_CONFIG_FILE);
 }
 
+// Insert-or-update mcp_servers.patchcord in a Hermes ~/.hermes/config.yaml,
+// preserving the rest of the user's YAML. Block-style only (what Hermes writes).
+function upsertHermesConfig(existing, url, token) {
+  const block = [
+    "  patchcord:",
+    `    url: "${url}"`,
+    "    headers:",
+    `      Authorization: "Bearer ${token}"`,
+  ];
+  if (!existing.trim()) return `mcp_servers:\n${block.join("\n")}\n`;
+  const lines = existing.split(/\r?\n/);
+  const mcpIdx = lines.findIndex((l) => /^mcp_servers:\s*$/.test(l));
+  if (mcpIdx === -1) {
+    const sep = existing.endsWith("\n") ? "" : "\n";
+    return existing + sep + `\nmcp_servers:\n${block.join("\n")}\n`;
+  }
+  let end = lines.length;
+  for (let i = mcpIdx + 1; i < lines.length; i++) {
+    if (lines[i].trim() === "") continue;
+    if (/^\S/.test(lines[i])) { end = i; break; }
+  }
+  let pcStart = -1;
+  for (let i = mcpIdx + 1; i < end; i++) {
+    if (/^\s+patchcord:\s*$/.test(lines[i])) { pcStart = i; break; }
+  }
+  if (pcStart !== -1) {
+    const pcIndent = lines[pcStart].match(/^(\s*)/)[1].length;
+    let pcEnd = end;
+    for (let i = pcStart + 1; i < end; i++) {
+      if (lines[i].trim() === "") continue;
+      if (lines[i].match(/^(\s*)/)[1].length <= pcIndent) { pcEnd = i; break; }
+    }
+    return [...lines.slice(0, pcStart), ...block, ...lines.slice(pcEnd)].join("\n").replace(/\n*$/, "\n");
+  }
+  return [...lines.slice(0, mcpIdx + 1), ...block, ...lines.slice(mcpIdx + 1)].join("\n").replace(/\n*$/, "\n");
+}
+
+// Read url + bearer token from a Hermes config.yaml's mcp_servers.patchcord.
+function readHermesShape(path) {
+  if (!existsSync(path)) return null;
+  let text;
+  try { text = readFileSync(path, "utf-8"); } catch { return null; }
+  const lines = text.split(/\r?\n/);
+  const pc = lines.findIndex((l) => /^\s{2}patchcord:\s*$/.test(l));
+  if (pc === -1) return null;
+  let url = null, token = null;
+  for (let i = pc + 1; i < lines.length; i++) {
+    if (lines[i].trim() === "") continue;
+    if (lines[i].match(/^(\s*)/)[1].length <= 2) break;
+    const um = lines[i].match(/url:\s*"?([^"\n]+?)"?\s*$/);
+    if (um && !url) url = um[1].trim();
+    const am = lines[i].match(/Authorization:\s*"?Bearer\s+([^"\n]+?)"?\s*$/);
+    if (am && !token) token = am[1].trim();
+  }
+  if (!url || !token) return null;
+  return { token, baseUrl: url.replace(/\/mcp(\/bearer)?$/, ""), configFile: path, tool: "hermes" };
+}
+
 async function _resolveBearer(options = {}) {
   const { readFileSync } = await import("fs");
   const preferKimi = _kimiContextRequested(options);
@@ -200,6 +258,7 @@ async function _resolveBearer(options = {}) {
 
   // Per-project (walk up from cwd). First win.
   const kimiProjectReader = (cwd) => readJsonAt(join(cwd, ".kimi", "mcp.json"), ["mcpServers", "patchcord"], "kimi");
+  const kimiCodeProjectReader = (cwd) => readJsonAt(join(cwd, ".kimi-code", "mcp.json"), ["mcpServers", "patchcord"], "kimi");
   const defaultProjectReaders = [
     (cwd) => readJsonAt(join(cwd, ".mcp.json"), ["mcpServers", "patchcord"], "claude_code"),
     (cwd) => readJsonAt(join(cwd, ".cursor", "mcp.json"), ["mcpServers", "patchcord"], "cursor"),
@@ -208,8 +267,8 @@ async function _resolveBearer(options = {}) {
     (cwd) => readCodexTomlShape(join(cwd, ".codex", "config.toml")),
   ];
   const projectReaders = preferKimi
-    ? [kimiProjectReader, ...defaultProjectReaders]
-    : [...defaultProjectReaders, kimiProjectReader];
+    ? [kimiProjectReader, kimiCodeProjectReader, ...defaultProjectReaders]
+    : [...defaultProjectReaders, kimiProjectReader, kimiCodeProjectReader];
   let dir = process.cwd();
   while (dir && dir !== "/") {
     for (const r of projectReaders) {
@@ -249,17 +308,19 @@ 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");
   const defaultGlobalCandidates = [
     () => readJsonAt(join(HOME, ".codeium", "windsurf", "mcp_config.json"), ["mcpServers", "patchcord"], "windsurf"),
     () => readJsonAt(join(HOME, ".gemini", "settings.json"), ["mcpServers", "patchcord"], "gemini"),
     () => readJsonAt(zedPath, ["context_servers", "patchcord"], "zed"),
     () => readJsonAt(join(HOME, ".openclaw", "openclaw.json"), ["mcp", "servers", "patchcord"], "openclaw"),
     () => readJsonAt(join(HOME, ".gemini", "antigravity", "mcp_config.json"), ["mcpServers", "patchcord"], "antigravity"),
+    () => readHermesShape(join(HOME, ".hermes", "config.yaml")),
     ...clinePaths.map((p) => () => readJsonAt(p, ["mcpServers", "patchcord"], "cline")),
   ];
   const globalCandidates = preferKimi
-    ? [kimiGlobalReader, ...defaultGlobalCandidates]
-    : [...defaultGlobalCandidates, kimiGlobalReader];
+    ? [kimiGlobalReader, kimiCodeGlobalReader, ...defaultGlobalCandidates]
+    : [...defaultGlobalCandidates, kimiGlobalReader, kimiCodeGlobalReader];
   for (const r of globalCandidates) {
     const found = r();
     if (found) return found;
@@ -1225,7 +1286,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
   const CLIENT_TYPE_MAP = {
     "claude_code": "1", "codex": "2", "cursor": "3", "windsurf": "4",
     "gemini": "5", "vscode": "6", "zed": "7", "opencode": "8", "openclaw": "9", "antigravity": "10",
-    "cline": "11", "kimi": "12",
+    "cline": "11", "kimi": "12", "hermes": "13",
   };
 
 
@@ -1280,9 +1341,10 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       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}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\n`);
-      choice = (await ask(`${dim}Choose (1-12):${r} `)).trim();
-      if (!["1","2","3","4","5","6","7","8","9","10","11","12"].includes(choice)) {
+      console.log(`  ${cyan}4.${r} Windsurf      ${cyan}8.${r} OpenCode     ${cyan}12.${r} Kimi CLI`);
+      console.log(`  ${cyan}13.${r} Hermes\n`);
+      choice = (await ask(`${dim}Choose (1-13):${r} `)).trim();
+      if (!["1","2","3","4","5","6","7","8","9","10","11","12","13"].includes(choice)) {
         console.error("Invalid choice.");
         rl.close();
         process.exit(1);
@@ -1607,6 +1669,23 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
   const isAntigravity = choice === "10";
   const isCline = choice === "11";
   const isKimi = choice === "12";
+  const isHermes = choice === "13";
+
+  // MoonshotAI ships TWO CLIs that both use the `kimi` command:
+  //   • kimi-cli (Python): supports `--mcp-config-file`, config in .kimi/mcp.json
+  //   • Kimi Code (Node):  no such flag — auto-merges project-local .kimi-code/mcp.json
+  // Detect Kimi Code by its home dir, or by `kimi --help` lacking the old flag.
+  const kimiCodeHome = process.env.KIMI_CODE_HOME || join(HOME, ".kimi-code");
+  let isKimiCode = false;
+  if (isKimi) {
+    let kimiHelp = "";
+    try {
+      kimiHelp = execSync("kimi --help 2>&1", { encoding: "utf-8", timeout: 4000, stdio: "pipe" });
+    } catch (e) {
+      kimiHelp = e && e.stdout ? String(e.stdout) : "";
+    }
+    isKimiCode = existsSync(kimiCodeHome) || (kimiHelp.length > 0 && !/mcp-config-file/.test(kimiHelp));
+  }
 
   const hostname = run("hostname -s") || run("hostname") || "unknown";
 
@@ -1635,6 +1714,29 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       console.log(`\n  ${green}✓${r} Cursor configured: ${dim}${cursorPath}${r}`);
       console.log(`  ${dim}Per-project only — other projects won't see this agent.${r}`);
     }
+  } else if (isHermes) {
+    // Hermes: global only (~/.hermes/config.yaml, YAML, mcp_servers key)
+    const hermesPath = join(HOME, ".hermes", "config.yaml");
+    mkdirSync(dirname(hermesPath), { recursive: true });
+    let existingYaml = "";
+    try { existingYaml = existsSync(hermesPath) ? readFileSync(hermesPath, "utf-8") : ""; } catch {}
+    try {
+      writeFileSync(hermesPath, upsertHermesConfig(existingYaml, `${serverUrl}/mcp`, token));
+      console.log(`\n  ${green}✓${r} Hermes configured: ${dim}${hermesPath}${r}`);
+      console.log(`  ${dim}Run ${r}${bold}/reload-mcp${r}${dim} in Hermes to pick it up.${r}`);
+    } catch (e) {
+      console.log(`\n  ${yellow}⚠ Failed to write ${hermesPath}: ${e.message}${r}`);
+    }
+    // Install Hermes skills to ~/.hermes/skills/integrations/
+    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 });
+        console.log(`  ${green}✓${r} Hermes skills installed: ${dim}${hermesSkillsDest}${r}`);
+      }
+    } catch {}
   } else if (isWindsurf) {
     // Windsurf: global only (~/.codeium/windsurf/mcp_config.json)
     const wsPath = join(HOME, ".codeium", "windsurf", "mcp_config.json");
@@ -1839,8 +1941,36 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       console.log(`\n  ${green}✓${r} Cline configured: ${dim}${clinePath}${r}`);
       console.log(`  ${yellow}Global config — all Cline projects share this agent.${r}`);
     }
+  } else if (isKimi && isKimiCode) {
+    // Kimi Code (Node/TS): project-local .kimi-code/mcp.json is auto-merged on
+    // startup — no --mcp-config-file flag and no wrapper. Just run `kimi`.
+    const kcDir = join(cwd, ".kimi-code");
+    const kcPath = join(kcDir, "mcp.json");
+    const kcOk = updateJsonConfig(kcPath, (obj) => {
+      obj.mcpServers = obj.mcpServers || {};
+      obj.mcpServers.patchcord = {
+        url: `${serverUrl}/mcp`,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "X-Patchcord-Machine": hostname,
+        },
+      };
+    });
+    if (kcOk) {
+      console.log(`\n  ${green}✓${r} Kimi Code configured: ${dim}${kcPath}${r}`);
+      console.log(`  ${dim}Kimi Code auto-loads project-local .kimi-code/mcp.json — just run ${r}${bold}kimi${r}${dim} in this project (no wrapper needed).${r}`);
+    }
+    // Skills → user-level Kimi Code skills dir
+    try {
+      for (const [label, rel] of [["patchcord:inbox", "inbox"], ["patchcord:wait", "wait"], ["patchcord:subscribe", "subscribe"]]) {
+        const dest = join(kimiCodeHome, "skills", label);
+        mkdirSync(dest, { recursive: true });
+        cpSync(join(pluginRoot, "per-project-skills", "kimi", rel, "SKILL.md"), join(dest, "SKILL.md"));
+      }
+      console.log(`  ${green}✓${r} Skills installed: ${dim}${join(kimiCodeHome, "skills")}${r}`);
+    } catch {}
   } else if (isKimi) {
-    // Kimi CLI: per-project .kimi/mcp.json + shell wrapper for --mcp-config-file
+    // Kimi CLI (Python): per-project .kimi/mcp.json + shell wrapper for --mcp-config-file
     const kimiDir = join(cwd, ".kimi");
     const kimiPath = join(kimiDir, "mcp.json");
     const kimiOk = updateJsonConfig(kimiPath, (obj) => {
@@ -2140,34 +2270,49 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     }
   }
 
-  // Warn about gitignore for per-project configs with tokens
-  if (!isWindsurf && !isGemini && !isZed && !isOpenClaw && !isAntigravity && !isCline && !isKimi) {
+  // 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) {
     const gitignorePath = join(cwd, ".gitignore");
-    const configFile = isCodex ? ".codex/config.toml" : isCursor ? ".cursor/mcp.json" : isVSCode ? ".vscode/mcp.json" : isOpenCode ? "opencode.json" : ".mcp.json";
-    let needsWarning = true;
-    if (existsSync(gitignorePath)) {
-      const gi = readFileSync(gitignorePath, "utf-8");
-      // Only check patterns relevant to this agent's config file
-      const patterns = [configFile];
-      if (isCodex) patterns.push(".codex/");
-      else if (isCursor) patterns.push(".cursor/");
-      else if (isVSCode) patterns.push(".vscode/");
-      if (patterns.some(p => gi.includes(p))) needsWarning = false;
-    }
-    if (needsWarning) {
-      console.log(`\n  ${yellow}⚠ Add ${configFile} to .gitignore — it contains your token${r}`);
+    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";
+    // Forms that already cover this config (its file or its dir)
+    const patterns = [configFile];
+    if (isKimiCode) patterns.push(".kimi-code/");
+    else if (isKimi) patterns.push(".kimi/");
+    else if (isCodex) patterns.push(".codex/");
+    else if (isCursor) patterns.push(".cursor/");
+    else if (isVSCode) patterns.push(".vscode/");
+
+    const hasGitignore = existsSync(gitignorePath);
+    // Only touch .gitignore inside a real git repo, or where one already exists.
+    if (hasGitignore || existsSync(join(cwd, ".git"))) {
+      const gi = hasGitignore ? readFileSync(gitignorePath, "utf-8") : "";
+      const alreadyIgnored = patterns.some(p => gi.includes(p));
+      if (!alreadyIgnored) {
+        const prefix = gi.length && !gi.endsWith("\n") ? "\n" : "";
+        const block = `${prefix}\n# patchcord — holds your auth token, never commit\n${configFile}\n`;
+        try {
+          writeFileSync(gitignorePath, gi + block);
+          console.log(`\n  ${green}✓${r} Added ${bold}${configFile}${r} to .gitignore ${dim}(it holds your token)${r}`);
+        } catch {
+          console.log(`\n  ${yellow}⚠ Add ${configFile} to .gitignore — it contains your token${r}`);
+        }
+      }
     }
   }
 
-  const toolName = 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" : 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) {
+  if (!isWindsurf && !isGemini && !isZed && !isOpenClaw && !isAntigravity && !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}`);
   }
 
   if (isOpenClaw) {
     console.log(`\n${dim}Run${r} ${bold}openclaw gateway restart${r}${dim}, then tools will be available in your channels.${r}`);
+  } else if (isKimiCode) {
+    console.log(`\n  ${green}→${r} ${bold}Restart ${cyan}kimi${r}${bold} in this project (or run ${cyan}/reload${r}${bold}), then say: ${cyan}${bold}check inbox${r}`);
   } else if (isKimi) {
     console.log(`\n  ${green}→${r} ${bold}Restart your ${toolName} session with ${cyan}kimi-pc${r}${bold}, then say: ${cyan}${bold}check inbox${r}`);
   } else {

package/package.json

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

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

@@ -0,0 +1,23 @@
+---
+name: patchcord-inbox
+description: Check the Patchcord inbox and reply to messages from other agents. Use when the user mentions patchcord, inbox, other agents, or a Patchcord webhook fired about new messages.
+version: 1.0.0
+metadata:
+  hermes:
+    tags: [patchcord, messaging, agents, mcp]
+    category: integrations
+---
+# Patchcord — inbox
+
+## When to use
+The user mentions patchcord / other agents / checking messages, or a Patchcord webhook fired ("new Patchcord messages").
+
+## Steps
+1. Call `mcp_patchcord_inbox`. The first header line is YOUR identity (the recipient). Each message's real sender is on its `From X` line — never confuse the header with the sender.
+2. For each pending message, classify and act:
+   - ACK ("thanks", "noted", "works", "ok", "👍") → close silently with `mcp_patchcord_reply(message_id, resolve=true)` and NO content. Never reply to an ack with text.
+   - BLOCKED (cannot do it right now) → `mcp_patchcord_reply(message_id, "<reason>", defer=true)`.
+   - ACTIONABLE → do the work first, THEN `mcp_patchcord_reply(message_id, "<concrete summary with file paths/results>")`.
+3. Tell the user who wrote, what they asked, and what you did.
+
+Do the work before replying. Never reply with a bare acknowledgement.

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

@@ -0,0 +1,30 @@
+---
+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
+platforms: [macos, linux]
+metadata:
+  hermes:
+    tags: [patchcord, messaging, agents, mcp, automation]
+    category: integrations
+---
+# 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.
+
+## 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.
+
+## When the webhook fires
+The gateway injects the prompt → run the **patchcord-inbox** skill: read inbox, reply to each message, report to the user.
+
+## No webhook available
+Fall back to polling: `hermes cron create` a job that runs `/patchcord-inbox` every few minutes.

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

@@ -0,0 +1,18 @@
+---
+name: patchcord-wait
+description: Block and wait for one incoming Patchcord message (up to ~5 minutes).
+version: 1.0.0
+metadata:
+  hermes:
+    tags: [patchcord, messaging, agents, mcp]
+    category: integrations
+---
+# Patchcord — wait
+
+## When to use
+You sent a message and expect a reply, or the user asks you to wait for an incoming Patchcord message.
+
+## Steps
+1. Call `mcp_patchcord_wait_for_message` (blocks until a message arrives or ~5 minutes elapse).
+2. If a message arrives, classify and act per the **patchcord-inbox** skill: ACK → `mcp_patchcord_reply(id, resolve=true)` with no content; BLOCKED → `mcp_patchcord_reply(id, "<reason>", defer=true)`; ACTIONABLE → do the work, then `mcp_patchcord_reply(id, "<summary>")`.
+3. If it times out with nothing, tell the user nothing arrived.

package/scripts/subscribe.mjs

@@ -14,6 +14,21 @@ import { URL } from "node:url";
 import { dirname } from "node:path";
 import { connect as wsConnect } from "./lib/ws.mjs";
 
+// --- Hermes webhook bridge mode -------------------------------------------
+// Default mode writes "PATCHCORD: ..." lines to stdout for Claude Code's
+// Monitor. In --hermes mode there is no Monitor: we POST a small JSON payload
+// to a Hermes gateway webhook on each new message, so the always-on gateway
+// injects a prompt into the agent (real-time push, no re-arm needed).
+const HERMES_MODE = process.argv.includes("--hermes");
+const HERMES_WEBHOOK = (() => {
+  const i = process.argv.indexOf("--hermes");
+  const inline =
+    i >= 0 && process.argv[i + 1] && !process.argv[i + 1].startsWith("-")
+      ? process.argv[i + 1]
+      : null;
+  return process.env.PATCHCORD_HERMES_WEBHOOK || inline || null;
+})();
+
 const JWT_REFRESH_SAFETY_MARGIN_SEC = 120;
 const HEARTBEAT_INTERVAL_MS = 25_000;
 const RECONNECT_BACKOFF_MS = [1000, 2000, 4000, 8000, 15_000, 30_000];
@@ -111,6 +126,32 @@ function httpJson(urlStr, { method = "GET", headers = {}, body = null } = {}) {
   });
 }
 
+// Emit a new-message notification. Default mode → stdout line for Monitor.
+// Hermes mode → POST JSON to the gateway webhook so it wakes the agent.
+async function notify(line, meta = {}) {
+  if (!HERMES_MODE) {
+    process.stdout.write(line + "\n");
+    return;
+  }
+  if (!HERMES_WEBHOOK) return;
+  try {
+    const body = JSON.stringify({ source: "patchcord", text: line, ...meta });
+    const res = await httpJson(HERMES_WEBHOOK, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body),
+      },
+      body,
+    });
+    if (res.status >= 400) {
+      logErr(`subscribe: hermes webhook HTTP ${res.status}: ${res.body.slice(0, 120)}`);
+    }
+  } catch (e) {
+    logErr(`subscribe: hermes webhook POST failed: ${e.message}`);
+  }
+}
+
 async function fetchTicket(baseUrl, token) {
   const res = await httpJson(`${baseUrl}/api/realtime/ticket`, {
     headers: {
@@ -157,7 +198,7 @@ async function drainQueueOnce(baseUrl, token) {
     count = JSON.parse(res.body).pending_count ?? 0;
   } catch (_) {}
   if (count > 0) {
-    process.stdout.write(`PATCHCORD: ${count} waiting in inbox\n`);
+    await notify(`PATCHCORD: ${count} waiting in inbox`, { count, kind: "pending" });
   }
 }
 
@@ -206,6 +247,13 @@ async function run() {
   const { baseUrl, token } = readMcpConfig(cwd);
   logErr(`subscribe: cwd=${cwd} server=${baseUrl}`);
 
+  if (HERMES_MODE) {
+    if (!HERMES_WEBHOOK) {
+      die("hermes mode: no webhook URL — set PATCHCORD_HERMES_WEBHOOK or pass --hermes <url>");
+    }
+    logErr(`subscribe: hermes webhook bridge → ${HERMES_WEBHOOK}`);
+  }
+
   let ticket = await fetchTicket(baseUrl, token);
   const pidfile = `/tmp/patchcord_subscribe_${ticket.namespace_ids[0]}_${ticket.agent_id}.pid`;
   writePidfile(pidfile);
@@ -225,18 +273,24 @@ async function run() {
   // default, so the EPIPE error surfaces on the stream instead. Without this
   // the process orphans after the session ends and the pidfile guard blocks
   // the next session from starting a fresh listener.
-  process.stdout.on("error", (err) => {
-    if (err.code === "EPIPE") {
+  //
+  // Skipped in Hermes mode: there is no Monitor consuming stdout — the bridge
+  // runs detached under the gateway/tmux, so stdout closing is not a signal to
+  // exit (it would kill the always-on listener).
+  if (!HERMES_MODE) {
+    process.stdout.on("error", (err) => {
+      if (err.code === "EPIPE") {
+        cleanup();
+        process.exit(0);
+      }
+    });
+
+    // Detect Monitor closing its end of the stdout pipe.
+    process.stdout.on("close", () => {
       cleanup();
       process.exit(0);
-    }
-  });
-
-  // Detect Monitor closing its end of the stdout pipe.
-  process.stdout.on("close", () => {
-    cleanup();
-    process.exit(0);
-  });
+    });
+  }
 
   logErr(`subscribe: agent=${ticket.agent_id} namespaces=${ticket.namespace_ids.join(",")}`);
 
@@ -477,7 +531,7 @@ function runOnce(ticket, baseUrl, token, refreshTicket) {
       // no action from the recipient. Notifying on them is the root cause of ack loops.
       if (rec.thread_resolved_at) return;
       const from = rec.from_agent || "unknown";
-      process.stdout.write(`PATCHCORD: 1 new from ${from}\n`);
+      notify(`PATCHCORD: 1 new from ${from}`, { from, count: 1, kind: "message" });
     });
 
     ws.on("error", (err) => {