patchcord 0.3.98 → 0.4.0

package/bin/patchcord.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { existsSync, mkdirSync, cpSync, readdirSync } from "fs";
-import { join, dirname } from "path";
+import { join, dirname, basename } from "path";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
 import { homedir } from "os";
@@ -80,6 +80,7 @@ if (cmd === "plugin-path") {
 if (!cmd || cmd === "install" || cmd === "agent" || cmd === "--token" || cmd === "--no-browser" || cmd === "--server") {
   const flags = cmd?.startsWith("--") ? process.argv.slice(2) : process.argv.slice(3);
   const fullStatusline = flags.includes("--full");
+  let wasPluginInstalled = false;
   const { readFileSync, writeFileSync, unlinkSync } = await import("fs");
 
   function safeReadJson(filePath) {
@@ -120,6 +121,7 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd === "--token" || cmd ===
     // doesn't detect new versions from local sources (#37252).
     run(`claude plugin marketplace add "${pluginRoot}"`);
     const installed = run(`claude plugin list`)?.includes("patchcord");
+    wasPluginInstalled = !!installed;
     if (installed) {
       run(`claude plugin update patchcord@patchcord-marketplace`);
       globalChanges.push("Claude Code plugin updated");
@@ -155,12 +157,16 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd === "--token" || cmd ===
       }
     }
 
-    const enableScript = join(pluginRoot, "scripts", "enable-statusline.sh");
-    if (existsSync(enableScript)) {
-      const slArg = fullStatusline ? " --full" : "";
-      const slResult = run(`bash "${enableScript}"${slArg}`);
-      if (slResult !== null && slResult.includes("statusline")) {
-        globalChanges.push(`Statusline${fullStatusline ? " (full)" : ""} enabled`);
+    // Statusline: enabled later in the Claude Code project-setup branch (prompts user).
+    // If --full flag passed non-interactively, install eagerly here so non-Claude-Code
+    // flows (e.g. setting up Codex on a machine with Claude Code) still get the upgrade.
+    if (fullStatusline) {
+      const enableScript = join(pluginRoot, "scripts", "enable-statusline.sh");
+      if (existsSync(enableScript)) {
+        const slResult = run(`bash "${enableScript}" --full`);
+        if (slResult !== null && slResult.includes("statusline")) {
+          globalChanges.push("Statusline (full) enabled");
+        }
       }
     }
   }
@@ -218,10 +224,10 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd === "--token" || cmd ===
       cpSync(join(pluginRoot, "skills", "patchcord-wait", "SKILL.md"), join(geminiWaitDir, "SKILL.md"));
       geminiChanged = true;
     }
-    if (!existsSync(join(geminiCmdDir, "patchcord.toml"))) {
+    if (!existsSync(join(geminiCmdDir, "inbox.toml"))) {
       mkdirSync(geminiCmdDir, { recursive: true });
-      cpSync(join(pluginRoot, "commands", "patchcord.toml"), join(geminiCmdDir, "patchcord.toml"));
-      cpSync(join(pluginRoot, "commands", "patchcord-wait.toml"), join(geminiCmdDir, "patchcord-wait.toml"));
+      cpSync(join(pluginRoot, "commands", "inbox.toml"), join(geminiCmdDir, "inbox.toml"));
+      cpSync(join(pluginRoot, "commands", "wait.toml"), join(geminiCmdDir, "wait.toml"));
       geminiChanged = true;
     }
     if (geminiChanged) globalChanges.push("Gemini CLI skills + commands installed");
@@ -993,14 +999,71 @@ if (!cmd || cmd === "install" || cmd === "agent" || cmd === "--token" || cmd ===
     }
     console.log(`\n  ${green}✓${r} Claude Code configured: ${dim}${mcpPath}${r}`);
 
-    // Enable patchcord statusline (agent identity + inbox count in status bar)
-    try {
-      const enableScript = join(pluginRoot, "scripts", "enable-statusline.sh");
-      if (existsSync(enableScript)) {
-        execSync(`bash "${enableScript}" --full`, { stdio: "ignore" });
-        console.log(`  ${green}✓${r} Statusline enabled`);
+    // Statusline: ask whether to enable full mode (unless --full flag passed or already configured).
+    const enableScript = join(pluginRoot, "scripts", "enable-statusline.sh");
+    if (existsSync(enableScript)) {
+      let currentStatusLine = "";
+      const claudeSettingsPath = join(HOME, ".claude", "settings.json");
+      if (existsSync(claudeSettingsPath)) {
+        try {
+          const s = JSON.parse(readFileSync(claudeSettingsPath, "utf-8"));
+          currentStatusLine = s?.statusLine?.command || "";
+        } catch {}
       }
-    } catch {}
+      const hasPatchcordStatusLine = currentStatusLine.includes("patchcord");
+
+      let installFull = null; // true = install, null = skip
+      if (fullStatusline) {
+        installFull = true; // already handled in global setup, but re-run is idempotent
+      } else if (!hasPatchcordStatusLine) {
+        // Build preview with user's real values
+        const dirName = basename(cwd) || "project";
+        let branchPart = "";
+        const gitBranch = run(`git -C "${cwd}" symbolic-ref --short HEAD 2>/dev/null`);
+        if (gitBranch) {
+          const dirty = run(`git -C "${cwd}" status --porcelain 2>/dev/null`);
+          const star = dirty ? `${red}*${green}` : "";
+          branchPart = ` ${green}(${gitBranch}${star})${r}`;
+        }
+        const idStr = identity || "your-agent@namespace";
+        const idParts = idStr.split("@");
+        const idPart = idParts.length === 2
+          ? `${white}${idParts[0]}${r}${dim}@${idParts[1]}${r}`
+          : `${white}${idStr}${r}`;
+        const machinePart = hostname ? ` ${dim}(${hostname})${r}` : "";
+        const sep = `${dim} │ ${r}`;
+        const blue = "\x1b[38;2;0;153;255m";
+        const example = `${blue}Claude Opus 4.7${r}${sep}${green}0%${r}${sep}${cyan}${dirName}${r}${branchPart}${sep}${idPart}${machinePart}`;
+
+        console.log(``);
+        console.log(`  Patchcord can show live agent identity + context in Claude Code's status bar.`);
+        console.log(``);
+        console.log(`  Full mode: ${example}`);
+        console.log(``);
+
+        const defaultYes = !wasPluginInstalled;
+        const promptStr = defaultYes
+          ? `  ${bold}Install full status bar?${r} ${dim}(Y/n):${r} `
+          : `  ${bold}Install full status bar?${r} ${dim}(y/N):${r} `;
+        const { createInterface: createRLS } = await import("readline");
+        const rlS = createRLS({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise((resolve) => rlS.question(promptStr, resolve));
+        rlS.close();
+        const a = (answer || "").trim().toLowerCase();
+        const yes = defaultYes
+          ? !(a === "n" || a === "no")
+          : (a === "y" || a === "yes");
+        if (yes) installFull = true;
+      }
+      // else: existing patchcord statusline — leave it alone
+
+      if (installFull === true) {
+        try {
+          execSync(`bash "${enableScript}" --full`, { stdio: "ignore" });
+          console.log(`  ${green}✓${r} Statusline enabled`);
+        } catch {}
+      }
+    }
   }
 
   // Warn about gitignore for per-project configs with tokens

package/package.json

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

package/per-project-skills/codex/SKILL.md

@@ -122,7 +122,9 @@ Send the returned `path` to the other agent in your message so they can download
 ## Rules
 
 - Do the work first, reply second. Never reply before completing the task.
-- Do not send ack-only replies to "ok", "noted", "seen", "thanks", or conversation-ending signals. Just read them and move on.
+- **Do not reply to acks.** "ok", "noted", "seen", "thanks", "good progress", "keep running" — read them and move on. If you must close the thread: `reply(id, resolve=true)` with NO content.
+- **resolve=true with ack-only content is an anti-pattern.** `reply(id, "Noted", resolve=true)` creates a new pending message the other side feels compelled to answer — producing ack chains. Omit content when there's nothing substantive to add: `reply(id, resolve=true)`.
+- **When you receive an ack**, close it silently: `reply(id, resolve=true)`. No content. This stops the chain.
 - Do not show raw JSON to the user unless they explicitly ask for it.
 - Use `agent@namespace` when the online list shows multiple namespaces for the same agent name.
 - Keep Patchcord config project-local. Do not rely on global shell exports.

package/per-project-skills/web/SKILL.md

@@ -53,7 +53,7 @@ Use the dominant topic of your current conversation as the tag. Keep it short (1
 
 6. **Never show raw JSON** - summarize naturally.
 
-7. **Do not reply to acks**: "ok", "noted", "seen", "thanks", thumbs up, or conversation-ending signals. Only reply when a question is asked, an action is requested, or a deliverable is expected. Use `resolve=true` on your reply when a thread is done. This applies even when an ack is for another session — don't defer-route acks, just leave them alone.
+7. **Do not reply to acks**: "ok", "noted", "seen", "thanks", "good progress", thumbs up, or conversation-ending signals. If you must close the thread: `reply(id, resolve=true)` with NO content. Never send a text reply to an ack. **resolve=true with ack-only content is an anti-pattern** — "Noted, thanks" + resolve creates a new pending message that chains into more acks. Omit content when there's nothing substantive. When you receive an ack, close it silently: `reply(id, resolve=true)`. This applies even when an ack is for another session — don't defer-route acks, just silently resolve them.
 
 8. **Presence is not a delivery gate**: an agent may receive messages while absent from the online list. Always send regardless of online/offline status. Messages queue and deliver when the recipient checks inbox.
 

package/skills/patchcord/SKILL.md

@@ -121,6 +121,8 @@ Named threads group related messages between a pair of agents. Use them for mult
 - Never ask "want me to wait?" - check presence and wait or don't based on that.
 - Never show raw JSON to the human - summarize naturally.
 - Cross-namespace agents: use `agent@namespace` syntax in send_message when targeting a specific namespace.
-- Do not reply to messages that don't need a response: acks, "ok", "noted", "seen", thumbs up, confirmations, "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.
+- **Do not reply to acks.** "ok", "noted", "seen", "thanks", "good progress", "keep running", thumbs up — anything that is clearly a conversation-ending signal. Just read them and move on. If you must close the thread, use `reply(id, resolve=true)` with NO content. Never send a text reply to an ack.
+- **resolve=true with ack-only content is an anti-pattern.** `reply(id, "Noted, thanks", resolve=true)` creates a new pending message the other side feels compelled to answer — producing ack chains. If you have nothing substantive to add, omit content entirely: `reply(id, resolve=true)`. Only include content with resolve when it carries new information the recipient needs.
+- **When you receive an ack**, close it silently: `reply(id, resolve=true)`. No content. This stops the chain.
 - MCP tools are cached at session start. New tools deployed after your session began are invisible until you start a new session. If a tool you expect is missing, this is why.
 - Agent names change frequently. Do not memorize or hardcode them. Check inbox() for recent activity. When unsure which agent to message, ask the human.

package/skills/patchcord-wait/SKILL.md

@@ -22,3 +22,5 @@ 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.