patchcord 0.5.129 → 0.5.130

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "patchcord",
   "description": "Cross-machine agent messaging. Messages from other agents land in the inbox and wake the agent to reply.",
-  "version": "0.5.129",
+  "version": "0.5.130",
   "author": {
     "name": "ppravdin"
   },

package/bin/patchcord.mjs

@@ -98,13 +98,18 @@ ACCOUNT — log in to the CLI (commands below log in on demand)
   patchcord login                            Authenticate the CLI (your account)
 
 ORCHESTRATOR — set up the orchestrator agent (the shepherd) in this folder
-  patchcord orchestrator [--namespace <ns>] [--tool <harness>]
-                                             Provision the orchestrator here; launch it
-                                             to adopt this project or build a new team
+  patchcord orchestrator [--namespace <ns>] [--tool <harness>] [--project <name>]
+                                             Provision the orchestrator here (always a
+                                             lead — see PROJECTS below); launch it to
+                                             adopt this project or build a new team
 
 TEAM — the orchestrator's tools (run from the project root)
-  patchcord provision <agent> --tool <X> --role <Y> --namespace <ns> [--dir <sub/>]
-                                             Create a worker agent (identity + config)
+  patchcord provision <agent> --tool <X> --role <Y> --namespace <ns> [--dir <sub/>] \\
+        [--project <name>] [--lead]
+                                             Create a worker agent (identity + config).
+                                             --lead marks it as a cross-namespace lead
+                                             (--role lead does the same); --project
+                                             assigns its namespace (see PROJECTS below)
   patchcord pull <agent> --tool <X> --namespace <ns> [--dir <sub/>]
                                              Place an EXISTING agent into a folder
                                              (same identity, new token; nothing overwritten)
@@ -113,6 +118,15 @@ TEAM — the orchestrator's tools (run from the project root)
   patchcord team status                      Reconcile folder ↔ identity ↔ tmux ↔ token
   patchcord team launch                      Launch each worker in mux
 
+PROJECTS — cloud-only. Group your OWN namespaces so their leads may cross-message
+  (same user + same project + BOTH ends provisioned as leads → agent@namespace works;
+  anything else is always denied, no exceptions). Namespace names are unique across
+  ALL your projects — you can't reuse a name in a different project.
+  patchcord namespace set-project <namespace> <project>
+                                             Assign a namespace to a project
+  patchcord namespace set-project <namespace>
+                                             Clear it (namespace becomes isolated again)
+
 SCHEDULES — timed / recurring messages (user-level)
   patchcord schedule create <name> --namespace <ns> --to <agent> --content "..." \\
         (--at <ISO> | --cron "<expr>" | --every <sec>) \\
@@ -845,7 +859,7 @@ if (cmd === "subscribe") {
 // account token (user-level, tied to NO agent) lives at ~/.patchcord/auth.json
 // (legacy: main.json / master.json) or $PATCHCORD_TOKEN (legacy: *_MAIN/MASTER).
 // `patchcord login` authenticates; everything else logs in on demand.
-if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "provision" || cmd === "pull" || cmd === "team" || cmd === "schedule") {
+if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "provision" || cmd === "pull" || cmd === "team" || cmd === "schedule" || cmd === "namespace") {
   const M = { cyan: "\x1b[36m", green: "\x1b[32m", dim: "\x1b[2m", rst: "\x1b[0m" };
   const AUTH_CONFIG = join(HOME, ".patchcord", "auth.json");
   const LEGACY_CONFIGS = [join(HOME, ".patchcord", "main.json"), join(HOME, ".patchcord", "master.json")];
@@ -1042,7 +1056,7 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
 
   if (cmd === "provision") {
     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 || arg.startsWith("-")) { console.error("Usage: patchcord provision <agent> --tool X --role Y --namespace ns [--dir sub/] [--project name] [--lead]"); process.exit(1); }
     if (arg === "revoke") {
       const ra = process.argv[4];
       const ns = flagVal("namespace");
@@ -1056,8 +1070,18 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
     const role = flagVal("role", "");
     const ns = flagVal("namespace");
     const subdir = flagVal("dir", arg);
+    const project = flagVal("project", "");
+    // --lead marks this token as a project-scoped cross-namespace lead (server
+    // trusts ONLY this explicit, main-token-authenticated request — see
+    // patchcord-cloud's api_provision). `--role lead` also sets it server-side
+    // (role==="lead" is treated the same as is_lead:true), but `--lead` is the
+    // explicit, discoverable way to ask for it without overloading the
+    // free-text --role field.
+    const lead = process.argv.includes("--lead");
     if (!ns) { console.error("--namespace <project-namespace> required"); process.exit(1); }
-    const { status, json, m } = await accountCall("POST", "/api/provision", { namespace_id: ns, agent_id: arg, tool, role, label: `main:${tool}` });
+    const provisionBody = { namespace_id: ns, agent_id: arg, tool, role, label: `main:${tool}` };
+    if (lead) provisionBody.is_lead = true;
+    const { status, json, m } = await accountCall("POST", "/api/provision", provisionBody);
     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);
@@ -1076,10 +1100,48 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
         writeFileSync(tj, JSON.stringify(man, null, 2) + "\n");
       }
     } catch {}
