remote-pi 0.4.0 → 0.4.2

package/dist/actions/handlers.d.ts

@@ -23,8 +23,8 @@
 import type { ClientMessage, ServerMessage, WireModel } from "../protocol/types.js";
 /**
  * Structural subset of the SDK's `Model<Api>` interface (defined in
- * `@mariozechner/pi-ai`, which is a transitive dep — not re-exported by
- * `@mariozechner/pi-coding-agent`'s main entry). Capturing just the
+ * `@earendil-works/pi-ai`, which is a transitive dep — not re-exported by
+ * `@earendil-works/pi-coding-agent`'s main entry). Capturing just the
  * fields we touch keeps the handler decoupled from the SDK's full Model
  * surface and avoids a direct dep on `pi-ai`.
  */

package/dist/actions/registry.d.ts

@@ -14,7 +14,7 @@
  * imports, no internal-state coupling — see the probe note in
  * `plan/28-pi-commands.md` Wave 0.
  */
-import { ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { ModelRegistry } from "@earendil-works/pi-coding-agent";
 /**
  * Lazily instantiate the shared `ModelRegistry`. Subsequent calls return
  * the same instance — keep it cached so `refresh()` cycles are cheap and

package/dist/actions/registry.js

@@ -14,7 +14,7 @@
  * imports, no internal-state coupling — see the probe note in
  * `plan/28-pi-commands.md` Wave 0.
  */
-import { ModelRegistry, AuthStorage } from "@mariozechner/pi-coding-agent";
+import { ModelRegistry, AuthStorage } from "@earendil-works/pi-coding-agent";
 let _registry = null;
 /**
  * Lazily instantiate the shared `ModelRegistry`. Subsequent calls return

package/dist/actions/registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/actions/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE3E,IAAI,SAAS,GAAyB,IAAI,CAAC;AAE3C;;;;GAIG;AACH,MAAM,UAAU,mBAAmB;IACjC,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,SAAS,GAAG,aAAa,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,2BAA2B;IACzC,SAAS,GAAG,IAAI,CAAC;AACnB,CAAC"}
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/actions/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAE7E,IAAI,SAAS,GAAyB,IAAI,CAAC;AAE3C;;;;GAIG;AACH,MAAM,UAAU,mBAAmB;IACjC,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,SAAS,GAAG,aAAa,CAAC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,2BAA2B;IACzC,SAAS,GAAG,IAAI,CAAC;AACnB,CAAC"}

package/dist/daemon/control_protocol.d.ts

@@ -8,7 +8,7 @@
  *
  * Plan/26 W2. The Pi RPC protocol (`pi --mode rpc`) used by the daemon
  * children themselves is a separate contract — see
- * `node_modules/@mariozechner/pi-coding-agent/dist/modes/rpc/rpc-types.d.ts`.
+ * `node_modules/@earendil-works/pi-coding-agent/dist/modes/rpc/rpc-types.d.ts`.
  * This file is strictly the supervisor's own control plane.
  */
 /** Per-daemon runtime state observable through the supervisor. */

package/dist/daemon/control_protocol.js

@@ -8,7 +8,7 @@
  *
  * Plan/26 W2. The Pi RPC protocol (`pi --mode rpc`) used by the daemon
  * children themselves is a separate contract — see
- * `node_modules/@mariozechner/pi-coding-agent/dist/modes/rpc/rpc-types.d.ts`.
+ * `node_modules/@earendil-works/pi-coding-agent/dist/modes/rpc/rpc-types.d.ts`.
  * This file is strictly the supervisor's own control plane.
  */
 // ── Serialization helpers ────────────────────────────────────────────────────

package/dist/index.d.ts

@@ -29,7 +29,7 @@
  *   AgentBridge (src/session/agent_bridge.ts) remains the tested, mockable unit
  *   for integration tests.
  */
-import type { ExtensionContext, ExtensionFactory } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext, ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import type { ClientMessage, SessionHistoryEvent } from "./protocol/types.js";
 import { PlainPeerChannel } from "./transport/peer_channel.js";
 export type RemoteState = "idle" | "started";

package/dist/index.js

@@ -30,7 +30,7 @@
  *   for integration tests.
  */
 import { randomUUID } from "node:crypto";
-import { SettingsManager } from "@mariozechner/pi-coding-agent";
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
 import { buildQRUri, qrSession, renderQRAscii } from "./pairing/qr.js";
 import { addPeer, getOrCreateEd25519Keypair, listOwnerPubkeys, listPeers, removePeer, } from "./pairing/storage.js";
 import { MeshClient } from "./mesh/client.js";
@@ -56,7 +56,7 @@ import { fileURLToPath } from "node:url";
 import { mkdirSync, copyFileSync, existsSync, unlinkSync, readFileSync, writeFileSync, realpathSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { spawnSync } from "node:child_process";
-import { hostname, homedir } from "node:os";
+import { hostname } from "node:os";
 import { kDefaultRelayUrl, resolveRelayUrl, saveConfig, isValidRelayUrl, isWebSocketScheme, toWebSocketUrl, } from "./config.js";
 let _state = "idle";
 let _relay = null;
@@ -930,11 +930,10 @@ const extension = (pi) => {
         _broadcastToActive({ type: "agent_done", in_reply_to: _currentTurnId });
         _currentTurnId = null;
     });
-    // plan/25 Wave 0: notify the local broker of turn lifecycle so it can
-    // ACK incoming agent-network envelopes as `busy` while this peer's LLM is
-    // mid-turn (and `received` once idle). Fire-and-forget — if the broker
-    // can't be reached, the worst case is a bad ACK answer; recovery is the
-    // next turn boundary. Skip silently when no mesh session is joined.
+    // plan/34: the broker no longer gates delivery on busy state, so we no
+    // longer notify it of turn lifecycle. Working state is still published as
+    // room_meta over the relay (plan/32) below — that's independent of the
+    // broker and drives the app's working indicator.
     pi.on("turn_start", (_event, ctx) => {
         // Late model hydration: if the model was still unknown at connect (resolved
         // lazily by the SDK), grab it on the first turn and fan it out — so a daemon
@@ -955,10 +954,6 @@ const extension = (pi) => {
         if (_relay && _myRoomId) {
             _relay.sendControl({ type: "room_meta_update", room_id: _myRoomId, meta: { working: true } });
         }
-        if (!_meshNode)
-            return;
-        void _meshNode.send("broker", { type: "turn_state", busy: true })
-            .catch(() => { });
     });
     pi.on("turn_end", () => {
         // Plan/32 Part B: publish working=false as room_meta (raw, no debounce).
@@ -967,10 +962,6 @@ const extension = (pi) => {
         if (_relay && _myRoomId) {
             _relay.sendControl({ type: "room_meta_update", room_id: _myRoomId, meta: { working: false } });
         }
-        if (!_meshNode)
-            return;
-        void _meshNode.send("broker", { type: "turn_state", busy: false })
-            .catch(() => { });
     });
     // Plan/32: compaction feedback. compact() doesn't run a turn, so bracket it
     // with working=true/false here. Returning void = no veto → default
@@ -2650,34 +2641,27 @@ if (_isDirectRun()) {
 }
 // ── `remote-pi claude` — launch Claude Code connected to the mesh ─────────────
 /**
- * Deploy the agent-network skill into the user-global Claude skills dir
- * (`~/.claude/skills/agent-network/SKILL.md`). The template ships in the
- * package at `skills/claude-agent-network/SKILL.md` (sibling of `dist/`).
- * Idempotent: overwrites on every launch so skill edits in the package
- * propagate. Best-effort — a failure here doesn't block the launch (the
- * MCP `instructions` + tool descriptions still give Claude the basics).
- *
- * Mirrors the Pi extension's `_deployAgentNetworkSkill()` (which targets
- * `~/.pi/remote/skills/`): same concept, each runtime's own skills dir.
+ * Resolve the packaged agent-network skill path
+ * (`<pkgRoot>/skills/agent-network/SKILL.md`). Single source of truth shared
+ * by both runtimes: Pi discovers it via `resources_discover`, and the Claude
+ * launcher injects it as a system prompt (see `_cmdClaudeCli`). Returns null
+ * if the file is missing (e.g. running before `pnpm build`).
  */
-function _deployClaudeMeshSkill() {
-    try {
-        const here = fileURLToPath(import.meta.url); // dist/index.js
-        const pkgRoot = dirname(dirname(here)); // package root (dist → ..)
-        const template = join(pkgRoot, "skills", "claude-agent-network", "SKILL.md");
-        if (!existsSync(template))
-            return;
-        const destDir = join(homedir(), ".claude", "skills", "agent-network");
-        mkdirSync(destDir, { recursive: true });
-        copyFileSync(template, join(destDir, "SKILL.md"));
-    }
-    catch {
-        /* best-effort — never block the launch on skill deploy */
-    }
+function _agentNetworkSkillPath() {
+    const here = fileURLToPath(import.meta.url); // dist/index.js (or src/index.ts via tsx)
+    const pkgRoot = dirname(dirname(here)); // package root (dist → ..; src → ..)
+    const skill = join(pkgRoot, "skills", "agent-network", "SKILL.md");
+    return existsSync(skill) ? skill : null;
 }
 async function _cmdClaudeCli(args) {
-    // Determine target cwd — first non-flag arg, or process.cwd()
-    const targetCwd = args.find((a) => !a.startsWith("--")) ?? process.cwd();
+    // Contract: `remote-pi claude [cwd] [claude-flags...]`. The optional cwd is
+    // ONLY the leading positional (first token, not a flag); everything after it
+    // is forwarded verbatim to the `claude` binary (e.g. `--resume`, `-c`,
+    // `-p "prompt"`). Restricting cwd to the leading token avoids mistaking a
+    // flag's value (e.g. the id in `--resume <id>`) for the cwd.
+    const hasCwdArg = args.length > 0 && !args[0].startsWith("-");
+    const targetCwd = hasCwdArg ? args[0] : process.cwd();
+    const passthroughArgs = hasCwdArg ? args.slice(1) : args;
     // Wizard when no local config exists
     if (!localConfigExists(targetCwd)) {
         const suggested = defaultAgentName(targetCwd);
@@ -2698,14 +2682,6 @@ async function _cmdClaudeCli(args) {
     }
     const absCwd = resolve(targetCwd);
     const SERVER_NAME = "remote-pi-mesh";
-    // Deploy the agent-network skill so Claude knows HOW to use the mesh tools
-    // (when to call get_messages, ACK statuses, cross-PC addressing, replies).
-    // Skills load only from disk — an MCP server can't inject one — so we write
-    // it to the user-global Claude skills dir, mirroring how the Pi extension
-    // deploys its own agent-network skill to ~/.pi/remote/skills/. The skill's
-    // `description` self-gates activation to mesh contexts, so a global deploy
-    // doesn't pollute unrelated Claude sessions.
-    _deployClaudeMeshSkill();
     // The channel feature (claude/channel push) only recognizes MCP servers
     // registered in one of the persistent scopes Claude Code enumerates:
     // enterprise / user / project / local. A server passed via `--mcp-config`
@@ -2713,30 +2689,42 @@ async function _cmdClaudeCli(args) {
     // scopes, so `--dangerously-load-development-channels server:<name>` can't
     // match it ("no MCP server configured with that name").
     //
-    // We therefore register in the **local** scope: per-project (only active in
-    // this cwd) and stored in `~/.claude.json` — NOT written into the project
-    // dir, NOT committed to VCS, NOT global. Best of both: no file pollution
-    // AND channels work.
+    // We therefore register in the **local** scope, stored in `~/.claude.json`
+    // (NOT written into the project dir, NOT committed to VCS, NOT global) so the
+    // dev-channel flag matches it. Caveat that drives the next decision: `-s
+    // local` is keyed by the **git repo root** and shares ONE entry per server
+    // name across every subdir of the repo — a same-name re-add overwrites it.
     //
     // remove-then-add makes it idempotent and refreshes the path if the
     // extension moved (Pi can reinstall to a new hash dir on upgrade).
+    //
+    // Crucially we do NOT bake `--cwd <absCwd>` into the registration. In a
+    // monorepo (app/, relay/, site/, …) every subproject is its own agent, but
+    // they'd all share this single repo-keyed entry — so whichever agent ran
+    // `remote-pi claude` LAST would leak its cwd to every other session, and the
+    // repo-root session would then spawn a peer that locks a subdir another agent
+    // owns ("Failed to connect"). Instead, the server resolves its folder from
+    // its own `process.cwd()`, which Claude sets to the directory each `claude`
+    // session was launched in (verified empirically — NOT the git root, NOT
+    // CLAUDE_PROJECT_DIR). We launch claude with `cwd: absCwd` below, so a single
+    // shared registration self-identifies as the right agent in every session.
     spawnSync("claude", ["mcp", "remove", SERVER_NAME, "-s", "local"], {
         cwd: absCwd, stdio: "ignore", shell: false,
     });
     const add = spawnSync("claude", [
         "mcp", "add", SERVER_NAME, "-s", "local", "--",
-        process.execPath, meshServerPath, "--cwd", absCwd,
+        process.execPath, meshServerPath,
     ], { cwd: absCwd, stdio: ["ignore", "pipe", "pipe"], shell: false, encoding: "utf8" });
     if (add.status !== 0) {
         console.log(`[remote-pi] failed to register MCP server: ${add.stderr || add.stdout}`);
         process.exit(1);
     }
-    const agentName = loadLocalConfig(targetCwd).agent_name ?? defaultAgentName(targetCwd);
-    process.stdout.write(`[remote-pi] Launching Claude as "${agentName}" in ${absCwd}\n`);
-    process.stdout.write(`[remote-pi] MCP server: ${meshServerPath} (local scope)\n`);
-    process.stdout.write(`[remote-pi] Tools: list_peers, agent_send, get_messages\n`);
-    process.stdout.write(`[remote-pi] Skill: agent-network (~/.claude/skills/)\n`);
-    process.stdout.write(`[remote-pi] Channel push enabled — incoming messages wake Claude\n\n`);
+    // Inject the agent-network protocol as a system prompt instead of deploying a
+    // skill file into ~/.claude. Anyone running `remote-pi claude` is here to use
+    // the mesh, so load the protocol unconditionally — no lazy skill gating, no
+    // global skills-dir pollution, and the packaged file is the single source of
+    // truth shared with the Pi runtime. Skipped only if the file is missing.
+    const skillPath = _agentNetworkSkillPath();
     // Launch flags:
     //   --dangerously-load-development-channels TAG  — enable claude/channel push
     //       for our local (non-allowlisted) server, so incoming mesh messages
@@ -2745,9 +2733,23 @@ async function _cmdClaudeCli(args) {
     //       (`plugin:<name>@<marketplace>` is the plugin form). Shows a one-time
     //       confirmation dialog at startup.
     //   --dangerously-skip-permissions               — auto-approve tool calls
+    //   --append-system-prompt-file=<skill>           — load the mesh protocol
+    // `--append-system-prompt-file` uses the glued `--flag=value` form (a SINGLE
+    // argv token) on purpose: tools that restore a session by capturing and
+    // replaying the live process's argv (e.g. cmux) drop the TRAILING token,
+    // which here was the skill path — leaving a dangling `--append-system-prompt-file`
+    // → `claude` aborts with "argument missing" and the session never comes back.
+    // As one token, the worst case is the whole flag being dropped: claude still
+    // starts (just without the injected protocol), which is recoverable instead
+    // of fatal. (The channels flag stays a separate pair — it's never last, so
+    // it isn't affected, and we don't risk a parser that may not accept `=`.)
+    // Any extra args the user passed (e.g. `--resume`, `-c`) are appended last so
+    // they reach the claude binary; ours come first as sensible defaults.
     spawnSync("claude", [
         "--dangerously-load-development-channels", `server:${SERVER_NAME}`,
         "--dangerously-skip-permissions",
+        ...(skillPath ? [`--append-system-prompt-file=${skillPath}`] : []),
+        ...passthroughArgs,
     ], {
         cwd: absCwd,
         stdio: "inherit",