patchcord 0.5.103 → 0.5.105

package/bin/patchcord.mjs

@@ -797,7 +797,7 @@ if (cmd === "subscribe") {
 // (docs/main-agent.md). The "main" is the managing agent of a team; its main
 // token is a user-scoped provisioning credential stored at ~/.patchcord/main.json
 // (legacy: master.json) or $PATCHCORD_MAIN_TOKEN (legacy: $PATCHCORD_MASTER_TOKEN).
-if (cmd === "main" || cmd === "master" || cmd === "provision" || cmd === "team") {
+if (cmd === "main" || cmd === "master" || cmd === "provision" || cmd === "team" || cmd === "schedule") {
   const M = { cyan: "\x1b[36m", green: "\x1b[32m", dim: "\x1b[2m", rst: "\x1b[0m" };
   const MAIN_CONFIG = join(HOME, ".patchcord", "main.json");
   const LEGACY_CONFIG = join(HOME, ".patchcord", "master.json"); // pre-rename
@@ -1134,6 +1134,73 @@ if (cmd === "main" || cmd === "master" || cmd === "provision" || cmd === "team")
     console.error("Usage: patchcord team <init|list|launch|status>");
     process.exit(1);
   }
+
+  if (cmd === "schedule") {
+    // User-level scheduled / recurring messages (server Plan 041). Authed by
+    // the main token — the user can manage schedules in any namespace they own.
+    const m = requireMain();
+    const sub = process.argv[3];
+    const BASE = `${m.baseUrl}/api/dashboard/scheduled`;
+    const when = (s) => s.cron_expr ? `cron ${s.cron_expr}` : s.interval_sec ? `every ${s.interval_sec}s` : s.fire_at ? `once @ ${s.fire_at}` : s.schedule_kind;
+    const fmt = (s) => `${s.id}  ${M.green}${s.namespace_id}:${s.to_agent}${M.rst}  ${s.active ? "" : M.dim + "[paused] " + M.rst}${s.name}  ${M.dim}${when(s)}${s.next_fire_at ? ` → ${s.next_fire_at}` : ""}${M.rst}`;
+
+    if (sub === "list") {
+      const ns = flagVal("namespace");
+      const url = ns ? `${BASE}?namespace=${encodeURIComponent(ns)}` : BASE;
+      const { status, json } = await _httpJSON("GET", url, m.token);
+      if (status !== "200") { console.error(`list failed (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
+      const items = json?.schedules || [];
+      for (const s of items) console.log("  " + fmt(s));
+      if (!items.length) console.log("  (no schedules)");
+      process.exit(0);
+    }
+    if (sub === "create") {
+      const name = process.argv[4];
+      if (!name || name.startsWith("-")) { console.error('Usage: patchcord schedule create <name> --namespace <ns> --to <agent> --content "..." (--at <ISO> | --cron "<expr>" | --every <sec>) [--timezone <tz>] [--thread <slug>] [--max-runs N] [--expires <ISO>]'); process.exit(1); }
+      const ns = flagVal("namespace"), to = flagVal("to"), content = flagVal("content");
+      if (!ns || !to || !content) { console.error("--namespace, --to, and --content are required"); process.exit(1); }
+      const at = flagVal("at"), cron = flagVal("cron"), every = flagVal("every");
+      let schedule_kind, extra = {};
+      if (cron) { schedule_kind = "cron"; extra.cron_expr = cron; }
+      else if (every) { schedule_kind = "interval"; extra.interval_sec = parseInt(every, 10); }
+      else if (at) { schedule_kind = "once"; extra.fire_at = at; }
+      else { console.error('one of --at <ISO>, --cron "<expr>", or --every <seconds> is required'); process.exit(1); }
+      const body = { namespace: ns, name, to_agent: to, content, schedule_kind, timezone: flagVal("timezone", "UTC"), ...extra };
+      const thread = flagVal("thread"); if (thread) body.thread_slug = thread;
+      const maxRuns = flagVal("max-runs"); if (maxRuns) body.max_runs = parseInt(maxRuns, 10);
+      const expires = flagVal("expires"); if (expires) body.expires_at = expires;
+      const { status, json } = await _httpJSON("POST", BASE, m.token, body);
+      if (status !== "201" && status !== "200") { console.error(`create failed (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
+      console.log(`✓ scheduled ${M.green}${ns}:${to}${M.rst} [${schedule_kind}] ${M.dim}${json?.schedule?.id || ""}${M.rst}`);
+      process.exit(0);
+    }
+    if (sub === "cancel" || sub === "delete" || sub === "rm") {
+      const id = process.argv[4];
+      if (!id) { console.error("Usage: patchcord schedule cancel <id>"); process.exit(1); }
+      const { status, json } = await _httpJSON("DELETE", `${BASE}/${id}`, m.token);
+      if (status !== "200") { console.error(`cancel failed (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
+      console.log(`✓ cancelled ${id}`);
+      process.exit(0);
+    }
+    if (sub === "test" || sub === "fire") {
+      const id = process.argv[4];
+      if (!id) { console.error("Usage: patchcord schedule test <id>"); process.exit(1); }
+      const { status, json } = await _httpJSON("POST", `${BASE}/${id}/test`, m.token, {});
+      if (status !== "200") { console.error(`test failed (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
+      console.log(`✓ fired ${id} once (does not consume max-runs)`);
+      process.exit(0);
+    }
+    if (sub === "pause" || sub === "resume") {
+      const id = process.argv[4];
+      if (!id) { console.error(`Usage: patchcord schedule ${sub} <id>`); process.exit(1); }
+      const { status, json } = await _httpJSON("PATCH", `${BASE}/${id}`, m.token, { active: sub === "resume" });
+      if (status !== "200") { console.error(`${sub} failed (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
+      console.log(`✓ ${sub === "resume" ? "resumed" : "paused"} ${id}`);
+      process.exit(0);
+    }
+    console.error("Usage: patchcord schedule <create|list|cancel|test|pause|resume>");
+    process.exit(1);
+  }
 }
 
 if (cmd === "update" || cmd === "--update") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchcord",
-  "version": "0.5.103",
+  "version": "0.5.105",
   "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".