remote-pi 0.2.0 → 0.4.0

package/dist/index.js

@@ -30,19 +30,19 @@
  *   for integration tests.
  */
 import { randomUUID } from "node:crypto";
-import { buildQRUri, qrSession, renderQRAscii, startQRRotation } from "./pairing/qr.js";
+import { SettingsManager } from "@mariozechner/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";
 import { SelfRevoke } from "./mesh/self_revoke.js";
 import { RelayClient, RoomAlreadyOpenError } from "./transport/relay_client.js";
 import { PlainPeerChannel } from "./transport/peer_channel.js";
 import { roomIdForCwd } from "./rooms.js";
-import { SessionPeer } from "./session/peer.js";
 import { registerAgentTools } from "./session/tools.js";
-import { BrokerRemote } from "./session/broker_remote.js";
 import { formatPeerInventory } from "./session/peer_inventory.js";
-import { PiForwardClient } from "./transport/pi_forward_client.js";
-import { discoverSelfLabel, discoverSiblings, fallbackLabel } from "./mesh/siblings.js";
+import { MeshNode } from "./session/mesh_node.js";
+import { handleSessionCompact, handleSessionNew, handleModelSet, handleThinkingSet, handleListModels, } from "./actions/handlers.js";
+import { ensureModelRegistry } from "./actions/registry.js";
 import { ensureGlobalDirs, LOCAL_SESSION_NAME, sessionAuditPath, sessionSockPath, skillsDir, } from "./session/global_config.js";
 import { acquireCwdLock } from "./session/cwd_lock.js";
 import { addDaemon, listDaemons, removeDaemon } from "./daemon/registry.js";
@@ -51,10 +51,12 @@ import { installService, uninstallService, linkCliBinaries, unlinkCliBinaries }
 import { defaultAgentName, effectiveAutoStartRelay, loadLocalConfig, localConfigExists, saveLocalConfig, } from "./session/local_config.js";
 import { runSetupWizard } from "./session/setup_wizard.js";
 import { updateFooter } from "./ui/footer.js";
