patchcord 0.5.100 → 0.5.103

package/bin/patchcord.mjs

@@ -869,7 +869,7 @@ if (cmd === "main" || cmd === "master" || cmd === "provision" || cmd === "team")
     const sub = process.argv[3];
     if (sub === "connect") {
       const harness = flagVal("harness", flagVal("tool", ""));
-      const create = run(`curl -sf --max-time 10 -X POST "${DEFAULT_API}/api/master/session" -H "Content-Type: application/json" -d '{"harness":"${harness}"}'`);
+      const create = run(`curl -sf --max-time 10 -X POST "${DEFAULT_API}/api/main/session" -H "Content-Type: application/json" -d '{"harness":"${harness}"}'`);
       let sessionId = "";
       try { sessionId = (JSON.parse(create).session_id) || ""; } catch {}
       if (!sessionId) { console.error("Could not start main-auth session."); process.exit(1); }
@@ -904,7 +904,7 @@ if (cmd === "main" || cmd === "master" || cmd === "provision" || cmd === "team")
     }
     if (sub === "whoami") {
       const m = requireMain();
-      const { status, json } = await _httpJSON("GET", `${m.baseUrl}/api/master/whoami`, m.token);
+      const { status, json } = await _httpJSON("GET", `${m.baseUrl}/api/main/whoami`, m.token);
       if (status !== "200" || !json) { console.error(`main whoami failed (HTTP ${status})`); process.exit(1); }
       console.log(`main · user ${json.user_id} · ${json.agents}/${json.quota} agents`);
       process.exit(0);
@@ -1458,22 +1458,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
   // Kimi CLI
   const hasKimi = run("which kimi");
   if (hasKimi) {
-    // Clean up old skill names (hyphen-style combined skill)
-    const oldKimiSkillDir = join(HOME, ".kimi", "skills", "patchcord");
-    const oldKimiWaitDir = join(HOME, ".kimi", "skills", "patchcord-wait");
-    if (existsSync(oldKimiSkillDir)) {
-      rmSync(oldKimiSkillDir, { recursive: true, force: true });
-    }
-    if (existsSync(oldKimiWaitDir)) {
-      rmSync(oldKimiWaitDir, { recursive: true, force: true });
-    }
-
-    // Install three focused Kimi skills
-    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");
@@ -1482,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;
@@ -2333,14 +2333,20 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       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
+    // Skills → user-level Kimi Code skills dir. Hyphen names so they register
+    // as /flow:patchcord-inbox (a colon kept them out of /flow:). Remove any
+    // stale colon-named dirs from prior installs.
     try {
-      for (const [label, rel] of [["patchcord:inbox", "inbox"], ["patchcord:wait", "wait"], ["patchcord:subscribe", "subscribe"]]) {
+      for (const stale of ["patchcord:inbox", "patchcord:wait", "patchcord:subscribe", "patchcord"]) {
+        const d = join(kimiCodeHome, "skills", stale);
+        if (existsSync(d)) { try { rmSync(d, { recursive: true, force: true }); } catch {} }
+      }
+      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}`);
+      console.log(`  ${green}✓${r} Skills installed: ${dim}${join(kimiCodeHome, "skills")}${r} ${dim}(/flow:patchcord-inbox)${r}`);
     } catch {}
   } else if (isKimi) {
     // Kimi CLI (Python): per-project .kimi/mcp.json + shell wrapper for --mcp-config-file
@@ -2360,22 +2366,22 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd?.startsWith("--")) {
       console.log(`\n  ${green}✓${r} Kimi CLI configured: ${dim}${kimiPath}${r}`);
       console.log(`  ${dim}Per-project — use the kimi-pc wrapper (see below) so Kimi loads this config.${r}`);
     }
-    // Install/update global skills (remove old combined skill, install three focused ones)
-    const oldKimiSkillDir = join(HOME, ".kimi", "skills", "patchcord");
-    const oldKimiWaitDir = join(HOME, ".kimi", "skills", "patchcord-wait");
-    if (existsSync(oldKimiSkillDir)) rmSync(oldKimiSkillDir, { recursive: true, force: true });
-    if (existsSync(oldKimiWaitDir)) rmSync(oldKimiWaitDir, { recursive: true, force: true });
-
-    const kimiInboxDir = join(HOME, ".kimi", "skills", "patchcord:inbox");
-    const kimiWaitDir = join(HOME, ".kimi", "skills", "patchcord:wait");
-    const kimiSubDir = join(HOME, ".kimi", "skills", "patchcord:subscribe");
+    // Install/update global skills. Hyphen names → /flow:patchcord-inbox
+    // (colon names never registered as flows). Remove old combined + colon dirs.
+    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 {} }
+    }
+    const kimiInboxDir = join(HOME, ".kimi", "skills", "patchcord-inbox");
+    const kimiWaitDir = join(HOME, ".kimi", "skills", "patchcord-wait");
+    const kimiSubDir = join(HOME, ".kimi", "skills", "patchcord-subscribe");
     mkdirSync(kimiInboxDir, { recursive: true });
     mkdirSync(kimiWaitDir, { recursive: true });
     mkdirSync(kimiSubDir, { recursive: true });
     cpSync(join(pluginRoot, "per-project-skills", "kimi", "inbox", "SKILL.md"), join(kimiInboxDir, "SKILL.md"));
     cpSync(join(pluginRoot, "per-project-skills", "kimi", "wait", "SKILL.md"), join(kimiWaitDir, "SKILL.md"));
     cpSync(join(pluginRoot, "per-project-skills", "kimi", "subscribe", "SKILL.md"), join(kimiSubDir, "SKILL.md"));
-    console.log(`  ${green}✓${r} Skills installed: ${dim}patchcord:inbox${r}, ${dim}patchcord:wait${r}, ${dim}patchcord:subscribe${r}`);
+    console.log(`  ${green}✓${r} Skills installed: ${dim}/flow:patchcord-inbox${r}, ${dim}-wait${r}, ${dim}-subscribe${r}`);
 
     // Install alias for per-project --mcp-config-file
     const aliasLine = `alias kimi-pc='kimi --mcp-config-file .kimi/mcp.json'`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchcord",
-  "version": "0.5.100",
+  "version": "0.5.103",
   "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,14 @@
 ---
-name: patchcord:inbox
+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).
+> Use `/flow:patchcord-inbox` to run this. `/skill:` only loads it as docs (Kimi design).
 
 ```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 shown 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', 'good', '👍', '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 of what you did') with file paths and line numbers. Never reply 'will do' / 'understood' / 'ready' 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'.]
+  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])
 ```

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

@@ -1,14 +1,14 @@
 ---
-name: patchcord:subscribe
+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).
+> Use `/flow:patchcord-subscribe` to run this. `/skill:` only loads it as docs (Kimi design).
 
 ```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 shown 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.]
+  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])
 ```

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

@@ -1,17 +1,17 @@
 ---
-name: patchcord:wait
+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).
+> Use `/flow:patchcord-wait` to run this. `/skill:` only loads it as docs (Kimi design).
 
 ```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.]
+  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'.]
+  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
 ```