patchcord 0.5.81 → 0.5.83

package/bin/patchcord.mjs

@@ -1106,24 +1106,19 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
 
       // Remove existing patchcord session-start hook blocks
       const segments2 = kimiConfig.split("[[hooks]]");
-      const kept2 = segments2.filter((seg, idx) => idx === 0 || !seg.includes("patchcord-session-start"));
+      const kept2 = segments2.filter((seg, idx) => idx === 0 || !seg.includes("patchcord-session-start") && !seg.includes("patchcord-prompt-hook"));
       kimiConfig = kept2.join("[[hooks]]").replace(/\n{3,}/g, "\n\n").trim();
 
-      // Install UserPromptSubmit hook — legacy compatibility for /skill:patchcord:*
-      const kimiPromptSrc = join(pluginRoot, "scripts", "kimi-prompt-hook.sh");
+      // Remove the legacy UserPromptSubmit shim script if a prior install left it.
+      // Kimi displays stderr to the user but does not feed it to the LLM, so the
+      // shim never auto-executed anything — flow skills handle slash invocations.
       const kimiPromptDest = join(HOME, ".kimi", "patchcord-prompt-hook.sh");
-      if (existsSync(kimiPromptSrc)) {
-        copyFileSync(kimiPromptSrc, kimiPromptDest);
-        chmodSync(kimiPromptDest, 0o755);
+      if (existsSync(kimiPromptDest)) {
+        try { rmSync(kimiPromptDest, { force: true }); } catch {}
       }
 
-      // Remove existing patchcord prompt hook blocks
-      const segments3 = kimiConfig.split("[[hooks]]");
-      const kept3 = segments3.filter((seg, idx) => idx === 0 || !seg.includes("patchcord-prompt-hook"));
-      kimiConfig = kept3.join("[[hooks]]").replace(/\n{3,}/g, "\n\n").trim();
-
       // Append new hooks
-      kimiConfig = kimiConfig.trimEnd() + `\n\n[[hooks]]\nevent = "UserPromptSubmit"\ncommand = "${kimiPromptDest}"\ntimeout = 5\n\n[[hooks]]\nevent = "SessionStart"\ncommand = "${kimiSessionDest}"\ntimeout = 10\n\n[[hooks]]\nevent = "Stop"\ncommand = "${kimiHookDest}"\ntimeout = 10\n`;
+      kimiConfig = kimiConfig.trimEnd() + `\n\n[[hooks]]\nevent = "SessionStart"\ncommand = "${kimiSessionDest}"\ntimeout = 10\n\n[[hooks]]\nevent = "Stop"\ncommand = "${kimiHookDest}"\ntimeout = 10\n`;
 
       mkdirSync(dirname(kimiConfigPath), { recursive: true });
       writeFileSync(kimiConfigPath, kimiConfig);

package/package.json

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

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

@@ -1,15 +1,12 @@
 ---
 name: patchcord:inbox
 description: Read Patchcord inbox and reply to messages
+type: flow
 ---
 
-1. Run `inbox()`
-2. For each pending message: do the work, then `reply(message_id, "what I did")`
-3. Re-arm listener:
-```
-Shell:
-  command: patchcord subscribe --kimi 5
-  run_in_background: true
-  description: Patchcord inbox polling
-  timeout: 86400
+```mermaid
+flowchart TD
+  A([BEGIN]) --> B[Call the inbox MCP tool. For each pending message: do the work it asks for, then call reply with the message_id and a concrete summary of what you did.]
+  B --> C[Use the Shell tool to run `patchcord subscribe --kimi 5` with run_in_background=true and timeout=86400 to re-arm the listener.]
+  C --> D([END])
 ```

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

@@ -1,24 +1,11 @@
 ---
 name: patchcord:subscribe
-description: >
-  Start a background polling task that wakes Kimi when new Patchcord messages
-  arrive. Use when the user asks about notifications, background listening,
-  or when you need to re-arm the listener after reading messages.
+description: Start the Patchcord background polling listener
+type: flow
 ---
 
-# patchcord:subscribe
-
-Run this exact background Shell task:
-
+```mermaid
+flowchart TD
+  A([BEGIN]) --> B[Use the Shell tool to run `patchcord subscribe --kimi 5` with run_in_background=true and timeout=86400. Then tell the user in one sentence: Patchcord listener active.]
+  B --> C([END])
 ```
-Shell:
-  command: patchcord subscribe --kimi 5
-  run_in_background: true
-  description: Patchcord inbox polling
-  timeout: 86400
-```
-
-- `command: patchcord subscribe --kimi 5` — forces Kimi polling mode and polls inbox every **5 seconds**
-- `timeout: 86400` — runs for **24 hours** (maximum). Always 86400, never anything else.
-- One-shot: exits with code 2 when messages found, triggering Kimi auto-run
-- Must re-arm after every `inbox()` or `wait_for_message()` call by running the exact same command again

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

@@ -1,31 +1,15 @@
 ---
 name: patchcord:wait
-description: >
-  Block this turn for up to 5 minutes waiting for one incoming Patchcord
-  message via the wait_for_message MCP tool. Single blocking call, no
-  background process. Use ONLY when the user explicitly runs /patchcord:wait
-  or asks you to wait for a patchcord message.
+description: Wait for one incoming Patchcord message
+type: flow
 ---
 
-# patchcord:wait
-
-User invoked /patchcord:wait or asked you to wait for a Patchcord message. Use `wait_for_message()` only. Do NOT spawn a background listener.
-
-Call `wait_for_message()` to block until a message arrives (up to 5 minutes).
-
-When a message arrives:
-
-1. Read it — the tool returns from, content, and message_id. If it belongs to a thread, `thread` and `thread_id` will be set.
-2. **Re-arm the background listener** — see `patchcord:subscribe` skill for how to run `patchcord subscribe --kimi 5` so the next message will also wake you up.
-3. Do the work described in the message first. Update the file, write the code, fix the bug — whatever it asks.
-4. Reply with what you did: `reply(message_id, "here's what I changed: [concrete details]")`. Thread is auto-inherited. Use `resolve=true` to close the thread when the task is fully done.
-5. Tell the human who wrote and what you did about it
-6. Call `wait_for_message()` again to keep listening
-
-Loop until timeout or the human interrupts.
-
-If `wait_for_message()` errors, fall back to polling `inbox()` every 10-15 seconds instead of stopping the loop.
-
-Do not ask the human for permission to reply — just do the work, reply with results, then report.
-
-**No ack chains.** If the arriving message is a clear ack ("Noted", "Got it", "Thanks", "Keep running") — close it silently with `reply(id, resolve=true)`, no content, and keep listening. Never text-reply to an ack. Never send "Noted" + resolve=true — that creates a new pending message the other side will feel compelled to answer.
+```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[Do the work the message asks for, then call reply with the message_id and a concrete summary.]
+  C -->|No| E([END])
+  D --> F[Use the Shell tool to run `patchcord subscribe --kimi 5` with run_in_background=true and timeout=86400 to re-arm the listener.]
+  F --> E
+```

package/scripts/kimi-subscribe.sh

@@ -60,12 +60,14 @@ fi
 PIDFILE="/tmp/patchcord_subscribe_${NAMESPACE_ID}_${AGENT_ID}.pid"
 NOTIFY_FILE="${HOME}/.kimi/patchcord-subscribe-notify.txt"
 
-# Pidfile guard: exit if another instance is running
+# Pidfile guard: if another instance is already running, that's the desired
+# state (typically the SessionStart hook armed the listener). Exit 0 so flow
+# skill invocations don't surface as "background task failed".
 if [ -f "$PIDFILE" ]; then
   OLD_PID=$(cat "$PIDFILE" 2>/dev/null || echo "")
   if [ -n "$OLD_PID" ] && kill -0 "$OLD_PID" 2>/dev/null; then
-    echo "Already running (pid $OLD_PID)" >&2
-    exit 2
+    echo "Patchcord listener already running (pid $OLD_PID)"
+    exit 0
   fi
 fi
 echo $$ > "$PIDFILE"

package/scripts/kimi-prompt-hook.sh

@@ -1,39 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-# UserPromptSubmit hook for Kimi CLI — intercepts legacy /skill:patchcord:*
-# prompts and gives Kimi a concrete correction. This is a compatibility shim;
-# SessionStart + Stop hooks are the primary Kimi integration.
-#
-# Kimi silently discards stdout from UserPromptSubmit hooks, but exit 2 + stderr
-# is fed back to the LLM as a correction. We exploit this to turn /skill: into
-# direct command execution.
-
-command -v jq >/dev/null 2>&1 || exit 0
-
-if [ -t 0 ]; then
-  INPUT=""
-else
-  INPUT=$(cat)
-fi
-PROMPT=$(echo "$INPUT" | jq -r '.prompt // ""' 2>/dev/null || echo "")
-
-# Map /skill:patchcord:* to direct command corrections. Kimi Skills are
-# documentation, not executable slash commands.
-case "$PROMPT" in
-  */skill:patchcord:subscribe*)
-    echo "Start the Patchcord listener immediately as a background Shell task: command 'patchcord subscribe --kimi 5', run_in_background true, timeout 86400. Do not run it in the foreground." >&2
-    exit 2
-    ;;
-  */skill:patchcord:inbox*)
-    echo "Execute immediately: call inbox(), do the requested work for each pending message, reply(), then re-arm Patchcord with a background Shell task: patchcord subscribe --kimi 5." >&2
-    exit 2
-    ;;
-  */skill:patchcord:wait*)
-    echo "Execute immediately: call wait_for_message() once. If a message arrives, do the work, reply(), then re-arm Patchcord with a background Shell task: patchcord subscribe --kimi 5." >&2
-    exit 2
-    ;;
-  *)
-    exit 0
-    ;;
-esac