patchcord 0.5.99 → 0.5.102

package/bin/patchcord.mjs

@@ -793,22 +793,25 @@ if (cmd === "subscribe") {
 // works the same as the space-form (--token foo). The internal flag parsing below
 // supports both. Non-flag commands (channel, init, skill, help, plugin-path) have
 // their own branches above and below.
-// ── Master agent: provisioning + team orchestration ────────────────────────
-// (docs/master-agent.md). A master token is a user-scoped provisioning
-// credential stored at ~/.patchcord/master.json or $PATCHCORD_MASTER_TOKEN.
-if (cmd === "master" || cmd === "provision" || cmd === "team") {
+// ── Main agent: provisioning + team orchestration ──────────────────────────
+// (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") {
   const M = { cyan: "\x1b[36m", green: "\x1b[32m", dim: "\x1b[2m", rst: "\x1b[0m" };
-  const MASTER_CONFIG = join(HOME, ".patchcord", "master.json");
+  const MAIN_CONFIG = join(HOME, ".patchcord", "main.json");
+  const LEGACY_CONFIG = join(HOME, ".patchcord", "master.json"); // pre-rename
   const DEFAULT_API = process.env.PATCHCORD_BASE_URL || "https://api.patchcord.dev";
 
-  const readMaster = () => {
-    if (process.env.PATCHCORD_MASTER_TOKEN) {
-      return { token: process.env.PATCHCORD_MASTER_TOKEN, baseUrl: DEFAULT_API };
+  const readMain = () => {
+    const envTok = process.env.PATCHCORD_MAIN_TOKEN || process.env.PATCHCORD_MASTER_TOKEN;
+    if (envTok) return { token: envTok, baseUrl: DEFAULT_API };
+    for (const p of [MAIN_CONFIG, LEGACY_CONFIG]) {
+      try {
+        const m = JSON.parse(readFileSync(p, "utf-8"));
+        if (m && m.token) return { token: m.token, baseUrl: m.baseUrl || DEFAULT_API };
+      } catch {}
     }
-    try {
-      const m = JSON.parse(readFileSync(MASTER_CONFIG, "utf-8"));
-      if (m && m.token) return { token: m.token, baseUrl: m.baseUrl || DEFAULT_API };
-    } catch {}
     return null;
   };
   const flagVal = (name, def = "") => {
@@ -818,9 +821,9 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
     if (i >= 0 && process.argv[i + 1] && !process.argv[i + 1].startsWith("-")) return process.argv[i + 1];
     return def;
   };
-  const requireMaster = () => {
-    const m = readMaster();
-    if (!m) { console.error("No master token. Run: patchcord master connect"); process.exit(1); }
+  const requireMain = () => {
+    const m = readMain();
+    if (!m) { console.error("No main token. Run: patchcord main connect"); process.exit(1); }
     return m;
   };
   const writeWorkerConfig = (tool, dir, baseUrl, token, hostname) => {
@@ -862,16 +865,16 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
     });
   };
 
-  if (cmd === "master") {
+  if (cmd === "main" || cmd === "master") {
     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 master-connect session."); process.exit(1); }
+      if (!sessionId) { console.error("Could not start main-auth session."); process.exit(1); }
       const url = `https://patchcord.dev/master?session=${sessionId}`;
-      console.log(`\n  Authorize the master agent in your browser:\n  ${M.cyan}${url}${M.rst}\n`);
+      console.log(`\n  Authorize the main agent in your browser:\n  ${M.cyan}${url}${M.rst}\n`);
       console.log(`  ${M.dim}Waiting for authorization...${M.rst}`);
       const http = await import("http");
       const https = await import("https");
@@ -894,24 +897,24 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
         setTimeout(() => { try { req.destroy(); } catch {}; resolve(null); }, 900000);
       });
       if (!token) { console.error("\n  Authorization timed out or failed."); process.exit(1); }
-      mkdirSync(dirname(MASTER_CONFIG), { recursive: true });
-      writeFileSync(MASTER_CONFIG, JSON.stringify({ token, baseUrl: DEFAULT_API }, null, 2) + "\n");
-      console.log(`\n  ${M.green}✓${M.rst} Master token saved: ${M.dim}${MASTER_CONFIG}${M.rst}`);
+      mkdirSync(dirname(MAIN_CONFIG), { recursive: true });
+      writeFileSync(MAIN_CONFIG, JSON.stringify({ token, baseUrl: DEFAULT_API }, null, 2) + "\n");
+      console.log(`\n  ${M.green}✓${M.rst} Main token saved: ${M.dim}${MAIN_CONFIG}${M.rst}`);
       process.exit(0);
     }
     if (sub === "whoami") {
-      const m = requireMaster();
-      const { status, json } = await _httpJSON("GET", `${m.baseUrl}/api/master/whoami`, m.token);
-      if (status !== "200" || !json) { console.error(`master whoami failed (HTTP ${status})`); process.exit(1); }
-      console.log(`master · user ${json.user_id} · ${json.agents}/${json.quota} agents`);
+      const m = requireMain();
+      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);
     }
-    console.error("Usage: patchcord master <connect|whoami>");
+    console.error("Usage: patchcord main <connect|whoami>");
     process.exit(1);
   }
 
   if (cmd === "provision") {
-    const m = requireMaster();
+    const m = requireMain();
     const arg = process.argv[3];
     if (!arg || arg.startsWith("-")) { console.error("Usage: patchcord provision <agent> --tool X --role Y --namespace ns [--dir sub/]"); process.exit(1); }
     if (arg === "revoke") {
@@ -928,7 +931,7 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
     const ns = flagVal("namespace");
     const subdir = flagVal("dir", arg);
     if (!ns) { console.error("--namespace <project-namespace> required"); process.exit(1); }
-    const { status, json } = await _httpJSON("POST", `${m.baseUrl}/api/provision`, m.token, { namespace_id: ns, agent_id: arg, tool, role, label: `master:${tool}` });
+    const { status, json } = await _httpJSON("POST", `${m.baseUrl}/api/provision`, m.token, { namespace_id: ns, agent_id: arg, tool, role, label: `main:${tool}` });
     if (status !== "200" || !json?.token) { console.error(`provision failed (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
     const base = String(json.url || `${m.baseUrl}/mcp`).replace(/\/mcp$/, "");
     const dir = join(process.cwd(), subdir);
@@ -955,39 +958,39 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
     const sub = process.argv[3];
     if (sub === "init") {
       const project = process.argv[4];
-      if (!project) { console.error("Usage: patchcord team init <project> [--namespace ns] [--tool <master-harness>]"); process.exit(1); }
+      if (!project) { console.error("Usage: patchcord team init <project> [--namespace ns] [--tool <main-harness>]"); process.exit(1); }
       const ns = flagVal("namespace", project.replace(/[^a-z0-9-]/gi, "-").toLowerCase());
-      const masterTool = flagVal("tool", "claude_code");
+      const mainTool = flagVal("tool", "claude_code");
       const root = join(process.cwd(), project);
       mkdirSync(join(root, ".patchcord"), { recursive: true });
-      const manifest = { project, namespace: ns, pattern: "architect-workers-reviewer", master: null, agents: [] };
-      // Provision the master's OWN messaging identity IN the team namespace and
-      // write its config at the project root, so the master — running here —
-      // resolves to ns:master and SEES every worker it provisions into ns.
-      // Without this the master has no identity and whoami grabs a stale global.
-      const m = readMaster();
+      const manifest = { project, namespace: ns, pattern: "architect-workers-reviewer", main: null, agents: [] };
+      // Provision the main's OWN messaging identity IN the team namespace and
+      // write its config at the project root, so the main — running here —
+      // resolves to ns:main and SEES every worker it provisions into ns.
+      // Without this the main has no identity and whoami grabs a stale global.
+      const m = readMain();
       if (m) {
         const hostname = run("hostname -s") || run("hostname") || "unknown";
-        const { status, json } = await _httpJSON("POST", `${m.baseUrl}/api/provision`, m.token, { namespace_id: ns, agent_id: "master", tool: masterTool, role: "master", label: "master:self" });
+        const { status, json } = await _httpJSON("POST", `${m.baseUrl}/api/provision`, m.token, { namespace_id: ns, agent_id: "main", tool: mainTool, role: "main", label: "main:self" });
         if (status === "200" && json?.token) {
           const base = String(json.url || `${m.baseUrl}/mcp`).replace(/\/mcp$/, "");
-          writeWorkerConfig(masterTool, root, base, json.token, hostname);
-          manifest.master = { agent: "master", tool: masterTool };
-          console.log(`✓ master identity: ${M.green}${ns}:master${M.rst} [${masterTool}] — config written at ${root}`);
+          writeWorkerConfig(mainTool, root, base, json.token, hostname);
+          manifest.main = { agent: "main", tool: mainTool };
+          console.log(`✓ main identity: ${M.green}${ns}:main${M.rst} [${mainTool}] — config written at ${root}`);
         } else {
-          console.log(`⚠ could not provision master identity (HTTP ${status}: ${json?.error || ""}) — scaffolding only`);
+          console.log(`⚠ could not provision main identity (HTTP ${status}: ${json?.error || ""}) — scaffolding only`);
         }
       } else {
-        console.log(`⚠ no master token — run 'patchcord master connect' first, then re-run team init`);
+        console.log(`⚠ no main token — run 'patchcord main connect' first, then re-run team init`);
       }
       writeFileSync(join(root, ".patchcord", "team.json"), JSON.stringify(manifest, null, 2) + "\n");
-      writeFileSync(join(root, "AGENTS.md"), `# ${project} — Patchcord team\n\nNamespace: ${ns}\nMaster identity: ${ns}:master (you, when running patchcord from this folder)\nProvision workers: patchcord provision <agent> --tool X --role Y --namespace ${ns} --dir <agent>/\n`);
+      writeFileSync(join(root, "AGENTS.md"), `# ${project} — Patchcord team\n\nNamespace: ${ns}\nMain identity: ${ns}:main (you, when running patchcord from this folder)\nProvision workers: patchcord provision <agent> --tool X --role Y --namespace ${ns} --dir <agent>/\n`);
       console.log(`✓ team scaffolded: ${root} (namespace ${ns})`);
-      console.log(`  ${M.dim}cd ${project} — your identity there is ${ns}:master; you'll see every worker you provision into ${ns}.${M.rst}`);
+      console.log(`  ${M.dim}cd ${project} — your identity there is ${ns}:main; you'll see every worker you provision into ${ns}.${M.rst}`);
       process.exit(0);
     }
     if (sub === "list") {
-      const m = requireMaster();
+      const m = requireMain();
       const { status, json } = await _httpJSON("GET", `${m.baseUrl}/api/provision/list`, m.token);
       if (status !== "200") { console.error(`list failed (HTTP ${status})`); process.exit(1); }
       const agents = json?.agents || [];
@@ -995,20 +998,140 @@ if (cmd === "master" || cmd === "provision" || cmd === "team") {
       if (!agents.length) console.log("  (no agents)");
       process.exit(0);
     }
+    if (sub === "status") {
+      // Reconciler: folder ↔ patchcord identity ↔ tmux session ↔ token-active.
+      // Truth = .patchcord/team.json. For each agent we resolve the token from
+      // ITS folder's config (NOT cwd — identity is the folder), ask the server
+      // who that token is, and cross-check against tmux panes by cwd.
+      let manifest = null;
+      try { manifest = JSON.parse(readFileSync(join(process.cwd(), ".patchcord", "team.json"), "utf-8")); } catch {}
+      if (!manifest) { console.error("No .patchcord/team.json here — cd into the project root."); process.exit(1); }
+      const ns = manifest.namespace;
+      const real = (p) => run(`realpath -m ${JSON.stringify(p)}`) || p;
+      const AGENT_CMDS = /(^|\/)(claude|codex|kimi|kimi-code|opencode|gemini|node)$/;
+
+      // Token reader for a specific folder + tool (folder IS the identity).
+      const tokenInDir = (tool, dir) => {
+        try {
+          if (tool === "codex") {
+            const p = join(dir, ".codex", "config.toml");
+            if (!existsSync(p)) return null;
+            const blk = readFileSync(p, "utf-8").match(/\[mcp_servers\.patchcord[-\w]*\]([\s\S]*?)(?=\n\[|$)/);
+            if (!blk) return null;
+            const u = blk[1].match(/url\s*=\s*"([^"]+)"/);
+            const t = blk[1].match(/Bearer\s+([^\s"]+)/);
+            if (!u || !t) return null;
+            return { token: t[1], baseUrl: u[1].replace(/\/mcp(\/bearer)?$/, "") };
+          }
+          const map = {
+            opencode: [join(dir, "opencode.json"), ["mcp", "patchcord"]],
+            kimi: [join(dir, ".kimi-code", "mcp.json"), ["mcpServers", "patchcord"]],
+            "kimi-code": [join(dir, ".kimi-code", "mcp.json"), ["mcpServers", "patchcord"]],
+            claude_code: [join(dir, ".mcp.json"), ["mcpServers", "patchcord"]],
+          };
+          const [p, keyPath] = map[tool] || map.claude_code;
+          if (!existsSync(p)) return null;
+          const entry = keyPath.reduce((o, k) => o?.[k], JSON.parse(readFileSync(p, "utf-8")));
+          const auth = entry?.headers?.Authorization;
+          const url = entry?.url;
+          if (!auth || !url) return null;
+          return { token: auth.replace(/^Bearer\s+/i, ""), baseUrl: url.replace(/\/mcp(\/bearer)?$/, "") };
+        } catch { return null; }
+      };
+
+      // tmux pane inventory (best-effort).
+      const panes = [];
+      const tmuxOut = run(`tmux list-panes -a -F '#{session_name}\t#{window_index}\t#{pane_current_path}\t#{pane_current_command}'`);
+      if (tmuxOut) for (const l of tmuxOut.split("\n").filter(Boolean)) {
+        const [session, window, path, cmd] = l.split("\t");
+        panes.push({ session, window, path: real(path), cmd, claimed: false });
+      }
+
+      // Build the roster: main first, then workers.
+      const roster = [];
+      const mainEntry = manifest.main || manifest.master; // master = pre-rename
+      if (mainEntry) roster.push({ ...mainEntry, role: "main", dir: ".", _main: true });
+      for (const a of (manifest.agents || [])) roster.push(a);
+
+      const rows = [];
+      for (const a of roster) {
+        const dir = a.dir || a.agent;
+        const abs = real(join(process.cwd(), dir));
+        const exists = existsSync(abs);
+        const cfg = exists ? tokenInDir(a.tool, abs) : null;
+        let token = "no-config", identity = "—";
+        if (cfg) {
+          const { status, json } = await _httpJSON("GET", `${cfg.baseUrl}/api/agent/whoami`, cfg.token);
+          if (status === "200" && json) {
+            identity = `${json.namespace}:${json.agent}`;
+            const expected = `${a.namespace || ns}:${a.agent}`;
+            token = identity === expected ? "live" : `MISMATCH(want ${expected})`;
+          } else if (status === "401" || status === "403") token = `dead(${status})`;
+          else token = `err(${status})`;
+        } else if (!exists) token = "no-folder";
+        // tmux match by folder cwd.
+        let tmux = "—";
+        const hit = panes.find((p) => p.path === abs && AGENT_CMDS.test("/" + p.cmd));
+        if (hit) { hit.claimed = true; tmux = `${hit.session}:${hit.window}(${hit.cmd})`; }
+        else if (panes.some((p) => p.path === abs)) { const p = panes.find((p) => p.path === abs); p.claimed = true; tmux = `${p.session}:${p.window}(shell)`; }
+        rows.push({ role: a.role || "", agent: a.agent, dir: dir === "." ? "./" : dir + "/", identity, token, tmux });
+      }
+
+      // Render.
+      const C = (s, c) => `${c}${s}${M.rst}`;
+      console.log(`\n  team ${C(manifest.project, M.cyan)} · namespace ${C(ns, M.cyan)}\n`);
+      const cols = [["ROLE", "role"], ["AGENT", "agent"], ["FOLDER", "dir"], ["IDENTITY", "identity"], ["TOKEN", "token"], ["TMUX", "tmux"]];
+      const w = cols.map(([h, k]) => Math.max(h.length, ...rows.map((r) => String(r[k]).length)));
+      const line = (cells) => "  " + cells.map((c, i) => String(c).padEnd(w[i])).join("  ");
+      console.log(C(line(cols.map((c) => c[0])), M.dim));
+      for (const r of rows) {
+        const tokColor = r.token === "live" ? M.green : (r.token.startsWith("MISMATCH") || r.token.startsWith("dead") ? "\x1b[31m" : M.dim);
+        const cells = cols.map(([, k]) => k === "token" ? C(String(r[k]).padEnd(w[cols.findIndex((c) => c[1] === "token")]), tokColor) : String(r[k]).padEnd(w[cols.findIndex((c) => c[1] === k)]));
+        console.log("  " + cells.join("  "));
+      }
+
+      // Orphans: agent CLIs running in folders that are NOT team agents.
+      const orphans = panes.filter((p) => !p.claimed && AGENT_CMDS.test("/" + p.cmd));
+      if (orphans.length) {
+        console.log(`\n  ${C("⚠ unanchored agent sessions", "\x1b[33m")} (running outside any team folder — they get GLOBAL identity, not a team seat):`);
+        for (const p of orphans) {
+          const anchored = existsSync(join(p.path, ".mcp.json")) || existsSync(join(p.path, "opencode.json")) || existsSync(join(p.path, ".codex", "config.toml")) || existsSync(join(p.path, ".kimi-code", "mcp.json"));
+          console.log(`    ${p.session}:${p.window}  ${p.cmd}  ${C(p.path, M.dim)}${anchored ? "" : C("  [no project config → falls back to a stale global identity]", "\x1b[33m")}`);
+        }
+        console.log(`\n  ${C("fix:", M.dim)} provision a seat for the folder, then relaunch in place WITH the resume flag:`);
+        console.log(`    ${C(`patchcord provision <agent> --tool <tool> --role <role> --namespace ${ns} --dir <folder>/`, M.dim)}`);
+      }
+      console.log();
+      process.exit(0);
+    }
     if (sub === "launch") {
       let manifest = null;
       try { manifest = JSON.parse(readFileSync(join(process.cwd(), ".patchcord", "team.json"), "utf-8")); } catch {}
       if (!manifest) { console.error("No .patchcord/team.json here — cd into the project root."); process.exit(1); }
       const { spawnSync } = await import("child_process");
+      // Already-running folders: `mux new` would FRESH-launch and wipe their
+      // context. Skip them — relaunch-for-identity must resume in place
+      // (see the team-ops / mux skill). launch is for INITIAL boot only.
+      const real = (p) => run(`realpath -m ${JSON.stringify(p)}`) || p;
+      const running = new Set();
+      const tmuxOut = run(`tmux list-panes -a -F '#{pane_current_path}\t#{pane_current_command}'`);
+      if (tmuxOut) for (const l of tmuxOut.split("\n").filter(Boolean)) {
+        const [path, cmd] = l.split("\t");
+        if (/(^|\/)(claude|codex|kimi|kimi-code|opencode|gemini|node)$/.test("/" + cmd)) running.add(real(path));
+      }
       for (const a of (manifest.agents || [])) {
         const dir = join(process.cwd(), a.dir || a.agent);
+        if (running.has(real(dir))) {
+          console.log(`  ${M.dim}skip ${a.agent} — already running in ${dir}; relaunch-for-identity must resume in place, not fresh-launch (see team-ops skill).${M.rst}`);
+          continue;
+        }
         const muxTool = a.tool === "claude_code" ? "claude" : (a.tool === "kimi-code" ? "kimi" : a.tool);
         console.log(`  launching ${a.agent} (${muxTool}) in ${dir}`);
         spawnSync("mux", ["new", muxTool, "--dir", dir], { stdio: "inherit" });
       }
       process.exit(0);
     }
-    console.error("Usage: patchcord team <init|list|launch>");
+    console.error("Usage: patchcord team <init|list|launch|status>");
     process.exit(1);
   }
 }
@@ -1335,20 +1458,19 @@ 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");
+    // 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) => {
@@ -2210,14 +2332,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
@@ -2237,22 +2365,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.99",
+  "version": "0.5.102",
   "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
 ```