patchcord 0.6.39 → 0.6.41

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "patchcord",
   "description": "Cross-machine agent messaging. Messages from other agents land in the inbox and wake the agent to reply.",
-  "version": "0.6.39",
+  "version": "0.6.41",
   "author": {
     "name": "ppravdin"
   },

package/bin/patchcord.mjs

@@ -789,8 +789,23 @@ if (cmd === "whoami") {
     // provisioned". Say explicitly that identity is fine.
     console.log(`self-description: (not set — optional; your identity ${json.agent}@${json.namespace} is fully provisioned. Set one with: patchcord whoami --propose "<text>")`);
   }
-  console.log();
-  console.log(`tip: \`patchcord agents\` returns whoami for all peers.`);
+  // TTY-ONLY, AND THAT IS THE WHOLE POINT.
+  //
+  // This tip is addressed to a human reading a terminal. It was printed
+  // unconditionally, which meant it also landed in the stdout an AGENT captures
+  // from a tool call — and to a model, a suggestion in a tool result is
+  // indistinguishable from an instruction. An agy session's own record shows the
+  // consequence exactly: 6 `patchcord whoami` calls, 6 `patchcord agents` calls,
+  // paired one-to-one, each `agents` immediately following the tip in the
+  // previous command's output. Nothing in any skill or config asked for it. We
+  // did, in our own stdout, every single time.
+  //
+  // A tip is help. An unrequested command is work. The difference is entirely in
+  // who is reading, and `isTTY` is the one place that difference is knowable.
+  if (process.stdout.isTTY) {
+    console.log();
+    console.log(`tip: \`patchcord agents\` returns whoami for all peers.`);
+  }
   for (const w of warnings) {
     // stderr, matching the global-scope warning above. The line is addressed
     // to the AGENT and says to relay it, because the human has no reason to
@@ -978,7 +993,27 @@ if (cmd === "subscribe") {
     spawnEnv.PATCHCORD_BEARER_TOKEN = bearerInfo.token;
   }
   const { spawnSync } = await import("child_process");
-  const result = spawnSync(process.execPath, [subscribeScript], {
+  // FORWARD argv. This used to spawn [subscribeScript] with no arguments, so
+  // every flag a user typed was silently thrown away between the wrapper and
+  // the script that reads it.
+  //
+  // What that broke: subscribe.mjs gates its Hermes webhook bridge on
+  // `process.argv.includes("--hermes")` — its OWN argv. Our Hermes skill tells
+  // the human to run `PATCHCORD_HERMES_WEBHOOK=<url> patchcord subscribe
+  // --hermes`. The env var arrived, the flag did not, and the flag is the gate.
+  // notify() then took the `!HERMES_MODE` branch and wrote to a stdout no
+  // Hermes gateway reads. The listener ran. Nothing was ever woken. No error.
+  // The `--hermes <url>` inline form was worse: it has no env fallback at all.
+  //
+  // Forward everything rather than allow-listing `--hermes`. An allow-list
+  // fixes today and leaves the trap armed: the next person adds a child-side
+  // flag, reads subscribe.mjs, sees it handled, and never looks at these eight
+  // lines. Same silent failure, new flag name. Reported by lead@mux-v2, who
+  // asked for the fix in this shape rather than the narrow one.
+  //
+  // `--kimi` never hit this because the kimi branch above parses it here in the
+  // parent and re-passes the interval explicitly. That was luck, not design.
+  const result = spawnSync(process.execPath, [subscribeScript, ...args], {
     stdio: "inherit",
     env: spawnEnv,
   });
@@ -1432,10 +1467,38 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
       // 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) => {
+      const agWritten = writeJson(join(adir, "mcp_config.json"), (o) => {
         o.mcpServers = o.mcpServers || {};
         o.mcpServers.patchcord = { serverUrl: `${baseUrl}/mcp`, headers: hdr };
       });
+      // THE SKILL IS A GUARD, NOT DOCUMENTATION, AND IT WAS MISSING HERE.
+      //
+      // The interactive installer copies these; this path did not, so every seat
+      // provisioned by `patchcord provision --tool agy` — which is how a
+      // mux-deployed Team is built — got the credential and none of the rules.
+      // Three live agy seats were checked: one had only patchcord-wait, two had
+      // no skills at all.
+      //
+      // What goes missing is specifically the line "Do not run the `patchcord`
+      // CLI (whoami, inbox, recall, HTTP calls)". Without it, a seat whose MCP
+      // has not loaded reaches for the CLI instead — and one that did wrote its
+      // own send_patchcord.js and ran it eight times. The skill exists, is
+      // correctly worded, and was installed by one provisioning path out of two,
+      // which is the same as not having it for anyone who arrives by the other.
+      //
+      // Copied the same way hermes is above, which is why the pattern was
+      // already here to notice.
+      try {
+        const agSkills = join(pluginRoot, "per-project-skills", "antigravity");
+        for (const [src, dest] of [["inbox", "patchcord"], ["wait", "patchcord-wait"]]) {
+          const from = join(agSkills, src, "SKILL.md");
+          if (!existsSync(from)) continue;
+          const to = join(adir, "skills", dest);
+          mkdirSync(to, { recursive: true });
+          cpSync(from, join(to, "SKILL.md"));
+        }
+      } catch {}
+      return agWritten;
     }
     if (tool === "hermes") {
       // Hermes reads MCP servers ONLY from its GLOBAL ~/.hermes/config.yaml
@@ -3994,21 +4057,71 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
         console.log(`  ${green}✓${r} Cleaned PATCHCORD_TOKEN from .env`);
       }
     }
-    // Clean up old per-project slash commands (deprecated in Codex v0.117+)
-    for (const dir of [join(codexDir, "prompts"), join(homedir(), ".codex", "prompts")]) {
-      for (const f of ["patchcord.md", "patchcord-wait.md"]) {
-        const p = join(dir, f);
-        if (existsSync(p)) { unlinkSync(p); }
-      }
-    }
+    // We do NOT touch .codex/prompts/ — not the project one, not the home one.
+    //
+    // We used to write /patchcord and /patchcord-wait there, then a later commit
+    // deleted them on every install. Both halves were wrong to keep.
+    //
+    // Writing them is pointless: Codex stopped loading $CODEX_HOME/prompts
+    // entirely. Verified on 0.145 — a probe file at ~/.codex/prompts/pctest.md
+    // and at ./.codex/prompts/pcproj.md both give "no matches" in the slash
+    // menu, while /us still filters to /usage, so the menu itself works.
+    // OpenAI marks custom prompts deprecated and says "use skills instead";
+    // openai/codex#15941 reports the 0.117 break and was closed "not planned".
+    //
+    // Deleting them is worse than pointless. A user still on Codex < 0.117 has
+    // WORKING slash commands, and the delete loop took them away on the next
+    // install. It gave that user nothing back. `@patchcord` is the replacement
+    // and it is installed below via the skills path.
+    //
+    // If you are tempted to re-add either half, run the probe first. Do not
+    // trust this comment and do not trust the docs.
+
     // Clean up old per-project skill (now installed as global plugin)
     const oldSkillPath = join(cwd, ".agents", "skills", "patchcord", "SKILL.md");
     if (existsSync(oldSkillPath)) { unlinkSync(oldSkillPath); }
 
-    // Install Codex plugin at ~/.agents/plugins/patchcord/ (personal marketplace)
-    const pluginVersion = JSON.parse(readFileSync(join(pluginRoot, "package.json"), "utf-8")).version;
+    // Install the Codex plugin.
+    //
+    // TWO DIFFERENT DIRECTORIES, and putting them in one place is the bug this
+    // replaces. The marketplace FILE lives at ~/.agents/plugins/marketplace.json.
+    // The plugin BODY lives at ~/plugins/patchcord. A `source.path` in that file
+    // resolves against HOME — NOT against the directory holding the file.
+    //
+    // We previously wrote the body to ~/.agents/plugins/patchcord and pointed at
+    // "./patchcord". Codex read that as ~/patchcord, which never existed, so:
+    //
+    //   $ codex plugin list
+    //   patchcord@patchcord   not installed   /home/now/patchcord
+    //
+    // The plugin has never once installed. Only the ~/.agents/skills/ copy
+    // written further down kept @patchcord alive, which is why nobody noticed.
+    //
+    // The layout below is OpenAI's own, from the bundled plugin-creator skill
+    // (~/.codex/skills/.system/plugin-creator/): the scaffold writes bodies to
+    // ~/plugins/<name>, and its SKILL.md states "In either location, the
+    // generated source path remains ./plugins/<plugin-name>".
+    //
+    // Verify with `codex plugin list` after changing this. STATUS must not say
+    // "not installed", and PATH must be a directory that exists.
+    // Codex caches an installed plugin BY VERSION under ~/.codex/plugins/cache/.
+    // Re-running the installer on the same release therefore reinstalls nothing,
+    // and re-running it is the normal way people pick up a fix. So append the
+    // cachebuster suffix Codex defines for exactly this case — the format is
+    // `+codex.<token>`, per the bundled plugin-creator helper
+    // (~/.codex/skills/.system/plugin-creator/scripts/update_plugin_cachebuster.py).
+    const basePluginVersion = JSON.parse(readFileSync(join(pluginRoot, "package.json"), "utf-8")).version;
+    const pluginVersion = `${basePluginVersion}+codex.${new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14)}`;
     const marketplaceDir = join(homedir(), ".agents", "plugins");
-    const pluginDir = join(marketplaceDir, "patchcord");
+    const pluginDir = join(homedir(), "plugins", "patchcord");
+
+    // Remove the body from the old, never-loadable location. Leaving it behind
+    // makes `plugin list` ambiguous and keeps a stale copy of the skills on disk.
+    const deadPluginDir = join(marketplaceDir, "patchcord");
+    if (existsSync(join(deadPluginDir, ".codex-plugin", "plugin.json"))) {
+      try { rmSync(deadPluginDir, { recursive: true, force: true }); } catch {}
+    }
+
     mkdirSync(join(pluginDir, ".codex-plugin"), { recursive: true });
     mkdirSync(join(pluginDir, "skills", "patchcord"), { recursive: true });
     mkdirSync(join(pluginDir, "skills", "patchcord-wait"), { recursive: true });
@@ -4038,7 +4151,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
     writeFileSync(join(pluginDir, "skills", "patchcord-wait", "SKILL.md"),
       readFileSync(join(pluginRoot, "skills", "wait", "SKILL.md"), "utf-8"));
 
-    // Personal marketplace entry (relative path from marketplace root)
+    // Personal marketplace entry. `path` is relative to HOME, not to this file.
     const marketplacePath = join(marketplaceDir, "marketplace.json");
     updateJsonConfig(marketplacePath, (obj) => {
       if (!obj.name) obj.name = "patchcord";
@@ -4046,24 +4159,71 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       obj.plugins = (obj.plugins || []).filter(p => p.name !== "patchcord");
       obj.plugins.push({
         name: "patchcord",
-        source: { source: "local", path: "./patchcord" },
+        source: { source: "local", path: "./plugins/patchcord" },
         policy: { installation: "INSTALLED_BY_DEFAULT", authentication: "ON_INSTALL" },
         category: "Productivity",
       });
     });
 
-    // Also install global skills (working @patchcord — plugin/read broken in Codex v0.117)
+    // Writing the marketplace entry does NOT install the plugin. Codex leaves it
+    // at "not installed" until this runs, `INSTALLED_BY_DEFAULT` notwithstanding.
+    // We never ran it, which is the second half of why the plugin was dead.
+    // The command is `plugin add`, not `plugin install` — see
+    // ~/.codex/skills/.system/plugin-creator/references/installing-and-updating.md.
+    //
+    // Not run() — run() has no timeout, and this is the one call here that talks
+    // to another program's install path. The marketplace entry sets
+    // authentication ON_INSTALL, so a future Codex could decide to ask. An
+    // installer that hangs forever is worse than one that skips the plugin, and
+    // skipping is survivable: the ~/.agents/skills/ fallback below covers it.
+    let pluginAdded = false;
+    try {
+      execSync(`codex plugin add patchcord@patchcord`,
+        { stdio: "pipe", encoding: "utf-8", timeout: 30_000 });
+      pluginAdded = true;
+    } catch { pluginAdded = false; }
+
+    // ~/.agents/skills/ holds the SAME two skills as a fallback. Codex reads that
+    // tree directly, with no marketplace and no install step, so @patchcord works
+    // there even when the plugin does not load.
+    //
+    // EXACTLY ONE of the two may exist at a time. Codex reads both and shows both.
+    // With the plugin installed AND the fallback present, `@patchcord` lists:
+    //
+    //   Patchcord                   Cross-machine agent messaging          Plugin
+    //   patchcord                   Cross-agent messaging for Codex …      Skill
+    //   patchcord (patchcord)       Cross-agent messaging for Codex …      Skill
+    //   patchcord-wait              Block this turn for up to 5 minutes …  Skill
+    //   patchcord:wait (patchcord)  Block this turn for up to 5 minutes …  Skill
+    //
+    // Five entries for two skills. Observed, not predicted — an earlier version
+    // of this comment asserted they would not collide, and that was wrong.
     const globalSkillDir = join(homedir(), ".agents", "skills", "patchcord");
-    mkdirSync(globalSkillDir, { recursive: true });
-    writeFileSync(join(globalSkillDir, "SKILL.md"),
-      readFileSync(join(pluginRoot, "per-project-skills", "codex", "SKILL.md"), "utf-8"));
     const globalWaitDir = join(homedir(), ".agents", "skills", "patchcord-wait");
-    mkdirSync(globalWaitDir, { recursive: true });
-    writeFileSync(join(globalWaitDir, "SKILL.md"),
-      readFileSync(join(pluginRoot, "skills", "wait", "SKILL.md"), "utf-8"));
+    if (pluginAdded) {
+      for (const d of [globalSkillDir, globalWaitDir]) {
+        if (existsSync(d)) { try { rmSync(d, { recursive: true, force: true }); } catch {} }
+      }
+    } else {
+      mkdirSync(globalSkillDir, { recursive: true });
+      writeFileSync(join(globalSkillDir, "SKILL.md"),
+        readFileSync(join(pluginRoot, "per-project-skills", "codex", "SKILL.md"), "utf-8"));
+      mkdirSync(globalWaitDir, { recursive: true });
+      writeFileSync(join(globalWaitDir, "SKILL.md"),
+        readFileSync(join(pluginRoot, "skills", "wait", "SKILL.md"), "utf-8"));
+    }
 
     console.log(`\n  ${green}✓${r} Codex configured: ${dim}${configPath}${r}`);
-    console.log(`  ${green}✓${r} Plugin installed: ${dim}@patchcord${r}, ${dim}@patchcord-wait${r}`);
+    if (pluginAdded) {
+      console.log(`  ${green}✓${r} Plugin installed: ${dim}${pluginDir}${r}`);
+    } else {
+      // Say it plainly. A silent failure here still leaves @patchcord working
+      // through ~/.agents/skills/, so this is a downgrade, not a breakage.
+      console.log(`  ${yellow}!${r} Codex plugin did not install (${dim}codex plugin add patchcord@patchcord${r})`);
+      console.log(`  ${dim}Skills still work. Check with: codex plugin list${r}`);
+    }
+    console.log(`  ${green}✓${r} Type ${dim}@patchcord${r} or ${dim}@patchcord-wait${r} in Codex`);
+    console.log(`  ${dim}Codex dropped custom slash commands — @ is the picker now.${r}`);
   } else {
     // Claude Code: write .mcp.json
     const mcpPath = join(cwd, ".mcp.json");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchcord",
-  "version": "0.6.39",
+  "version": "0.6.41",
   "description": "Cross-machine agent messaging for Claude Code and Codex",
   "scripts": {
     "version": "node scripts/sync-plugin-version.mjs && git add .claude-plugin/plugin.json"