-    console.log(`✓ provisioned ${M.green}${ns}:${arg}${M.rst} [${tool}${role ? "/" + role : ""}] → ${dir}`);
+    // --project assigns this namespace to a project — the cross-namespace lead
+    // chat boundary (namespaces in the same project may link leads; different
+    // projects, or no project, never can). Separate call: provisioning creates
+    // the agent identity, project assignment groups the NAMESPACE — safe to
+    // retry independently, and a namespace already in a project just gets
+    // reassigned (last call wins, server-side upsert).
+    if (project) {
+      const { status: pStatus, json: pJson } = await accountCall("POST", "/api/namespace/set-project", { namespace_id: ns, project });
+      if (pStatus !== "200") {
+        console.error(`  ${M.dim}warning: provisioned OK, but --project failed (HTTP ${pStatus}): ${pJson?.error || ""}${M.rst}`);
+      } else {
+        console.log(`  ${M.dim}namespace ${ns} assigned to project "${project}"${M.rst}`);
+      }
+    }
+    console.log(`✓ provisioned ${M.green}${ns}:${arg}${M.rst} [${tool}${role ? "/" + role : ""}${lead ? "/lead" : ""}] → ${dir}`);
     process.exit(0);
   }
 
+  if (cmd === "namespace") {
+    // Cloud-only: group namespaces into a "project" — the boundary
+    // cross-namespace lead chat is gated on. Same user + same project + both
+    // ends are provisioned leads (--lead / --role lead) → their leads may
+    // message each other with `agent@namespace`. Different project, or no
+    // project, or a non-lead agent → always denied, no exceptions.
+    const sub = process.argv[3];
+    if (sub === "set-project") {
+      const ns = process.argv[4];
+      const project = process.argv[5];
+      if (!ns) { console.error("Usage: patchcord namespace set-project <namespace> [project-name]\n  Omit project-name to clear (un-groups the namespace, reverting it to isolated)."); process.exit(1); }
+      const { status, json } = await accountCall("POST", "/api/namespace/set-project", { namespace_id: ns, project: project || "" });
+      if (status !== "200") { console.error(`set-project failed (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
+      if (json.status === "cleared") {
+        console.log(`✓ ${ns} un-grouped — no project, isolated (no cross-namespace lead peers)`);
+      } else {
+        console.log(`✓ ${ns} assigned to project "${json.project}"`);
+      }
+      process.exit(0);
+    }
+    console.error("Usage: patchcord namespace set-project <namespace> [project-name]");
+    process.exit(1);
+  }
+
   if (cmd === "pull") {
     // Inverse of provision: place an EXISTING agent identity into a folder.
     // Mints another token bound to the same agent_id@namespace (its original
@@ -1123,11 +1185,23 @@ if (cmd === "login" || cmd === "orchestrator" || cmd === "teamlead" || cmd === "
     const root = process.cwd();
     const ns = (flagVal("namespace", basename(root)) || "team").replace(/[^a-z0-9-]/gi, "-").toLowerCase();
     const tool = flagVal("tool", "claude_code");
+    const project = flagVal("project", "");
     const hostname = run("hostname -s") || run("hostname") || "unknown";
-    const { status, json, m } = await accountCall("POST", "/api/provision", { namespace_id: ns, agent_id: "orchestrator", tool, role: "orchestrator", label: "orchestrator:self" });
+    // is_lead: true always — the orchestrator IS the one identity per namespace
+    // meant to coordinate across teams. Harmless without --project: a lead with
+    // no project assignment has zero cross-namespace peers (fails closed).
+    const { status, json, m } = await accountCall("POST", "/api/provision", { namespace_id: ns, agent_id: "orchestrator", tool, role: "orchestrator", label: "orchestrator:self", is_lead: true });
     if (status !== "200" || !json?.token) { console.error(`could not set up orchestrator (HTTP ${status}): ${json?.error || ""}`); process.exit(1); }
     const base = String(json.url || `${m.baseUrl}/mcp`).replace(/\/mcp$/, "");
     writeWorkerConfig(tool, root, base, json.token, hostname);
+    if (project) {
+      const { status: pStatus, json: pJson } = await accountCall("POST", "/api/namespace/set-project", { namespace_id: ns, project });
+      if (pStatus !== "200") {
+        console.error(`  ${M.dim}warning: orchestrator set up OK, but --project failed (HTTP ${pStatus}): ${pJson?.error || ""}${M.rst}`);
+      } else {
+        console.log(`  ${M.dim}namespace ${ns} assigned to project "${project}"${M.rst}`);
+      }
+    }
     mkdirSync(join(root, ".patchcord"), { recursive: true });
     const tj = join(root, ".patchcord", "team.json");
     let manifest = { project: basename(root), namespace: ns, orchestrator: { agent: "orchestrator", tool }, agents: [] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchcord",
-  "version": "0.5.129",
+  "version": "0.5.130",
   "description": "Cross-machine agent messaging for Claude Code and Codex",
   "scripts": {
     "version": "node scripts/sync-plugin-version.mjs && git add .claude-plugin/plugin.json"

package/skills/inbox/SKILL.md

@@ -182,7 +182,10 @@ Named threads group related messages between a pair of agents. Use them for mult
 - Never ask "should I do this?" - just do it. User can undo in 3 seconds.
 - 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.
+- **Cross-namespace addressing (`agent@namespace`)**: the syntax always exists in `send_message`/`reply`, but what it actually reaches depends on who you are:
+  - **Ordinary agents (the default):** `agent@namespace` only ever works for YOUR OWN namespace — same as a bare name. Targeting any other namespace is rejected. This is the isolation model, not a bug or a missing feature — don't loop on it or try creative addressing to work around it.
+  - **Lead agents (cloud only — a small number of specially-provisioned identities per namespace, usually the orchestrator):** may reach a peer lead in a DIFFERENT namespace, but only if a human explicitly grouped both namespaces into the same "project" (a cloud-side setting you cannot set yourself from inside a session) — different project, or no project, is always rejected, no exceptions. If you don't know whether you're a lead, you're not one — this isn't discoverable by trial and error; ask the human.
+  - A rejection here is almost always correct behavior, not a server error — don't retry with variations of the name.
 - **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.