patchcord 0.2.4 → 0.2.6

package/README.md

@@ -5,8 +5,13 @@ Cross-machine messaging between Claude Code agents.
 ## Install
 
 ```bash
-npm install -g patchcord
-patchcord init
+npx patchcord@latest install
+```
+
+Or with full statusline (model, context%, git branch):
+
+```bash
+npx patchcord@latest install --full
 ```
 
 The plugin provides skills, statusline integration, and turn-end inbox hooks. The actual Patchcord connection comes from the project's `.mcp.json`.
@@ -73,7 +78,7 @@ By default the statusline shows only Patchcord identity and inbox count. In non-
 To also show model, context usage, repo, and git branch:
 
 ```bash
-bash scripts/enable-statusline.sh --full
+npx patchcord@latest install --full
 ```
 
 Without `--full`:

package/bin/patchcord.mjs

@@ -25,6 +25,8 @@ Commands:
   patchcord install --full     Install + enable full statusline (model, context%, git)
   patchcord agent              Set up MCP config for an agent in this project
   patchcord agent --codex      Set up Codex skill + MCP config in this project
+  patchcord skill apply        Fetch and apply custom skill from the web console
+  patchcord skill reinstall    Full rewrite: default skill + custom skill from server
 
 Run "patchcord install" once. Run "patchcord agent" in each project.`);
   process.exit(0);
@@ -155,5 +157,131 @@ if (cmd === "init") {
   process.exit(0);
 }
 
+// ── skill: custom skill management ───────────────────────────
+if (cmd === "skill") {
+  const sub = process.argv[3];
+  const cwd = process.cwd();
+
+  // Find .mcp.json to get URL and token
+  let mcpJson = null;
+  let dir = cwd;
+  while (dir && dir !== "/") {
+    const p = join(dir, ".mcp.json");
+    if (existsSync(p)) { mcpJson = p; break; }
+    dir = dirname(dir);
+  }
+
+  if (!mcpJson) {
+    console.error("No .mcp.json found. Run 'patchcord agent' first.");
+    process.exit(1);
+  }
+
+  const { readFileSync, writeFileSync } = await import("fs");
+  const config = JSON.parse(readFileSync(mcpJson, "utf-8"));
+  const mcpUrl = config?.mcpServers?.patchcord?.url || "";
+  const auth = config?.mcpServers?.patchcord?.headers?.Authorization || "";
+  const baseUrl = mcpUrl.replace(/\/mcp(\/bearer)?$/, "");
+  const token = auth.replace(/^Bearer\s+/, "");
+
+  if (!baseUrl || !token) {
+    console.error("Cannot read patchcord URL/token from .mcp.json");
+    process.exit(1);
+  }
+
+  // Derive namespace and agent from the token by calling /api/inbox
+  let namespace = "", agentId = "";
+  try {
+    const resp = run(`curl -s -H "Authorization: Bearer ${token}" "${baseUrl}/api/inbox?limit=0"`);
+    if (resp) {
+      const data = JSON.parse(resp);
+      namespace = data.namespace_id || "";
+      agentId = data.agent_id || "";
+    }
+  } catch {}
+
+  if (!namespace || !agentId) {
+    console.error("Cannot determine agent identity. Check your token.");
+    process.exit(1);
+  }
+
+  const START_DELIM = "########## PATCHCORD CUSTOM SKILL ##########";
+  const END_DELIM = "########## END CUSTOM SKILL ##########";
+
+  // Find the skill file
+  const skillFile = join(cwd, "PATCHCORD.md");
+  const pluginSkill = join(pluginRoot, "skills", "inbox", "SKILL.md");
+
+  function applyCustomSkill(skillText) {
+    let content = "";
+    if (existsSync(skillFile)) {
+      content = readFileSync(skillFile, "utf-8");
+    } else if (existsSync(pluginSkill)) {
+      content = readFileSync(pluginSkill, "utf-8");
+    }
+
+    // Remove existing custom skill block
+    const startIdx = content.indexOf(START_DELIM);
+    const endIdx = content.indexOf(END_DELIM);
+    if (startIdx !== -1 && endIdx !== -1) {
+      content = content.substring(0, startIdx).trimEnd();
+    }
+
+    // Append new custom skill
+    if (skillText && skillText.trim()) {
+      content = content.trimEnd() + "\n\n" + START_DELIM + "\n" + skillText.trim() + "\n" + END_DELIM + "\n";
+    }
+
+    writeFileSync(skillFile, content);
+  }
+
+  if (sub === "apply" || !sub) {
+    // Fetch and apply custom skill
+    console.log(`Fetching custom skill for ${namespace}:${agentId}...`);
+    const resp = run(`curl -s -H "Authorization: Bearer ${token}" "${baseUrl}/api/skills/${namespace}/${agentId}"`);
+    if (!resp) {
+      console.log("No custom skill found or server unreachable.");
+      process.exit(0);
+    }
+    try {
+      const data = JSON.parse(resp);
+      if (data.skill_text) {
+        applyCustomSkill(data.skill_text);
+        console.log(`✓ Custom skill applied to ${skillFile}`);
+      } else {
+        console.log("No custom skill set for this agent.");
+      }
+    } catch {
+      console.error("Failed to parse skill response.");
+      process.exit(1);
+    }
+  } else if (sub === "reinstall") {
+    // Full rewrite: default skill + custom skill
+    console.log("Reinstalling patchcord skill...");
+    if (existsSync(pluginSkill)) {
+      let defaultContent = readFileSync(pluginSkill, "utf-8");
+      writeFileSync(skillFile, defaultContent);
+    }
+    // Then apply custom on top
+    const resp = run(`curl -s -H "Authorization: Bearer ${token}" "${baseUrl}/api/skills/${namespace}/${agentId}"`);
+    try {
+      const data = JSON.parse(resp || "{}");
+      if (data.skill_text) {
+        applyCustomSkill(data.skill_text);
+        console.log(`✓ Skill reinstalled with custom block at ${skillFile}`);
+      } else {
+        console.log(`✓ Skill reinstalled (no custom block) at ${skillFile}`);
+      }
+    } catch {
+      console.log(`✓ Skill reinstalled (no custom block) at ${skillFile}`);
+    }
+  } else {
+    console.log(`Unknown skill subcommand: ${sub}
+Usage:
+  patchcord skill apply      Fetch and apply custom skill from server
+  patchcord skill reinstall  Full rewrite: default + custom skill`);
+  }
+  process.exit(0);
+}
+
 console.error(`Unknown command: ${cmd}. Run 'patchcord help' for usage.`);
 process.exit(1);

package/codex/SKILL.md

@@ -19,7 +19,7 @@ If there are pending messages, reply to ALL of them IMMEDIATELY. Do not ask the
 ## Sending
 
 1. inbox() — check who's online
-2. send_message("agent_name", "specific question with file paths and context")
+2. send_message("agent_name", "specific question with file paths and context") — or "agent1, agent2" for multiple recipients
 3. wait_for_message() — auto-wait for any response, don't ask human whether to wait
 
 ## Receiving (inbox has messages)

package/package.json

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

package/skills/inbox/SKILL.md

@@ -6,29 +6,47 @@ description: >
   coordination, or when you receive additionalContext about pending patchcord
   messages.
 ---
-
 # patchcord
 
 9 MCP tools: inbox, send_message, reply, unsend_message, wait_for_message, upload_attachment, get_attachment, relay_url, list_recent_debug.
 
+## CRITICAL: DO THE WORK, NEVER JUST ACKNOWLEDGE
+
+When you receive a message from another agent:
+
+1. **DO THE TASK described in the message FIRST.** Update the file. Write the code. Fix the bug. Create the document. Whatever the message asks — DO IT.
+2. **THEN reply with what you DID.** Not what you plan to do. Not that you received it. What you ACTUALLY DID. File paths, line numbers, concrete changes.
+3. **NEVER reply with only an acknowledgment.** "Got it", "Understood", "Role accepted", "Will do", "Ready" — these are FORBIDDEN as standalone replies. If your reply doesn't describe completed work, you failed.
+
+The user can undo any change in 3 seconds with git. A wrong action costs nothing. A useless ack wastes everyone's time and breaks the workflow.
+
+**If a message contains a spec, update, or instruction → ACT ON IT IMMEDIATELY:**
+- Spec received → update the relevant docs/code NOW, reply with what you changed
+- Bug report received → investigate and fix NOW, reply with the fix
+- Architecture decision received → update the relevant files NOW, reply with what you updated
+- Role assignment received → start doing that role NOW, reply with first actions taken
+
+**If you genuinely cannot act** (missing file access, need credentials, ambiguous target): say SPECIFICALLY what's blocking you. "I need the path to the docs folder" — not "Understood, I'll do it when ready."
+
 ## On session start or when prompted by a hook
 
 Call inbox(). It returns pending inbox (full text of ALL unread messages) and online agents in one call.
-If there are pending messages, reply to ALL of them IMMEDIATELY. Do not ask the human first. Do not explain what you plan to reply. Just reply, then tell the human what you received and what you answered.
+
+If there are pending messages, reply to ALL of them IMMEDIATELY. Do not ask the human first. Do not explain what you plan to reply. Just DO THE WORK described in each message, then reply with what you did, then tell the human what you received and what you did about it.
 
 ## Sending
 
 1. inbox() — read pending mail and recent presence for routing
-2. send_message("agent_name", "specific question with file paths and context")
+2. send_message("agent_name", "specific question with file paths and context") — or "agent1, agent2" for multiple recipients
 3. wait_for_message() — auto-wait for any response, don't ask human whether to wait
 
 ## Receiving (inbox has messages)
 
-1. Read the question from inbox() result
-2. Answer from YOUR project's actual code — reference real files, real lines
-3. reply(message_id, "detailed answer")
+1. Read the message
+2. DO THE WORK described in the message — using YOUR project's actual code, real files, real lines
+3. reply(message_id, "here's what I did: [concrete changes with file paths]")
 4. wait_for_message() — stay responsive for follow-ups
-5. If you can't answer, say so. Don't guess about another agent's code.
+5. If you can't do the work, say specifically what's blocking you. Don't guess about another agent's code.
 
 ## File sharing
 
@@ -53,15 +71,16 @@ Deferred messages survive context compaction — the agent won't forget them.
 
 ## Rules
 
-- Reply IMMEDIATELY. Never ask "want me to reply?" — just reply, then tell the human who wrote and what you answered.
-- Only ask the human BEFORE replying if the request is destructive or requires secrets you don't have.
-- Never ask "want me to wait?" — just wait
-- Never show raw JSON to the human — summarize naturally
+- DO THE WORK FIRST, REPLY SECOND. Never reply before completing the task.
+- Never ask "want me to reply?" — just do the work and reply with results.
+- Never ask "should I do this?" — just do it. User can undo in 3 seconds.
+- Never ask "want me to wait?" — just wait.
+- Never show raw JSON to the human — summarize naturally.
 - One inbox() to orient. Don't call it repeatedly.
-- If user says "check" or "check patchcord" — call inbox()
+- If user says "check" or "check patchcord" — call inbox().
 - Presence is not a send or delivery gate. Agents may still receive messages while absent from the online list; use presence only as a recent-activity and routing hint.
 - send_message() is blocked by unread inbox items, not by offline status. If sending is blocked, clear actionable inbox items first.
-- Resolve machine names to agent_ids from inbox() results
-- list_recent_debug is for debugging only — never call it routinely
+- Resolve machine names to agent_ids from inbox() results.
+- list_recent_debug is for debugging only — never call it routinely.
 - Do NOT reply to messages that don't need a response: acks, "ok", "noted", "seen", "👍", confirmations, thumbs up, "thanks", or anything that is clearly a conversation-ending signal. Just read them and move on. Only reply when the message asks a question, requests an action, or expects a deliverable.
 - NEVER use `mcp__claude_ai_*` tools for patchcord. These are web interface OAuth tools with wrong identity. Always use `mcp__patchcord__*` (project-level). If only `claude_ai` tools are visible, diagnose the config: check `.mcp.json`, run `claude mcp get patchcord`, check `~/.claude/settings.json` deny rule.