-import { join } from "node:path";
+import { join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { mkdirSync, copyFileSync, existsSync, unlinkSync, readFileSync } from "node:fs";
-import { hostname } from "node:os";
+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 { kDefaultRelayUrl, resolveRelayUrl, saveConfig, isValidRelayUrl, isWebSocketScheme, toWebSocketUrl, } from "./config.js";
 let _state = "idle";
 let _relay = null;
@@ -74,17 +76,22 @@ let _relayUrl = null; // URL used by current _relay connection
 const _activePeers = new Map();
 let _peerShort = ""; // shortid of the most recently attached peer (UX hint only)
 let _myRoomId = null; // this Pi's room id (derived from cwd)
+// Plan/28 Wave D.1: `thinking` published alongside `model` so the app's
+// Quick Actions sheet hydrates the thinking segmented control on first
+// open instead of starting null. The SDK fires `thinking_level_select`
+// on every change (initial load + user toggle), mirrored to room_meta
+// the same way model is — apps subscribe to one channel for both.
 let _myRoomMeta = null;
 let _currentModel = undefined; // last-known model name
+let _currentThinking = undefined; // last-known thinking level
 // ── Agent-network session (plano 19) ──────────────────────────────────────────
-let _sessionPeer = null;
+// MeshNode owns both the local UDS mesh (SessionPeer) and the optional
+// cross-PC relay bridge (BrokerRemote + PiForwardClient). The bridge is
+// attached via `_meshNode.attachBridge()` once the relay WS is up and this
+// Pi is the leader; MeshNode re-attaches it across UDS failovers.
+let _meshNode = null;
 let _sessionName = null;
 let _sessionPeerCount = 0;
-// Plan/25 Wave B/C — cross-PC routing. Instantiated when this Pi has the
-// local broker (leader) AND the relay WS is up. Detached on either side
-// of those preconditions falling away.
-let _brokerRemote = null;
-let _piForwardClient = null;
 // Cached state of global pairings (`peers.json`). Pairing is per-machine, so a
 // device paired in any Pi process is paired everywhere. Refreshed on boot,
 // after addPeer (handle_pair_request), and after removePeer (revoke).
@@ -118,61 +125,51 @@ function _refreshSessionPeerCount(peer, ctx) {
 function _currentModelName() {
     return _currentModel;
 }
-// ── Cross-PC mesh wiring (plan/25 Wave B/C) ───────────────────────────────────
 /**
- * Bring up the cross-PC router when both prerequisites are met:
- *   1. local session peer is the leader (we host the Broker)
- *   2. relay WS is up (`_relay !== null`)
- *
- * Idempotent: safe to call from `_cmdStart`, `_cmdJoin`, post-failover
- * reconnect, etc. Self-heals: if siblings can't be loaded (no mesh blob
- * yet, network hiccup) we still attach a `BrokerRemote` with an empty
- * sibling set — push from a remote sibling will populate the cache later.
+ * Cache the active model name and fan it out to subscribed apps via a
+ * `room_meta_update`. The relay push is a no-op when the room isn't up yet —
+ * the next `room_meta` hello carries the cached value instead. Shared by the
+ * `model_select` event and the connect/turn-start seeding, so a daemon that
+ * just runs its DEFAULT model still reports it: `model_select` only fires on an
+ * explicit set/cycle (never on settings load), so default-model daemons would
+ * otherwise never surface their model.
  */
-async function _ensureBrokerRemote() {
-    if (_brokerRemote !== null)
-        return;
-    if (!_sessionPeer || _sessionPeer.currentRole() !== "leader")
-        return;
-    const broker = _sessionPeer.localBroker();
-    if (!broker)
-        return;
-    if (!_relay || !_relayUrl || !_cachedEd25519)
-        return;
-    const pi = new PiForwardClient(_relay);
-    _piForwardClient = pi;
-    const selfPubkeyB64 = Buffer.from(_cachedEd25519.publicKey).toString("base64");
-    // Best-effort sibling + label discovery — failures are non-fatal.
-    let selfPcLabel = fallbackLabel(selfPubkeyB64);
-    let siblings = [];
-    try {
-        const meshClient = new MeshClient(_relayUrl);
-        const owners = await listOwnerPubkeys();
-        if (owners.length > 0) {
-            const [labelRes, sibs] = await Promise.all([
-                discoverSelfLabel({ client: meshClient, ownerEpks: owners, myPubkey: _cachedEd25519.publicKey }),
-                discoverSiblings({ client: meshClient, ownerEpks: owners, myPubkey: _cachedEd25519.publicKey }),
-            ]);
-            selfPcLabel = labelRes.selfPcLabel;
-            siblings = sibs;
-        }
+function _setCurrentModel(name) {
+    _currentModel = name;
+    if (_myRoomMeta)
+        _myRoomMeta = { ..._myRoomMeta, model: name };
+    if (_relay && _myRoomId) {
+        _relay.sendControl({ type: "room_meta_update", room_id: _myRoomId, meta: { model: name } });
+    }
+}
+/**
+ * Plan/32: publish the `working` flag as room_meta (raw, no debounce — the
+ * app debounces). Same shape as model/thinking updates. Used by turn_start/end
+ * AND by the compaction handlers: `compact()` doesn't run a turn (it
+ * disconnects the agent + aborts, emitting compaction_start, NOT turn_start),
+ * so room_meta.working must be bracketed manually around compaction.
+ */
+function _publishWorking(working) {
+    if (_myRoomMeta)
+        _myRoomMeta = { ..._myRoomMeta, working };
+    if (_relay && _myRoomId) {
+        _relay.sendControl({ type: "room_meta_update", room_id: _myRoomId, meta: { working } });
     }
-    catch (err) {
-        console.error(`[remote-pi] broker_remote bootstrap: sibling discovery failed: ${String(err)}`);
-    }
-    _brokerRemote = new BrokerRemote({
-        broker,
-        pi,
-        selfPcLabel,
-        selfPcPubkey: selfPubkeyB64,
-        siblings,
-    });
 }
-function _teardownBrokerRemote() {
-    _brokerRemote?.detach();
-    _brokerRemote = null;
-    _piForwardClient?.detach();
-    _piForwardClient = null;
+// ── Cross-PC mesh wiring (plan/25 Wave B/C) ───────────────────────────────────
+/**
+ * Hand the live relay to MeshNode so it can bring up the cross-PC bridge
+ * (BrokerRemote + sibling discovery) — but only when this Pi is the leader
+ * (broker host). MeshNode is idempotent + re-attaches across UDS failovers,
+ * so this is safe to call from `_cmdStart`, relay reconnect, or SelfRevoke.
+ * No-op until the relay WS + cached identity are both present.
+ */
+function _attachBridgeIfReady() {
+    if (!_meshNode || !_relay || !_relayUrl || !_cachedEd25519)
+        return;
+    void _meshNode
+        .attachBridge({ relay: _relay, relayUrl: _relayUrl, keypair: _cachedEd25519 })
+        .catch(() => { });
 }
 /** Refreshes the Pi TUI footer slots from current module state. Safe no-op when ctx lacks ui. */
 function _refreshFooter(ctx) {
@@ -189,7 +186,7 @@ function _refreshFooter(ctx) {
         // `/remote-pi status` line, not the footer slot).
         devicePaired: _anyPeerActive() ? _peerShort : undefined,
         hasPairings: _hasGlobalPairings,
-        agentName: _sessionPeer?.name(),
+        agentName: _meshNode?.name(),
     };
     updateFooter({ ui: { setStatus: ui.setStatus.bind(ui), setTitle: ui.setTitle.bind(ui) } }, state);
 }
@@ -242,6 +239,42 @@ export function _setSessionStartedAtForTest(ts) {
 export function _setCurrentModelForTest(name) {
     _currentModel = name;
 }
+/** Test-only: override the bound AgentSession so a spy can capture the
+ *  content handed to `sendUserMessage` (plan/30 multimodal ingest). */
+export function _setPiForTest(pi) {
+    _pi = pi;
+}
+/**
+ * Persist a model change to the PROJECT settings (`<cwd>/.pi/settings.json`) so
+ * a model picked from the app survives a Pi/daemon restart. `pi.setModel` only
+ * sets the LIVE model — on the next restart a fresh session reads the saved
+ * default and reverts (the reported bug). We write the PROJECT scope, NOT
+ * global, deliberately: the SDK merges global←project with PROJECT winning
+ * (`SettingsManager`), so a folder that already has a project default (every
+ * created daemon does) would shadow a global write like the TUI's. Project
+ * scope is also correct for a fleet — each daemon keeps its own model rather
+ * than leaking one default globally.
+ *
+ * Read-merge-write + best-effort: preserves other keys and never throws (a
+ * settings write must not fail the live model change, which already applied).
+ */
+function _persistModelDefault(provider, modelId) {
+    try {
+        const path = join(process.cwd(), ".pi", "settings.json");
+        let obj = {};
+        try {
+            const parsed = JSON.parse(readFileSync(path, "utf8"));
+            if (parsed && typeof parsed === "object")
+                obj = parsed;
+        }
+        catch { /* no existing/parseable file → start fresh */ }
+        obj["defaultProvider"] = provider;
+        obj["defaultModel"] = modelId;
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, JSON.stringify(obj, null, 2));
+    }
+    catch { /* best-effort — model change already applied live */ }
+}
 // Per-turn messaging state
 let _currentTurnId = null;
 // Module-level pi reference
@@ -370,8 +403,8 @@ function _detachPeerChannel(appPeerId) {
  * the raw cwd path.
  */
 function _displayName(cwd) {
-    if (_sessionPeer)
-        return _sessionPeer.name();
+    if (_meshNode)
+        return _meshNode.name();
     const local = loadLocalConfig(cwd);
     return local.agent_name || defaultAgentName(cwd);
 }
@@ -424,7 +457,7 @@ function _goIdle(byeReason) {
     _selfRevoke?.stop();
     _selfRevoke = null;
     // Cross-PC routing relies on _relay being up; tear it down here too.
-    _teardownBrokerRemote();
+    _meshNode?.detachBridge();
     // Preserve _sessionStartedAt + _messageBuffer across stop/start cycles.
     // The Pi agent session outlives the relay connection — `message_end` keeps
     // firing for terminal turns even while idle, and the buffer must survive
@@ -463,7 +496,7 @@ function _onRelayClose() {
     _relay = null; // _relayUrl preserved for retry
     // Cross-PC routing relies on _relay; bring it down. Will be re-instated
     // by _attemptReconnect on success.
-    _teardownBrokerRemote();
+    _meshNode?.detachBridge();
     _state = "started";
     _refreshFooter();
     _scheduleReconnect();
@@ -520,9 +553,7 @@ async function _attemptReconnect() {
     relay.on("close", _onRelayClose);
     _stopAutoListener = _installAutoListener(relay);
     // Plan/25 Wave B/C: relay is back; bring cross-PC routing back online.
-    void _ensureBrokerRemote().catch((err) => {
-        console.error(`[remote-pi] _ensureBrokerRemote (post-reconnect) failed: ${String(err)}`);
-    });
+    _attachBridgeIfReady();
     // _state stays "started"; peer reconnect (if previously paired) flows
     // through _installAutoListener → _findKnownPeer → _promoteToPaired
     // automatically when the app sends any inner.
@@ -743,12 +774,22 @@ async function _handlePairRequest(relay, appPeerId, inner) {
     });
 }
 // ── Extension factory (default export) ───────────────────────────────────────
-// Stores most recent command context so the auto-listener can use ui.notify
+// Stores most recent command context so the auto-listener can use ui.notify.
+// NOTE: this is a CAPTURED command ctx — the SDK marks it stale after a
+// session replacement (newSession/fork/switch/reload). We re-capture it via
+// `withSession` when WE drive a newSession (see the session_new dispatch).
 let _lastCtx = null;
+// Freshest base ExtensionContext, re-captured on EVERY `session_start`
+// (startup/new/fork/reload/resume). The session_start ctx is always bound to
+// the CURRENT session, so compact (a base-ctx method) routed through here
+// never hits a stale ctx — regardless of who triggered the replacement (an
+// app Quick Action OR a `/new` typed in the Pi TUI). It carries only base-ctx
+// methods (no newSession — that's command-ctx only), so command ops keep using
+// `_lastCtx`.
+let _lastEventCtx = null;
 const _noopCtx = { ui: { notify: () => undefined }, abort: () => undefined };
 const extension = (pi) => {
     _pi = pi;
-    console.error(`[remote-pi] session sync limit: ${_getSyncLimit()}`);
     // Plano 19: ensure ~/.pi/remote/{sessions,skills}/ exist and deploy the
     // agent-network skill on first load. resources_discover lets Pi find it.
     try {
@@ -761,9 +802,9 @@ const extension = (pi) => {
     _refreshPairingsCache();
     pi.on("resources_discover", () => ({ skillPaths: [skillsDir()] }));
     // Plano 20: agent_send + agent_request tools so the LLM can drive the
-    // session network natively. Getter captures `_sessionPeer` live so the
+    // session network natively. Getter captures `_meshNode` live so the
     // tool always sees the current state.
-    registerAgentTools(pi, () => _sessionPeer);
+    registerAgentTools(pi, () => _meshNode?.peer() ?? null);
     // Tool calls execute without prompting the remote user. The Pi SDK has no
     // native `requiresApproval` per tool, and a hardcoded gate (Bash/Edit/Write)
     // misfired on every custom tool from third-party packages. Approval will
@@ -791,19 +832,29 @@ const extension = (pi) => {
         const modelName = m?.name ?? m?.id;
         if (!modelName)
             return;
-        _currentModel = modelName;
-        // Keep the cached room_meta fresh so a future reconnect carries the
-        // current model in its hello (otherwise the post-reconnect hello would
-        // ship the stale model that was active at _cmdStart time).
+        // Cache + fan out. Keeps the cached room_meta fresh so a future reconnect
+        // carries the current model in its hello, and pushes a room_meta_update to
+        // apps already subscribed.
+        _setCurrentModel(modelName);
+    });
+    // Plan/28 Wave D.1: mirror model's room_meta_update path for thinking
+    // level so the app hydrates the segmented control on first open instead
+    // of starting null. SDK fires `thinking_level_select` on settings load
+    // AND on every user toggle (matching `model_select`'s behavior), so
+    // late-pairing apps see the current level via `room_meta_updated`.
+    pi.on("thinking_level_select", (event) => {
+        const level = event?.level;
+        if (!level)
+            return;
+        _currentThinking = level;
         if (_myRoomMeta)
-            _myRoomMeta = { ..._myRoomMeta, model: modelName };
+            _myRoomMeta = { ..._myRoomMeta, thinking: level };
         if (!_relay || !_myRoomId)
             return;
-        console.error(`[remote-pi] model_select → ${modelName}`);
         _relay.sendControl({
             type: "room_meta_update",
             room_id: _myRoomId,
-            meta: { model: modelName },
+            meta: { thinking: level },
         });
     });
     pi.on("message_update", (event) => {
@@ -831,9 +882,14 @@ const extension = (pi) => {
     pi.on("tool_execution_end", (event) => {
         if (!_anyPeerActive())
             return;
+        // Stringify like the history mapper (same helper) so the live text == what
+        // a session_sync replays for this tool. Raw `String(event.result)` turned
+        // a content-array/object into "[object Object]" and the success branch sent
+        // the object unstringified — both diverging from re-sync.
+        const text = _stringifyToolResult(event.result);
         const msg = event.isError
-            ? { type: "tool_result", tool_call_id: event.toolCallId, error: String(event.result) }
-            : { type: "tool_result", tool_call_id: event.toolCallId, result: event.result };
+            ? { type: "tool_result", tool_call_id: event.toolCallId, error: text }
+            : { type: "tool_result", tool_call_id: event.toolCallId, result: text };
         _broadcastToActive(msg);
     });
     // Cumulative session buffer fed via `message_end`, which fires once per
@@ -850,6 +906,21 @@ const extension = (pi) => {
         if (m.role === "user" || m.role === "assistant" || m.role === "toolResult") {
             _messageBuffer.push(m);
         }
+        // Forward a failed turn to connected owners. Without this the app just
+        // hangs with no response when the provider errors (e.g. the TUI's
+        // "Provider finish_reason: error"): the SDK surfaces the failure as an
+        // assistant message with stopReason "error" + an `errorMessage` (pi-ai).
+        // `error` is an existing ServerMessage the app already renders — no
+        // protocol/app change. `in_reply_to` ties it to the turn the app awaits.
+        if (m.role === "assistant" && m.stopReason === "error" && _anyPeerActive()) {
+            const message = typeof m.errorMessage === "string" && m.errorMessage
+                ? m.errorMessage
+                : "Provider error";
+            const errMsg = _currentTurnId
+                ? { type: "error", in_reply_to: _currentTurnId, code: "provider_error", message }
+                : { type: "error", code: "provider_error", message };
+            _broadcastToActive(errMsg);
+        }
     });
     pi.on("agent_end", () => {
         // Buffer is fed by `message_end`; here we only finalize the outbound
@@ -864,18 +935,71 @@ const extension = (pi) => {
     // 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.
-    pi.on("turn_start", () => {
-        if (!_sessionPeer)
+    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
+        // whose model only materialises at turn 1 still reports it to the app.
+        if (!_currentModel) {
+            try {
+                const m = ctx.getModel?.();
+                const name = m?.name ?? m?.id;
+                if (name)
+                    _setCurrentModel(name);
+            }
+            catch { /* defensive — never block a turn on a model lookup */ }
+        }
+        // Plan/32 Part B: publish working=true as room_meta (raw, no debounce —
+        // the debounce lives in the app). Same shape as the model/thinking updates.
+        if (_myRoomMeta)
+            _myRoomMeta = { ..._myRoomMeta, working: true };
+        if (_relay && _myRoomId) {
+            _relay.sendControl({ type: "room_meta_update", room_id: _myRoomId, meta: { working: true } });
+        }
+        if (!_meshNode)
             return;
-        void _sessionPeer.send("broker", { type: "turn_state", busy: true })
+        void _meshNode.send("broker", { type: "turn_state", busy: true })
             .catch(() => { });
     });
     pi.on("turn_end", () => {
-        if (!_sessionPeer)
+        // Plan/32 Part B: publish working=false as room_meta (raw, no debounce).
+        if (_myRoomMeta)
+            _myRoomMeta = { ..._myRoomMeta, working: false };
+        if (_relay && _myRoomId) {
+            _relay.sendControl({ type: "room_meta_update", room_id: _myRoomId, meta: { working: false } });
+        }
+        if (!_meshNode)
             return;
-        void _sessionPeer.send("broker", { type: "turn_state", busy: false })
+        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
+    // compaction proceeds.
+    pi.on("session_before_compact", () => {
+        _publishWorking(true);
+    });
+    pi.on("session_compact", (event) => {
+        const entry = event?.compactionEntry;
+        const summary = typeof entry?.summary === "string" ? entry.summary : "";
+        const tokensBefore = typeof entry?.tokensBefore === "number" ? entry.tokensBefore : 0;
+        const ts = Date.now();
+        // (2) Persist in history: the CompactionEntry never reaches _messageBuffer
+        // via message_end (only user/assistant/toolResult), so push a synthetic
+        // marker the mapper turns into a `compaction` event — survives session_sync.
+        _messageBuffer.push({ role: "compaction", content: summary, timestamp: ts, tokensBefore });
+        // (1) Live result to every connected owner.
+        _broadcastToActive({ type: "compaction", summary, tokens_before: tokensBefore, ts });
+        // (3) Working ends.
+        _publishWorking(false);
+    });
+    // Re-capture the freshest base ctx on every session replacement so compact
+    // never operates on a stale captured ctx — this is the fix for the
+    // "stale after session replacement" crash when the app taps Compact after a
+    // New session. Fires on startup/new/fork/reload/resume; the ctx is always
+    // bound to the current session.
+    pi.on("session_start", (_event, ctx) => {
+        _lastEventCtx = ctx;
+    });
     // ── Commands ──────────────────────────────────────────────────────────────
     //
     // Final surface: 8 commands. Pre-2026-05-23 we had 20 commands covering
@@ -937,10 +1061,10 @@ const extension = (pi) => {
                 await _cmdPeers(ctx);
             }
             else if (sub.startsWith("create")) {
-                _cmdCreate(sub.slice("create".length).trim(), ctx);
+                await _cmdCreate(sub.slice("create".length).trim(), ctx);
             }
             else if (sub.startsWith("remove")) {
-                _cmdRemove(sub.slice("remove".length).trim(), ctx);
+                await _cmdRemove(sub.slice("remove".length).trim(), ctx);
             }
             else if (sub === "daemons") {
                 await _cmdDaemonsList(ctx);
@@ -993,12 +1117,12 @@ const extension = (pi) => {
     // Daemon registry (plan/26 Wave 1) — create + remove. start/stop/send/
     // status/install/uninstall come in later waves with the supervisor.
     pi.registerCommand("remote-pi create", {
-        description: "Register a folder as a daemon (will be supervised once `install` runs)",
-        handler: async (args, ctx) => { _lastCtx = ctx; _cmdCreate(args.trim(), ctx); },
+        description: "Register a folder as a daemon and start it (when the supervisor is running)",
+        handler: async (args, ctx) => { _lastCtx = ctx; await _cmdCreate(args.trim(), ctx); },
     });
     pi.registerCommand("remote-pi remove", {
-        description: "Unregister a daemon by id (local config is preserved)",
-        handler: async (args, ctx) => { _lastCtx = ctx; _cmdRemove(args.trim(), ctx); },
+        description: "Stop + unregister a daemon by id (local config is preserved)",
+        handler: async (args, ctx) => { _lastCtx = ctx; await _cmdRemove(args.trim(), ctx); },
     });
     // Fleet ops via the supervisor (plan/26 W2). `/remote-pi stop` stays as
     // local stop — fleet stop is `/remote-pi daemon stop`.
@@ -1011,6 +1135,18 @@ const extension = (pi) => {
     // Service install / uninstall (plan/26 W3)
     pi.registerCommand("remote-pi install", { description: "Install pi-supervisord as a system service + link the remote-pi CLI into ~/.local/bin (systemd/launchd)", handler: async (_, ctx) => { _lastCtx = ctx; _cmdInstall(ctx, { linkCli: true }); } });
     pi.registerCommand("remote-pi uninstall", { description: "Remove the pi-supervisord system service + the ~/.local/bin symlinks (daemons registry preserved)", handler: async (_, ctx) => { _lastCtx = ctx; _cmdUninstall(ctx, { linkCli: true }); } });
+    // Daemon mode: when spawned by pi-supervisord (REMOTE_PI_DAEMON=1) there is
+    // no human to type /remote-pi, so we auto-init after the factory returns.
+    // _cmdRoot checks localConfig.auto_start_relay and connects to the relay +
+    // local broker automatically; if no config exists it is a no-op (no wizard
+    // in headless mode).
+    if (process.env["REMOTE_PI_DAEMON"] === "1") {
+        const daemonCtx = {
+            ui: { notify: (msg) => process.stderr.write(`${msg}\n`) },
+            cwd: process.cwd(),
+        };
+        setTimeout(() => { void _cmdRoot(daemonCtx); }, 0);
+    }
 };
 export default extension;
 // ── Command implementations ───────────────────────────────────────────────────
@@ -1025,8 +1161,8 @@ function _cmdStatus(ctx) {
     const relayUrl = _relayUrl ?? resolveRelayUrl().url;
     // Mesh line
     let meshLine;
-    if (_sessionPeer) {
-        const name = _sessionPeer.name();
+    if (_meshNode) {
+        const name = _meshNode.name();
         meshLine = `🟢 Local mesh: connected as "${name}" (${_sessionPeerCount} peer${_sessionPeerCount === 1 ? "" : "s"})`;
     }
     else {
@@ -1058,13 +1194,13 @@ function _cmdStatus(ctx) {
  * their machine vs. on a paired sibling Pi.
  */
 async function _cmdPeers(ctx) {
-    if (!_sessionPeer) {
+    if (!_meshNode) {
         ctx.ui.notify("[remote-pi] Not on the local mesh. Run /remote-pi to join.", "warning");
         return;
     }
     let peers;
     try {
-        const reply = await _sessionPeer.request("broker", { type: "list_peers" }, 2000);
+        const reply = await _meshNode.request("broker", { type: "list_peers" }, 2000);
         peers = reply.body?.peers ?? [];
     }
     catch (err) {
@@ -1073,7 +1209,7 @@ async function _cmdPeers(ctx) {
     }
     // Exclude self from the printed list — `list_peers` returns every peer
     // registered with the broker including the caller, which is noise here.
-    const selfName = _sessionPeer.name();
+    const selfName = _meshNode.name();
     ctx.ui.notify(`[remote-pi] peers:\n${formatPeerInventory(peers, selfName)}`, "info");
 }
 /**
@@ -1109,30 +1245,25 @@ async function _cmdRoot(ctx) {
             return;
         }
         const baseDefault = defaultAgentName(cwd);
-        const wizardResult = await runSetupWizard(ui, {
+        const newConfig = await runSetupWizard(ui, {
             agent_name: baseDefault,
             use_relay: true,
-            enable_daemon: false,
         });
-        if (!wizardResult) {
+        if (!newConfig) {
             ctx.ui.notify("[remote-pi] Setup cancelled.", "info");
             return;
         }
-        // `enable_daemon` is wizard-only state, not part of LocalConfig.
-        const { enable_daemon, ...newConfig } = wizardResult;
         saveLocalConfig(cwd, newConfig);
         ctx.ui.notify(`[remote-pi] Config saved to ${cwd}/.pi/remote-pi/config.json`, "info");
         await _cmdJoin(ctx);
         if (effectiveAutoStartRelay(newConfig))
             await _cmdStart(ctx);
-        if (enable_daemon)
-            _cmdInstall(ctx, { linkCli: true });
         _cmdStatus(ctx);
         return;
     }
     // Returning user with config: auto-start if requested + currently inactive.
     const config = loadLocalConfig(cwd);
-    if (effectiveAutoStartRelay(config) && !_sessionPeer) {
+    if (effectiveAutoStartRelay(config) && !_meshNode) {
         await _cmdJoin(ctx);
         if (_state === "idle")
             await _cmdStart(ctx);
@@ -1152,23 +1283,16 @@ async function _cmdSetup(ctx) {
     }
     const current = loadLocalConfig(cwd);
     const baseDefault = defaultAgentName(cwd);
-    const wizardResult = await runSetupWizard(ui, {
+    const newConfig = await runSetupWizard(ui, {
         agent_name: current.agent_name ?? baseDefault,
         use_relay: effectiveAutoStartRelay(current),
-        // No way to introspect launchd/systemd here without shelling out;
-        // default the wizard to "off" — re-running setup is for changing
-        // your mind, not for re-confirming current OS state.
-        enable_daemon: false,
     });
-    if (!wizardResult) {
+    if (!newConfig) {
         ctx.ui.notify("[remote-pi] Setup cancelled.", "info");
         return;
     }
-    const { enable_daemon, ...newConfig } = wizardResult;
     saveLocalConfig(cwd, newConfig);
     ctx.ui.notify("[remote-pi] Config updated. Run /remote-pi to apply now.", "info");
-    if (enable_daemon)
-        _cmdInstall(ctx, { linkCli: true });
 }
 async function _cmdStart(ctx) {
     if (_state !== "idle") {
@@ -1186,17 +1310,55 @@ async function _cmdStart(ctx) {
     // Same name we send in pair_ok — keeps room_meta.name and the per-pair
     // session_name aligned so the app shows consistent labels.
     const sessionName = _displayName(cwd);
-    // Initial model from ctx (ExtensionContext.model is the SDK's current
-    // selection — set by user settings or last-used). May be undefined on
-    // first boot before any model_select; that's fine, room_meta omits the
-    // field then.
-    const ctxModelName = ctx.model;
-    if (ctxModelName)
-        _currentModel = ctxModelName.name ?? ctxModelName.id ?? undefined;
+    // Seed the current model from the SDK's resolved selection so room_meta
+    // carries it on connect. `model_select` only fires on an explicit set/cycle
+    // (NOT on settings load), so a headless daemon that just runs its default
+    // model never emits it — without this its room_meta would omit the model and
+    // the app shows "unknown". `getModel()` returns the session's resolved model
+    // in every mode (interactive + RPC daemon); turn_start hydrates it later if
+    // the SDK resolves the model lazily.
+    if (!_currentModel) {
+        try {
+            const c = ctx;
+            // Prefer the live getModel() / ctx.model — populated for an interactive
+            // Pi. For a HEADLESS DAEMON both are undefined at connect: the SDK only
+            // resolves `this.model` lazily at the first turn, and `model_select`
+            // never fires for a default-model session. So fall back to the CONFIGURED
+            // default (defaultProvider/defaultModel in <cwd>/.pi/settings.json) — the
+            // model the daemon will actually use. Without this an idle daemon (never
+            // prompted → no turn) would never report its model and the app shows
+            // "unknown". turn_start still hydrates a later override.
+            const live = c.getModel?.() ?? c.model;
+            if (live) {
+                _currentModel = live.name ?? live.id ?? undefined;
+            }
+            else {
+                const sm = SettingsManager.create(cwd);
+                const provider = sm.getDefaultProvider();
+                const modelId = sm.getDefaultModel();
+                if (modelId) {
+                    const found = provider ? ensureModelRegistry().find(provider, modelId) : undefined;
+                    _currentModel = found?.name ?? modelId;
+                }
+            }
+        }
+        catch { /* defensive — never block start on a model lookup */ }
+    }
+    // Plan/28 Wave D.1: seed thinking from the SDK's current level so the
+    // first room_meta hello already carries it. `pi.getThinkingLevel()` is
+    // safe at this point — extension factory has been bound by the SDK
+    // before any command handler fires. Future toggles go through the
+    // `thinking_level_select` event handler above.
+    try {
+        _currentThinking = _pi?.getThinkingLevel();
+    }
+    catch { /* defensive — never block /remote-pi start on this */ }
     const roomMeta = { name: sessionName, cwd };
     const modelName = _currentModelName();
     if (modelName)
         roomMeta.model = modelName;
+    if (_currentThinking)
+        roomMeta.thinking = _currentThinking;
     // Persist so _attemptReconnect can replay the same hello payload — without
     // this, reconnect issues a bare hello and the relay creates a "default room"
     // entry that surfaces in the app as a phantom legacy session.
@@ -1269,24 +1431,25 @@ async function _cmdStart(ctx) {
                     display: true,
                 });
             },
-            // Plan/25 Wave D: keep broker_remote's sibling list in sync with
+            // Plan/25 Wave D: keep the cross-PC sibling list in sync with
             // mesh_versions. The poller fires this whenever the union of Pi
-            // members across owners changes — adding/removing a sibling, or
-            // an owner relabeling a nickname. `_brokerRemote` may be null
-            // until `_ensureBrokerRemote` finishes; the callback short-circuits.
+            // members across owners changes — adding/removing a sibling, or an
+            // owner relabeling a nickname. MeshNode.setSiblings is a no-op until
+            // the bridge is up (follower / relay down), so this is always safe.
             onMembersChanged: (siblings) => {
-                _brokerRemote?.setSiblings(siblings);
+                _meshNode?.setSiblings(siblings);
             },
+            // Silent log: routine self-revoke audit and per-Owner fetch
+            // failures don't belong in the TUI chat panel. User-facing
+            // revocation events flow through `onRevoke` → `pi.sendMessage`.
+            log: { info: () => { }, warn: () => { }, error: () => { } },
         });
         _selfRevoke.start();
     }
     // Plan/25 Wave B/C: bring up cross-PC routing if local broker is ready.
-    // No-op when we're a follower (broker_remote needs the local Broker
-    // instance the leader hosts). Best-effort; failures log but don't break
-    // single-PC operation.
-    void _ensureBrokerRemote().catch((err) => {
-        console.error(`[remote-pi] _ensureBrokerRemote failed: ${String(err)}`);
-    });
+    // No-op when we're a follower (the bridge needs the local Broker instance
+    // the leader hosts). Best-effort; failures don't surface.
+    _attachBridgeIfReady();
     ctx.ui.notify(`[remote-pi] state: started (peer=${myShort}) — Connected to relay ${relayUrl}`, "info");
 }
 /**
@@ -1315,7 +1478,7 @@ async function _cmdPair(ctx) {
             return;
         }
         ctx.ui.notify("[remote-pi] Starting mesh + relay before pairing…", "info");
-        if (!_sessionPeer)
+        if (!_meshNode)
             await _cmdJoin(ctx);
         if (_state === "idle")
             await _cmdStart(ctx);
@@ -1362,7 +1525,7 @@ async function _cmdPair(ctx) {
  * `/remote-pi` again.
  */
 async function _cmdStop(ctx) {
-    const meshUp = _sessionPeer !== null;
+    const meshUp = _meshNode !== null;
     const relayUp = _state !== "idle";
     if (!meshUp && !relayUp) {
         ctx.ui.notify("[remote-pi] Already stopped — nothing to do.", "info");
@@ -1370,10 +1533,10 @@ async function _cmdStop(ctx) {
     }
     if (meshUp) {
         try {
-            await _sessionPeer.leave();
+            await _meshNode.close();
         }
         catch { /* best-effort */ }
-        _sessionPeer = null;
+        _meshNode = null;
         _sessionName = null;
         _sessionPeerCount = 0;
     }
@@ -1474,7 +1637,7 @@ function _cmdSetRelay(arg, ctx) {
  *     on an existing daemon is idempotent at this layer; the registry
  *     itself rejects duplicate cwds.
  */
-function _cmdCreate(arg, ctx) {
+async function _cmdCreate(arg, ctx) {
     // Parse `[cwd] [--name "value with spaces" | --name word]` in any order.
     // The first non-flag token is the cwd; the rest of the line after
     // `--name` (quoted or unquoted) is the display name.
@@ -1506,6 +1669,23 @@ function _cmdCreate(arg, ctx) {
     }
     const finalName = loadLocalConfig(result.cwd).agent_name ?? defaultAgentName(result.cwd);
     ctx.ui.notify(`[remote-pi] Daemon registered: id=${result.id} name="${finalName}" cwd=${result.cwd}`, "info");
+    // Auto-start: register alone used to leave the daemon idle until the next
+    // supervisor restart (the reported bug — `create` didn't run anything). Ask
+    // the supervisor to spawn THIS daemon now. Config was just written above, so
+    // the child boots with it. When the supervisor is offline we keep the
+    // registration and tell the user it'll boot on the next supervisor start.
+    try {
+        await callSupervisor({ op: "start", id: result.id });
+        ctx.ui.notify(`[remote-pi] Daemon started: id=${result.id}`, "info");
+    }
+    catch (err) {
+        if (err instanceof SupervisorOfflineError) {
+            ctx.ui.notify(`[remote-pi] Registered, but the supervisor is offline — not running yet. ` +
+                `Run \`remote-pi install\` (or start \`pi-supervisord\`); it auto-starts on the next supervisor boot.`, "warning");
+            return;
+        }
+        ctx.ui.notify(`[remote-pi] Registered, but auto-start failed: ${String(err)}`, "error");
+    }
 }
 /**
  * `/remote-pi remove <id>`
@@ -1515,12 +1695,35 @@ function _cmdCreate(arg, ctx) {
  * stays on disk — re-creating later with the same cwd is a no-op
  * because the existing config wins.
  */
-function _cmdRemove(arg, ctx) {
+async function _cmdRemove(arg, ctx) {
     const id = arg.trim();
     if (!id) {
         ctx.ui.notify("[remote-pi] Usage: /remote-pi remove <id>. Run /remote-pi daemons to see ids.", "warning");
         return;
     }
+    // Prefer the supervisor's `unregister`: it STOPS the running child (SIGTERM →
+    // SIGKILL) BEFORE deleting the registry entry. Removing only the registry
+    // (the old behaviour) left an orphaned `pi --mode rpc` process running with
+    // nothing left to manage it — the reported bug. Fall back to a registry-only
+    // removal when the supervisor is offline (no managed process to stop anyway).
+    try {
+        const data = await callSupervisor({ op: "unregister", id });
+        if (!data.removed) {
+            const known = listDaemons().map((d) => d.id).join(", ") || "(none)";
+            ctx.ui.notify(`[remote-pi] No daemon with id "${id}". Known ids: ${known}`, "warning");
+            return;
+        }
+        ctx.ui.notify(`[remote-pi] Daemon removed + process stopped: id=${id} cwd=${data.cwd}. ` +
+            `Local config at ${data.cwd}/.pi/remote-pi/config.json was kept.`, "info");
+        return;
+    }
+    catch (err) {
+        if (!(err instanceof SupervisorOfflineError)) {
+            ctx.ui.notify(`[remote-pi] remove failed: ${String(err)}`, "error");
+            return;
+        }
+        // Supervisor offline — fall through to registry-only removal below.
+    }
     let result;
     try {
         result = removeDaemon(id);
@@ -1530,13 +1733,12 @@ function _cmdRemove(arg, ctx) {
         return;
     }
     if (!result.removed) {
-        // Surface the registered ids for a quick visual diff.
         const known = listDaemons().map((d) => d.id).join(", ") || "(none)";
         ctx.ui.notify(`[remote-pi] No daemon with id "${id}". Known ids: ${known}`, "warning");
         return;
     }
-    ctx.ui.notify(`[remote-pi] Daemon removed: id=${id} cwd=${result.cwd}. ` +
-        `Local config at ${result.cwd}/.pi/remote-pi/config.json was kept.`, "info");
+    ctx.ui.notify(`[remote-pi] Daemon removed from registry: id=${id} cwd=${result.cwd}. ` +
+        `Supervisor was offline, so any running process was NOT stopped. Local config kept.`, "warning");
 }
 // ── Fleet-ops commands (plan/26 W2) — talk to the supervisor over UDS ─────────
 //
@@ -1790,6 +1992,84 @@ function _deployAgentNetworkSkill() {
     }
     catch { /* best-effort */ }
 }
+/**
+ * Inject text into the agent as a user message, waking a turn. The Pi SDK's
+ * `ExtensionAPI.sendUserMessage` is fire-and-forget (returns `void`) and
+ * "always triggers a turn" — the SDK runtime owns any *async* turn failure
+ * (no model/API key, expired auth, provider error), which surfaces in the
+ * agent's own output, not back to us. Two gaps this helper closes, both of
+ * which previously failed silently:
+ *
+ *   1. `_pi` not bound yet (activation race / mesh joined before the session
+ *      attached): the old code did `if (!_pi) return`, dropping the message
+ *      with no trace. We log it (the daemon forwards child stderr to its log
+ *      with a cwd prefix, so it's visible in `journalctl`).
+ *   2. A *synchronous* throw from `sendUserMessage` (e.g. malformed content):
+ *      the old fire-and-forget call let it propagate out of the `onMessage`
+ *      callback, which could wedge the read loop and blackout every later
+ *      message. We catch + surface it instead.
+ *
+ * NOTE: this does NOT make a wake that fails *inside* the SDK observable —
+ * that requires a fix in the Pi runtime (no extension-level error event
+ * exists for it). See `.orchestration/results/mesh-liveness-stale-peer.md`.
+ */
+function _wakeAgent(content, label) {
+    if (!_pi) {
+        console.error(`[remote-pi] ${label}: agent session not bound yet — message dropped`);
+        return;
+    }
+    try {
+        _pi.sendUserMessage(content);
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        console.error(`[remote-pi] ${label}: agent rejected incoming message: ${detail}`);
+        _lastCtx?.ui.notify(`[remote-pi] failed to process incoming message: ${detail}`, "error");
+    }
+}
+/**
+ * Deliver an inbound agent-network (mesh) message to the agent + the app.
+ *
+ * Display: the app renders it in the TOOL timeline (a matched
+ * tool_request/tool_result "agent-network" pair) — NOT as the user's own
+ * message, which is what `sendUserMessage` used to produce (the reported bug).
+ *
+ * Wake: we inject a CUSTOM message (role:"custom"), not a user message. The
+ * SDK's `convertToLlm` maps custom → a user-role LLM message, so the agent
+ * still sees + replies to it, but `message_end` does NOT buffer role:"custom",
+ * so it never replays as `user_input` on session_sync. `triggerTurn` runs the
+ * turn; `id` lets the LLM echo it via `agent_send(..., re=<id>)`.
+ */
+function _deliverMeshMessageToAgent(env) {
+    const bodyText = typeof env.body === "string" ? env.body : JSON.stringify(env.body);
+    const toolCallId = `mesh_${env.id}`;
+    _broadcastToActive({
+        type: "tool_request",
+        tool_call_id: toolCallId,
+        tool: "agent-network",
+        args: env.re
+            ? { from: env.from, re: env.re, message: bodyText }
+            : { from: env.from, message: bodyText },
+    });
+    _broadcastToActive({ type: "tool_result", tool_call_id: toolCallId, result: { from: env.from, message: bodyText } });
+    const label = `agent-network message from "${env.from}"`;
+    if (!_pi) {
+        console.error(`[remote-pi] ${label}: agent session not bound yet — message dropped`);
+        return;
+    }
+    const header = `[agent-network] message from "${env.from}" (id=${env.id}${env.re ? `, re=${env.re}` : ""}):`;
+    const footer = env.re
+        ? "(This is a reply to a previous message of yours.)"
+        : `(If a reply is expected, call agent_send with to="${env.from}" and re="${env.id}".)`;
+    try {
+        _pi.sendMessage({ customType: "remote-pi:mesh-message", content: `${header}\n${bodyText}\n\n${footer}`, display: true }, { triggerTurn: true });
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        console.error(`[remote-pi] ${label}: agent rejected incoming message: ${detail}`);
+        _lastCtx?.ui.notify(`[remote-pi] failed to process incoming message: ${detail}`, "error");
+    }
+}
 /**
  * Joins the fixed local UDS mesh ("local" session — see LOCAL_SESSION_NAME).
  * Called by `_cmdRoot` on first run and on subsequent runs when the relay
@@ -1802,7 +2082,7 @@ async function _cmdJoin(ctx) {
     const local = loadLocalConfig(cwd);
     const sessionName = LOCAL_SESSION_NAME;
     const agentName = local.agent_name || defaultAgentName(cwd);
-    if (_sessionPeer) {
+    if (_meshNode) {
         ctx.ui.notify("[remote-pi] Already on the local mesh.", "warning");
         return;
     }
@@ -1810,7 +2090,7 @@ async function _cmdJoin(ctx) {
     mkdirSync(join(skillsDir(), "..", "sessions", sessionName), { recursive: true });
     const sock = sessionSockPath(sessionName);
     const audit = sessionAuditPath(sessionName);
-    const peer = new SessionPeer({ sockPath: sock, name: agentName, auditPath: audit });
+    const peer = new MeshNode({ sockPath: sock, name: agentName, auditPath: audit });
     peer.onMessage((env) => {
         const body = env.body;
         // Broker system events: re-query broker for authoritative count.
@@ -1823,11 +2103,12 @@ async function _cmdJoin(ctx) {
             void peer.request("broker", { type: "list_peers" }, 2000)
                 .then((reply) => {
                 const peers = reply.body?.peers;
-                if (Array.isArray(peers) && _brokerRemote) {
+                if (Array.isArray(peers)) {
                     // Strip remote-prefixed entries — onLocalPeersChanged wants
-                    // local-only names (`list_peers` returns aggregated).
+                    // local-only names (`list_peers` returns aggregated). No-op when
+                    // the bridge isn't up (follower / relay down).
                     const local = peers.filter((p) => !p.includes(":"));
-                    _brokerRemote.onLocalPeersChanged(local);
+                    peer.onLocalPeersChanged(local);
                 }
             })
                 .catch(() => { });
@@ -1835,47 +2116,24 @@ async function _cmdJoin(ctx) {
         }
         if (env.from === "broker")
             return; // other broker control messages — ignore
-        // Anything else is a real agent-to-agent message. SessionPeer already
-        // correlated replies (env.re matched a pending request) before reaching
-        // here — what arrives now is unsolicited and needs the LLM to react.
-        // Inject as a user message so the model sees it as a turn input. Include
-        // the `id` so the LLM can echo it via `agent_send(..., re=<id>)` when
-        // replying (otherwise the sender's agent_request times out).
-        if (!_pi)
-            return;
-        const bodyText = typeof env.body === "string" ? env.body : JSON.stringify(env.body);
-        const header = `[agent-network] message from "${env.from}" (id=${env.id}${env.re ? `, re=${env.re}` : ""}):`;
-        const footer = env.re
-            ? "(This is a reply to a previous message of yours.)"
-            : `(If a reply is expected, call agent_send with to="${env.from}" and re="${env.id}".)`;
-        _pi.sendUserMessage(`${header}\n${bodyText}\n\n${footer}`);
+        // Real agent-to-agent message (SessionPeer already correlated replies via
+        // env.re before this point). Show it in the app's TOOL timeline and wake
+        // the agent as a CUSTOM message — never as the user's own message.
+        _deliverMeshMessageToAgent(env);
     });
     // After failover (leader died, we re-elected): the new broker's peers map
     // starts fresh, but our cached `_sessionPeerCount` is stale. Re-seed it so
     // surviving peers don't carry the pre-failover count forever.
     //
-    // Plan/25 Wave D: when this peer was promoted to leader by the failover,
-    // it now hosts a fresh `Broker` instance with no `RemoteRouter` attached.
-    // The previous broker_remote (on the dead leader) is gone with that
-    // process. Recreate ours here. Followers stay no-op (broker_remote only
-    // runs on the leader). Idempotent — _ensureBrokerRemote short-circuits
-    // when one is already wired.
+    // The cross-PC bridge re-attach on failover (drop the stale broker ref,
+    // re-wire against the fresh `localBroker()` if we were promoted to leader)
+    // is handled INSIDE MeshNode — no manual teardown/ensure needed here.
     peer.onReconnect(() => {
         _refreshSessionPeerCount(peer, ctx);
-        if (peer.currentRole() === "leader") {
-            // Tear down any previous instance first — its broker reference is now
-            // stale (it pointed at the broker we hosted before the prior
-            // disconnect). The new broker comes from `peer.localBroker()` after
-            // reconnect.
-            _teardownBrokerRemote();
-            void _ensureBrokerRemote().catch((err) => {
-                console.error(`[remote-pi] _ensureBrokerRemote (post-failover) failed: ${String(err)}`);
-            });
-        }
     });
     try {
-        const assigned = await peer.start();
-        _sessionPeer = peer;
+        const assigned = await peer.connect();
+        _meshNode = peer;
         _sessionName = sessionName;
         _sessionPeerCount = 1; // optimistic — overwritten by list_peers below
         // Broker broadcasts `peer_joined` only to existing peers when a new one
@@ -1888,9 +2146,7 @@ async function _cmdJoin(ctx) {
         // Plan/25 Wave B/C: try to bring up cross-PC routing now that the
         // local broker exists. No-op if the relay isn't up yet (will fire
         // again from `_cmdStart`).
-        void _ensureBrokerRemote().catch((err) => {
-            console.error(`[remote-pi] _ensureBrokerRemote (post-join) failed: ${String(err)}`);
-        });
+        _attachBridgeIfReady();
     }
     catch (err) {
         ctx.ui.notify(`[remote-pi] join failed: ${String(err)}`, "error");
@@ -1919,12 +2175,6 @@ export function _routeClientMessageFrom(sender, msg, ctx) {
         return;
     switch (msg.type) {
         case "user_message": {
-            // Reverse-lookup of the sender's appPeerId from `_activePeers` (the
-            // PlainPeerChannel's `remotePeerId` is private). Purely diagnostic.
-            const senderId = [..._activePeers.entries()].find(([, ch]) => ch === sender)?.[0] ?? "unknown";
-            console.error(`[remote-pi] user_message from ${senderId.slice(0, 8)} ` +
-                `id=${msg.id} text=${JSON.stringify(msg.text).slice(0, 60)} ` +
-                `activePeers=[${[..._activePeers.keys()].map((k) => k.slice(0, 8)).join(", ")}]`);
             // Source-of-truth rebroadcast (plan/24 W2D fix). Echo the message
             // back to every attached owner (sender included) BEFORE handing it
             // off to the agent — so that:
@@ -1936,9 +2186,26 @@ export function _routeClientMessageFrom(sender, msg, ctx) {
             // The user_message is also recorded in _messageBuffer indirectly
             // via `pi.on("message_end")` after the SDK persists the turn — so
             // a later `session_sync` returns it in the history events.
-            _broadcastToActive({ type: "user_message", id: msg.id, text: msg.text });
+            // Plan/30: echo any inline images too so every owner renders the same
+            // image bubble. No-image path is byte-identical to before (no `images`
+            // key on the wire).
+            const echo = msg.images && msg.images.length > 0
+                ? { type: "user_message", id: msg.id, text: msg.text, images: msg.images }
+                : { type: "user_message", id: msg.id, text: msg.text };
+            _broadcastToActive(echo);
             _currentTurnId = msg.id;
-            _pi.sendUserMessage(msg.text);
+            if (msg.images && msg.images.length > 0) {
+                // Plan/30 multimodal: image(s) first, then the caption text — the shape
+                // the SDK's sendUserMessage(content[]) hands straight to the model.
+                const content = [
+                    ...msg.images.map((img) => ({ type: "image", data: img.data, mimeType: img.mime })),
+                    { type: "text", text: msg.text },
+                ];
+                _wakeAgent(content, `app user_message id=${msg.id} (+${msg.images.length} image)`);
+            }
+            else {
+                _wakeAgent(msg.text, `app user_message id=${msg.id}`);
+            }
             break;
         }
         case "approve_tool":
@@ -1959,6 +2226,48 @@ export function _routeClientMessageFrom(sender, msg, ctx) {
             // Already paired — ignore subsequent pair_request to maintain idempotency.
             // (Token is already consumed and peer is in peers.json.)
             break;
+        // Plan/28 — Typed app actions. Each delegates to the pure handler in
+        // `actions/handlers.ts`; the only thing this layer does is unify the
+        // dep injection (sender, _pi, _lastCtx, registry). `_lastCtx` may be
+        // null or a narrower Pick than the handlers want, so we cast to
+        // `ActionCtx` — fields that aren't present at runtime are surfaced
+        // as `action_error` by the handlers, not as a TypeError.
+        case "session_compact":
+            // Route through _lastEventCtx (refreshed on every session_start), NOT the
+            // capturable-stale _lastCtx — compact must never hit a ctx left stale by
+            // a prior New session. compact() is a base-ctx method, so the
+            // session_start ctx suffices. Fall back to _lastCtx defensively if no
+            // session_start has landed yet (keeps the pre-replacement happy path).
+            handleSessionCompact((_lastEventCtx ?? _lastCtx), sender, msg);
+            break;
+        case "session_new":
+            void handleSessionNew(_lastCtx, sender, msg, (freshCtx) => {
+                // newSession just made the captured _lastCtx STALE (the SDK throws
+                // if it's reused). Re-capture the fresh command-capable ctx the SDK
+                // passes to withSession so later command ops (another New session,
+                // list_models) run on the current session, not the stale one. The
+                // runtime object also carries ui/abort/cwd, so storing it in the
+                // narrowly-typed _lastCtx slot is sound (mirrors the read-site casts).
+                _lastCtx = freshCtx;
+            }).then((created) => {
+                // Pi-side reset is durable only here: handleSessionNew swaps the SDK
+                // session, but the app's session_sync log (_messageBuffer) and the
+                // session clock (_sessionStartedAt) live in this module. Reset them +
+                // fan out an empty history so every owner drops the stale conversation
+                // — not just the sender, who also clears locally on action_ok.
+                if (created)
+                    _resetSessionForNew(msg.id);
+            });
+            break;
+        case "model_set":
+            void handleModelSet(_pi, ensureModelRegistry(), sender, msg, _persistModelDefault);
+            break;
+        case "thinking_set":
+            handleThinkingSet(_pi, sender, msg);
+            break;
+        case "list_models":
+            handleListModels(_lastCtx, ensureModelRegistry(), sender, msg);
+            break;
     }
 }
 /**
@@ -2008,6 +2317,33 @@ function _handleSessionSync(sender, msg) {
         truncated,
     });
 }
+/**
+ * Resets the Pi-side session view after a SUCCESSFUL `session_new`. The app's
+ * New Session clears its local store on `action_ok`, but that alone isn't
+ * durable: `_messageBuffer` (which answers `session_sync`) is append-only and
+ * `_sessionStartedAt` is stamped once, so a later reconnect/restart would
+ * replay the OLD history. We clear the buffer, restamp the clock, and
+ * broadcast an EMPTY `session_history` — the exact shape `_handleSessionSync`
+ * sends, just with `events: []` — so every attached owner drops the stale
+ * conversation. The app's `_applyHistory` substitutes its cache wholesale, so
+ * no new app-side code is needed.
+ *
+ * Unlike a per-request session_history reply (which must go to the sender
+ * channel only — see `_broadcastToActive`), this is an intentional fan-out:
+ * a new session is global state, so every owner must see the reset.
+ */
+function _resetSessionForNew(inReplyTo) {
+    _messageBuffer = [];
+    _sessionStartedAt = Date.now();
+    _broadcastToActive({
+        type: "session_history",
+        in_reply_to: inReplyTo,
+        session_started_at: _sessionStartedAt,
+        events: [],
+        eos: true,
+        truncated: false,
+    });
+}
 function _stringifyContent(content) {
     if (typeof content === "string")
         return content;
@@ -2022,6 +2358,59 @@ function _stringifyContent(content) {
     })
         .join("");
 }
+/**
+ * Stringify a tool result consistently for BOTH the live `tool_execution_end`
+ * broadcast AND the history mapper, so the app shows the same text live and on
+ * re-sync. The SDK's `ToolExecutionEndEvent.result` is `any` — usually a
+ * content-array of `{type:"text"}` blocks; `String()` on that yields the
+ * "[object Object]" bug. Rules: string → as-is; content-array → join its text
+ * (same as `_stringifyContent`); any other object → readable JSON; other
+ * primitives → `String()`; null/undefined → "". Never "[object Object]".
+ */
+function _stringifyToolResult(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return _stringifyContent(value);
+    if (value !== null && typeof value === "object") {
+        // The LIVE `tool_execution_end` result is a WRAPPER object
+        // `{ content: [{type:"text",...}], details:{} }` — not the bare
+        // content-array the history path (`m.content`) carries. Unwrap `content`
+        // (or a plain `text`) so live == re-sync; JSON is only the last fallback.
+        const obj = value;
+        if (Array.isArray(obj.content))
+            return _stringifyContent(obj.content);
+        if (typeof obj.text === "string")
+            return obj.text;
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return "";
+        }
+    }
+    return value === null || value === undefined ? "" : String(value);
+}
+/**
+ * Plan/30: extract `ImageContent` blocks ({type:"image", data, mimeType}) from
+ * an SDK message's content and map them to the wire shape (`mimeType` → `mime`).
+ * Used by the history mapper so a re-synced image bubble keeps its bytes —
+ * `_stringifyContent` only pulls text and would otherwise drop the image.
+ */
+function _imagesFromContent(content) {
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    for (const c of content) {
+        if (!c || typeof c !== "object")
+            continue;
+        const block = c;
+        if (block.type === "image" && typeof block.data === "string" && typeof block.mimeType === "string") {
+            out.push({ data: block.data, mime: block.mimeType });
+        }
+    }
+    return out;
+}
 /**
  * Maps SDK AgentMessage[] (UserMessage / AssistantMessage / ToolResultMessage)
  * into the flat SessionHistoryEvent[] shape consumed by the app.
@@ -2036,15 +2425,31 @@ export function _mapAgentMessagesToEvents(messages) {
     let lastUserId = null;
     for (const m of messages) {
         const ts = typeof m.timestamp === "number" ? m.timestamp : 0;
-        if (m.role === "user") {
+        if (m.role === "compaction") {
+            // Plan/32: re-render the compaction notice on history re-sync.
+            events.push({
+                ts,
+                type: "compaction",
+                summary: typeof m.content === "string" ? m.content : "",
+                tokens_before: typeof m.tokensBefore === "number" ? m.tokensBefore : 0,
+            });
+        }
+        else if (m.role === "user") {
             const id = `sync_${ts}`;
             lastUserId = id;
-            events.push({
+            // Plan/30: keep any image blocks so a re-sync rebuilds the bubble. The
+            // bytes are already in _messageBuffer; only attach `images` when present
+            // so the text-only path stays byte-identical (no `images` key).
+            const images = _imagesFromContent(m.content);
+            const ev = {
                 ts,
                 type: "user_input",
                 id,
                 text: _stringifyContent(m.content),
-            });
+            };
+            if (images.length > 0)
+                ev.images = images;
+            events.push(ev);
         }
         else if (m.role === "assistant") {
             const content = Array.isArray(m.content) ? m.content : [];
@@ -2080,7 +2485,8 @@ export function _mapAgentMessagesToEvents(messages) {
             }
         }
         else if (m.role === "toolResult") {
-            const text = _stringifyContent(m.content);
+            // Same helper as the live `tool_execution_end` broadcast → live == re-sync.
+            const text = _stringifyToolResult(m.content);
             const tcid = String(m.toolCallId ?? "");
             events.push(m.isError
                 ? { ts, type: "tool_result", tool_call_id: tcid, error: text }
@@ -2090,7 +2496,15 @@ export function _mapAgentMessagesToEvents(messages) {
     return events;
 }
 // ── Standalone CLI ────────────────────────────────────────────────────────────
-if (import.meta.url === `file://${process.argv[1]}`) {
+function _isDirectRun() {
+    try {
+        return fileURLToPath(import.meta.url) === realpathSync(process.argv[1] ?? "");
+    }
+    catch {
+        return false;
+    }
+}
+if (_isDirectRun()) {
     const [, , subcmd, ...cliArgs] = process.argv;
     if (subcmd === "devices" || subcmd === "list") {
         const peers = await listPeers();
@@ -2146,13 +2560,13 @@ if (import.meta.url === `file://${process.argv[1]}`) {
         // parser (shared with the slash-command path) sees the same shape
         // as it would from a Pi interactive prompt.
         const joined = cliArgs.map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(" ");
-        _cmdCreate(joined, {
+        await _cmdCreate(joined, {
             ui: { notify: (msg) => console.log(msg) },
         });
     }
     else if (subcmd === "remove") {
         const id = (cliArgs[0] ?? "").trim();
-        _cmdRemove(id, {
+        await _cmdRemove(id, {
             ui: { notify: (msg) => console.log(msg) },
         });
     }
@@ -2187,6 +2601,9 @@ if (import.meta.url === `file://${process.argv[1]}`) {
             console.log("Usage: remote-pi daemon <start|stop|restart|status|send <id> \"<text>\">");
         }
     }
+    else if (subcmd === "claude") {
+        await _cmdClaudeCli(cliArgs);
+    }
     else if (subcmd === "install") {
         // CLI mode = user installed via `npm install -g remote-pi`, so the
         // `remote-pi` / `pi-supervisord` bins are already on $PATH via npm's
@@ -2200,14 +2617,141 @@ if (import.meta.url === `file://${process.argv[1]}`) {
         _cmdUninstall(stubCtx, { linkCli: false });
     }
     else {
-        const edKp = await getOrCreateEd25519Keypair();
-        const sessionName = process.cwd().split("/").slice(-2).join("/");
-        const { url: relayUrl, source } = resolveRelayUrl();
-        const roomId = roomIdForCwd(process.cwd());
-        console.log(`[remote-pi] relay: ${relayUrl} (source: ${source}), room: ${roomId}`);
-        void cliArgs;
-        const stop = startQRRotation(edKp.publicKey, sessionName, roomId);
-        process.once("SIGINT", () => { stop(); process.exit(0); });
+        console.log([
+            "Usage: remote-pi <command>",
+            "",
+            "Daemon registry:",
+            "  create <cwd> [--name \"Name\"]   Register a folder as a daemon",
+            "  remove <id>                     Unregister a daemon",
+            "  daemons                         List registered daemons",
+            "",
+            "Fleet control:",
+            "  daemon start                    Start all registered daemons",
+            "  daemon stop                     Stop all running daemons",
+            "  daemon restart                  Restart all daemons",
+            "  daemon status                   Show pid / uptime / restarts",
+            "  daemon send <id> \"<text>\"       Send a prompt to a daemon",
+            "",
+            "Service:",
+            "  install                         Install pi-supervisord as a system service",
+            "  uninstall                       Remove the system service",
+            "",
+            "Devices:",
+            "  devices                         List paired devices",
+            "  revoke <shortid>                Revoke a paired device",
+            "",
+            "Config:",
+            "  set-relay <url>                 Set the relay URL (http:// or https://)",
+            "",
+            "Agent mesh:",
+            "  claude [cwd]                    Start Claude Code connected to the agent mesh",
+        ].join("\n"));
+    }
+}
+// ── `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.
+ */
+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 */
+    }
+}
+async function _cmdClaudeCli(args) {
+    // Determine target cwd — first non-flag arg, or process.cwd()
+    const targetCwd = args.find((a) => !a.startsWith("--")) ?? process.cwd();
+    // Wizard when no local config exists
+    if (!localConfigExists(targetCwd)) {
+        const suggested = defaultAgentName(targetCwd);
+        process.stdout.write(`\n[remote-pi] No config found for ${targetCwd}\n`);
+        process.stdout.write("Let's set up this agent.\n\n");
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const agentName = await new Promise((res) => rl.question(`Agent name [${suggested}]: `, (ans) => { rl.close(); res(ans.trim() || suggested); }));
+        saveLocalConfig(targetCwd, { agent_name: agentName, auto_start_relay: true });
+        process.stdout.write(`[remote-pi] Config saved: agent="${agentName}"\n\n`);
+    }
+    // Resolve mesh server script path (dist/mcp/mesh_server.js)
+    const here = fileURLToPath(import.meta.url);
+    const distRoot = dirname(here);
+    const meshServerPath = resolve(distRoot, "mcp/mesh_server.js");
+    if (!existsSync(meshServerPath)) {
+        console.log(`[remote-pi] mesh server not found at ${meshServerPath}. Run pnpm build first.`);
+        process.exit(1);
+    }
+    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`
+    // on the command line is loaded for tool calls but is NOT in any of those
+    // 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.
+    //
+    // remove-then-add makes it idempotent and refreshes the path if the
+    // extension moved (Pi can reinstall to a new hash dir on upgrade).
+    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,
+    ], { 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`);
+    // Launch flags:
+    //   --dangerously-load-development-channels TAG  — enable claude/channel push
+    //       for our local (non-allowlisted) server, so incoming mesh messages
+    //       wake Claude instead of waiting for a get_messages poll. Entries must
+    //       be tagged: `server:<name>` for a manually configured MCP server
+    //       (`plugin:<name>@<marketplace>` is the plugin form). Shows a one-time
+    //       confirmation dialog at startup.
+    //   --dangerously-skip-permissions               — auto-approve tool calls
+    spawnSync("claude", [
+        "--dangerously-load-development-channels", `server:${SERVER_NAME}`,
+        "--dangerously-skip-permissions",
+    ], {
+        cwd: absCwd,
+        stdio: "inherit",
+        shell: false,
+    });
 }
 //# sourceMappingURL=index.js.map