patchcord 0.5.102 → 0.5.104

package/bin/patchcord.mjs

@@ -1458,21 +1458,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
   // Kimi CLI
   const hasKimi = run("which kimi");
   if (hasKimi) {
-    // Clean up old skill names: the combined skill AND the colon-named flow
-    // skills (patchcord:inbox …). Kimi requires skill names to be
-    // lowercase/digits/hyphens only — a colon kept them out of /flow:, so they
-    // showed only under /skill:. Renamed to patchcord-inbox etc.
-    for (const stale of ["patchcord", "patchcord-wait", "patchcord:inbox", "patchcord:wait", "patchcord:subscribe"]) {
-      const d = join(HOME, ".kimi", "skills", stale);
-      if (existsSync(d)) { try { rmSync(d, { recursive: true, force: true }); } catch {} }
-    }
-
-    // Install three focused Kimi flow skills (hyphen names → /flow:patchcord-inbox)
-    const kimiInboxDir = join(HOME, ".kimi", "skills", "patchcord-inbox");
-    const kimiWaitDir = join(HOME, ".kimi", "skills", "patchcord-wait");
-    const kimiSubDir = join(HOME, ".kimi", "skills", "patchcord-subscribe");
     let kimiChanged = false;
-
     const installKimiSkill = (destDir, relSrc) => {
       const src = join(pluginRoot, "per-project-skills", "kimi", relSrc, "SKILL.md");
       const dest = join(destDir, "SKILL.md");
@@ -1481,9 +1467,24 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       copyFileSync(src, dest);
       return changed;
     };
-    kimiChanged = installKimiSkill(kimiInboxDir, "inbox") || kimiChanged;
-    kimiChanged = installKimiSkill(kimiWaitDir, "wait") || kimiChanged;
-    kimiChanged = installKimiSkill(kimiSubDir, "subscribe") || kimiChanged;
+    // Kimi CLI (Python) reads ~/.kimi/skills; Kimi Code (Node) reads
+    // ~/.kimi-code/skills. Install into BOTH user dirs that exist — a global
+    // `npx patchcord` must fix whichever Kimi the user runs. Clean up the old
+    // combined skill AND colon-named flow skills (Kimi requires names to be
+    // lowercase/digits/hyphens only — a colon kept them out of /flow:, showing
+    // them only under /skill:). Renamed to patchcord-inbox etc.
+    const kimiCodeHome = process.env.KIMI_CODE_HOME || join(HOME, ".kimi-code");
+    const kimiSkillRoots = [join(HOME, ".kimi", "skills")];
+    if (existsSync(kimiCodeHome)) kimiSkillRoots.push(join(kimiCodeHome, "skills"));
+    for (const root of kimiSkillRoots) {
+      for (const stale of ["patchcord", "patchcord-wait", "patchcord:inbox", "patchcord:wait", "patchcord:subscribe"]) {
+        const d = join(root, stale);
+        if (existsSync(d)) { try { rmSync(d, { recursive: true, force: true }); } catch {} }
+      }
+      kimiChanged = installKimiSkill(join(root, "patchcord-inbox"), "inbox") || kimiChanged;
+      kimiChanged = installKimiSkill(join(root, "patchcord-wait"), "wait") || kimiChanged;
+      kimiChanged = installKimiSkill(join(root, "patchcord-subscribe"), "subscribe") || kimiChanged;
+    }
 
     // Install/update stop hook — fires after each Kimi turn to check inbox
     let hookChanged = false;

package/package.json

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

package/per-project-skills/kimi/inbox/SKILL.md

@@ -1,14 +1,15 @@
 ---
 name: patchcord-inbox
 description: Read Patchcord inbox and reply to messages
-type: flow
 ---
 
-> Use `/flow:patchcord-inbox` to run this. `/skill:` only loads it as docs (Kimi design).
+Run this with `/skill:patchcord-inbox`. (Kimi Code has no `/flow:` — `/skill:` injects this as a prompt and you act on it.)
 
-```mermaid
-flowchart TD
-  A([BEGIN]) --> B["Call the inbox MCP tool. Reading the response: the first header line shows YOUR own identity (the recipient). The actual sender of each message is on a 'From X' line — never confuse the header with the sender. For each pending message, classify it: (1) ACK — short signals like thanks, noted, works, great, ok, 👍 with no task. Close silently with reply(message_id, resolve=true) and NO content. Never send a text reply to an ack — it creates infinite ack chains. (2) BLOCKED — you cannot do the work right now (busy, missing credentials, ambiguous target). Use reply(message_id, reason, defer=true) — the message stays in your inbox as a reminder. Never silently skip a message. (3) ACTIONABLE — do the work the message asks for first (edit the file, run the command, write the code), THEN call reply(message_id, concrete summary) with file paths and line numbers. Never reply will-do or understood before doing the work."]
-  B --> C["Call the Shell tool with these exact parameters to re-arm the listener: command=patchcord subscribe --kimi 5, run_in_background=true, timeout=86400, description=Patchcord listener."]
-  C --> D([END])
-```
+Call the `inbox` MCP tool now. In its response, the first header line is YOUR own identity (the recipient); the real sender of each message is on a `From X` line — never confuse the two.
+
+For each pending message, classify it and act:
+- **ACK** — short signals like thanks, noted, works, great, ok, 👍 with no task → close it silently: `reply(message_id, resolve=true)` with NO content. Never send a text reply to an ack (it creates infinite ack chains).
+- **BLOCKED** — you cannot do the work right now (busy, missing credentials, ambiguous target) → `reply(message_id, "<reason>", defer=true)` so it stays in your inbox as a reminder. Never silently skip a message.
+- **ACTIONABLE** — do the work the message asks for FIRST (edit the file, run the command, write the code), THEN `reply(message_id, "<concrete summary of what you did, with file paths and line numbers>")`. Never reply "will do" / "understood" before doing the work.
+
+After handling every message, re-arm the background listener: use the Shell tool to run `patchcord subscribe --kimi 5` with run_in_background=true, timeout=86400, description="Patchcord listener".

package/per-project-skills/kimi/subscribe/SKILL.md

@@ -1,14 +1,13 @@
 ---
 name: patchcord-subscribe
 description: Start the Patchcord background polling listener
-type: flow
 ---
 
-> Use `/flow:patchcord-subscribe` to run this. `/skill:` only loads it as docs (Kimi design).
+Run this with `/skill:patchcord-subscribe`. (Kimi Code has no `/flow:` — `/skill:` injects this as a prompt and you act on it.)
 
-```mermaid
-flowchart TD
-  A([BEGIN]) --> B["First, call the inbox MCP tool. Reading the response: the first header line shows YOUR own identity (the recipient). The actual sender of each message is on a 'From X' line — never confuse the header with the sender. Drain each pending message by classifying it: ACK (thanks, noted, works, ok, 👍) → close silently with reply(message_id, resolve=true), no content; BLOCKED (you cannot do the work right now) → reply(message_id, reason, defer=true); ACTIONABLE → do the work first, then reply(message_id, concrete summary). Do NOT skip the drain — the listener exits immediately if messages are already waiting."]
-  B --> C["Now call the Shell tool with these exact parameters: command=patchcord subscribe --kimi 5, run_in_background=true, timeout=86400, description=Patchcord listener. Then tell the user in one sentence: Patchcord listener active."]
-  C --> D([END])
-```
+First, call the `inbox` MCP tool and DRAIN every pending message before starting the listener (the listener exits immediately if messages are already waiting). In the inbox response, the first header line is YOUR identity (recipient); the real sender is on each `From X` line. For each message:
+- **ACK** (thanks, noted, works, ok, 👍) → `reply(message_id, resolve=true)`, no content.
+- **BLOCKED** → `reply(message_id, "<reason>", defer=true)`.
+- **ACTIONABLE** → do the work first, then `reply(message_id, "<what you did>")`.
+
+Then start the background listener: use the Shell tool to run `patchcord subscribe --kimi 5` with run_in_background=true, timeout=86400, description="Patchcord listener". Tell the user in one sentence: Patchcord listener active.

package/per-project-skills/kimi/wait/SKILL.md

@@ -1,17 +1,15 @@
 ---
 name: patchcord-wait
 description: Wait for one incoming Patchcord message
-type: flow
 ---
 
-> Use `/flow:patchcord-wait` to run this. `/skill:` only loads it as docs (Kimi design).
+Run this with `/skill:patchcord-wait`. (Kimi Code has no `/flow:` — `/skill:` injects this as a prompt and you act on it.)
 
-```mermaid
-flowchart TD
-  A([BEGIN]) --> B["Call the wait_for_message MCP tool to block until a message arrives or 5 minutes elapse."]
-  B --> C{"Message arrived?"}
-  C -->|Yes| D["Classify the message: ACK (thanks, noted, works, ok, 👍) → close silently with reply(message_id, resolve=true), no content; BLOCKED (cannot do work right now) → reply(message_id, reason, defer=true); ACTIONABLE → do the work first, then reply(message_id, concrete summary). Never reply to an ack with text."]
-  C -->|No| E([END])
-  D --> F["Call the Shell tool with these exact parameters to re-arm the listener: command=patchcord subscribe --kimi 5, run_in_background=true, timeout=86400, description=Patchcord listener."]
-  F --> E
-```
+Call the `wait_for_message` MCP tool now to block until a message arrives or ~5 minutes elapse.
+
+When a message arrives, classify it and act:
+- **ACK** (thanks, noted, works, ok, 👍, no task) → `reply(message_id, resolve=true)` with NO content. Never text-reply an ack.
+- **BLOCKED** (cannot do the work right now) → `reply(message_id, "<reason>", defer=true)`.
+- **ACTIONABLE** → do the work FIRST, then `reply(message_id, "<concrete summary of what you did>")`.
+
+Then re-arm the background listener: use the Shell tool to run `patchcord subscribe --kimi 5` with run_in_background=true, timeout=86400, description="Patchcord listener".