clawmatrix 0.2.11 → 0.4.0

package/src/index.ts

@@ -17,7 +17,7 @@ import { createClusterAcpTool } from "./tools/cluster-acp.ts";
 import { createClusterTerminalTool } from "./tools/cluster-terminal.ts";
 import { createClusterToolInvokeTool } from "./tools/cluster-tool.ts";
 import { createClusterTransferTool } from "./tools/cluster-transfer.ts";
-import { registerClusterCli } from "./cli.ts";
+import { createClusterNotifyTool } from "./tools/cluster-notify.ts";
 import { spawnProcess } from "./compat.ts";
 
 /**
@@ -272,7 +272,7 @@ const plugin = {
 
     const repatchTimer = setInterval(patchAllConfigs, 10_000);
     repatchTimer.unref?.();
-    api.on("dispose", () => clearInterval(repatchTimer));
+    api.on("gateway_stop", () => clearInterval(repatchTimer));
 
     for (const [nodeId, models] of Object.entries(modelsByNode)) {
       api.registerProvider({
@@ -304,6 +304,7 @@ const plugin = {
     api.registerTool(createClusterTerminalTool(), { optional: true });
     api.registerTool(createClusterToolInvokeTool(), { optional: true });
     api.registerTool(createClusterTransferTool(), { optional: true });
+    api.registerTool(createClusterNotifyTool(), { optional: true });
 
     // Wire up peer approval with OpenClaw channel API
     if (config.peerApproval.enabled) {
@@ -555,13 +556,632 @@ const plugin = {
       },
     );
 
+    // ── Tool proxy CLI gateway methods ──────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.tools.list",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { node } = (params ?? {}) as { node?: string };
+          const allPeers = runtime.peerManager.router.getAllPeers();
+          const peers = mergeSentinelPeers(allPeers, runtime)
+            .filter((p) => (p as { nodeId: string }).nodeId !== config.nodeId);
+
+          type PeerToolInfo = { nodeId: string; status: string; toolProxy?: import("./types.ts").ToolProxyInfo };
+          const result: PeerToolInfo[] = [];
+
+          for (const peer of peers) {
+            const p = peer as { nodeId: string; connected: boolean; status: string; toolProxy?: import("./types.ts").ToolProxyInfo };
+            if (node && p.nodeId !== node) continue;
+            if (!p.toolProxy?.enabled) continue;
+            result.push({
+              nodeId: p.nodeId,
+              status: p.status,
+              toolProxy: p.toolProxy,
+            });
+          }
+
+          respond(true, result);
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.tools.call",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { node, tool, params: toolParams, timeout } = (params ?? {}) as {
+            node?: string; tool?: string; params?: Record<string, unknown>; timeout?: number;
+          };
+
+          if (!node || !tool) {
+            respond(false, { error: "Missing required params: node, tool" });
+            return;
+          }
+
+          const result = await runtime.toolProxy.invoke(node, tool, toolParams ?? {}, timeout);
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.tools.batch",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { node, items, stopOnError, timeout } = (params ?? {}) as {
+            node?: string;
+            items?: Array<{ tool: string; params?: Record<string, unknown> }>;
+            stopOnError?: boolean;
+            timeout?: number;
+          };
+
+          if (!node || !items || items.length === 0) {
+            respond(false, { error: "Missing required params: node, items" });
+            return;
+          }
+
+          const batchItems = items.map((item) => ({
+            tool: item.tool,
+            params: item.params ?? {},
+          }));
+
+          const results = await runtime.toolProxy.invokeBatch(node, batchItems, { stopOnError, timeout });
+          respond(true, results);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    // ── Models CLI gateway method ──────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.models.list",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { node } = (params ?? {}) as { node?: string };
+          const allProxyModels = runtime.modelProxy.allProxyModels;
+
+          const reachable = new Set(
+            runtime.peerManager.router.getAllPeers()
+              .filter((p) => p.connection?.isOpen || p.reachableVia)
+              .map((p) => p.nodeId),
+          );
+
+          const models = allProxyModels
+            .filter((m) => !node || m.nodeId === node)
+            .map((m) => ({
+              id: m.id,
+              nodeId: m.nodeId,
+              provider: m.provider ?? m.nodeId,
+              ...(m.description && { description: m.description }),
+              ...(m.contextWindow && { contextWindow: m.contextWindow }),
+              ...(m.maxTokens && { maxTokens: m.maxTokens }),
+              ...(m.reasoning !== undefined && { reasoning: m.reasoning }),
+              ...(m.input && { input: m.input }),
+              ...(m.api && { api: m.api }),
+              ...(m.cost && { cost: m.cost }),
+              reachable: reachable.has(m.nodeId),
+            }));
+
+          respond(true, models);
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    // ── Events CLI gateway methods ──────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.events.query",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.webHandler) {
+            respond(false, { error: "Events not enabled (web.enabled = false)" });
+            return;
+          }
+          const { type, source, since, unconsumed, limit } = (params ?? {}) as {
+            type?: string; source?: string; since?: number; unconsumed?: boolean; limit?: number;
+          };
+          const events = runtime.webHandler.queryEvents({
+            type,
+            source,
+            since,
+            unconsumed: unconsumed ?? true,
+            limit: limit ?? 20,
+          });
+          respond(true, events);
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.events.consume",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.webHandler) {
+            respond(false, { error: "Events not enabled (web.enabled = false)" });
+            return;
+          }
+          const { ids } = (params ?? {}) as { ids?: string[] };
+          if (!ids || ids.length === 0) {
+            respond(false, { error: "Missing required param: ids (array of event IDs)" });
+            return;
+          }
+          const consumed = runtime.webHandler.consumeEvents(ids);
+          respond(true, { consumed, ids });
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    // ── Send / Handoff gateway methods ──────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.send",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { node, message } = (params ?? {}) as { node?: string; message?: string };
+          if (!node || !message) {
+            respond(false, { error: "Missing required params: node, message" });
+            return;
+          }
+          const route = runtime.peerManager.router.resolveAgent(node);
+          if (!route) {
+            respond(false, { error: `No reachable agent for target "${node}"` });
+            return;
+          }
+          const sent = runtime.peerManager.sendTo(route.nodeId, {
+            type: "send",
+            from: runtime.config.nodeId,
+            to: route.nodeId,
+            timestamp: Date.now(),
+            payload: { target: node, message },
+          });
+          respond(true, { sent, nodeId: route.nodeId });
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.handoff",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { target, task, context } = (params ?? {}) as {
+            target?: string; task?: string; context?: string;
+          };
+          if (!target || !task) {
+            respond(false, { error: "Missing required params: target, task" });
+            return;
+          }
+          const result = await runtime.handoffManager.handoff(target, task, context);
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    // ── ACP gateway methods ──────────────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.acp.list",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.acpProxy) {
+            respond(false, { error: "ACP proxy not available" });
+            return;
+          }
+          const { node, agent, cwd } = (params ?? {}) as { node?: string; agent?: string; cwd?: string };
+          if (!node) {
+            respond(false, { error: "Missing required param: node" });
+            return;
+          }
+          const result = await runtime.acpProxy.listSessions(node, { agent, cwd });
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.acp.prompt",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.acpProxy) {
+            respond(false, { error: "ACP proxy not available" });
+            return;
+          }
+          const { node, agent, task, sessionId, mode, cwd } = (params ?? {}) as {
+            node?: string; agent?: string; task?: string; sessionId?: string;
+            mode?: "oneshot" | "persistent"; cwd?: string;
+          };
+          if (!node) {
+            respond(false, { error: "Missing required param: node" });
+            return;
+          }
+          if (!agent && !sessionId) {
+            respond(false, { error: "Missing required param: agent (or sessionId for follow-up)" });
+            return;
+          }
+          const result = await runtime.acpProxy.prompt(node, agent ?? "", task ?? "", { sessionId, mode, cwd });
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.acp.resume",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.acpProxy) {
+            respond(false, { error: "ACP proxy not available" });
+            return;
+          }
+          const { node, agent, acpSessionId, cwd } = (params ?? {}) as {
+            node?: string; agent?: string; acpSessionId?: string; cwd?: string;
+          };
+          if (!node || !agent || !acpSessionId) {
+            respond(false, { error: "Missing required params: node, agent, acpSessionId" });
+            return;
+          }
+          const result = await runtime.acpProxy.resumeSession(node, agent, acpSessionId, cwd ?? process.cwd());
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.acp.cancel",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.acpProxy) {
+            respond(false, { error: "ACP proxy not available" });
+            return;
+          }
+          const { node, sessionId } = (params ?? {}) as { node?: string; sessionId?: string };
+          if (!node || !sessionId) {
+            respond(false, { error: "Missing required params: node, sessionId" });
+            return;
+          }
+          const result = await runtime.acpProxy.cancelSession(node, sessionId);
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.acp.close",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          if (!runtime.acpProxy) {
+            respond(false, { error: "ACP proxy not available" });
+            return;
+          }
+          const { node, sessionId } = (params ?? {}) as { node?: string; sessionId?: string };
+          if (!node || !sessionId) {
+            respond(false, { error: "Missing required params: node, sessionId" });
+            return;
+          }
+          const result = await runtime.acpProxy.closeSession(node, sessionId);
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    // ── Diagnostic gateway method ────────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.diagnostic",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { node, action, command, timeout = 30 } = (params ?? {}) as {
+            node?: string; action?: string; command?: string; timeout?: number;
+          };
+          if (!node || !action) {
+            respond(false, { error: "Missing required params: node, action" });
+            return;
+          }
+          const sentinelNodeId = node.endsWith(":sentinel") ? node : `${node}:sentinel`;
+          const route = runtime.peerManager.router.getRoute(sentinelNodeId);
+          if (!route) {
+            respond(false, { error: `Sentinel "${sentinelNodeId}" is not reachable` });
+            return;
+          }
+          const id = (await import("node:crypto")).randomUUID();
+          const timeoutMs = timeout * 1000;
+
+          const frameType = action === "exec" ? "diagnostic_exec" : "diagnostic_status";
+          const responseType = action === "exec" ? "diagnostic_exec_res" : "diagnostic_status_res";
+          const frame = {
+            type: frameType,
+            id,
+            from: runtime.config.nodeId,
+            to: sentinelNodeId,
+            timestamp: Date.now(),
+            ...(action === "exec" ? { payload: { command, timeout } } : {}),
+          };
+
+          const result = await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+              cleanup();
+              reject(new Error(`Diagnostic timed out after ${timeoutMs}ms`));
+            }, timeoutMs + (action === "exec" ? 5000 : 0));
+
+            const handler = (incoming: any) => {
+              if (incoming.type === responseType && incoming.id === id) {
+                cleanup();
+                resolve(incoming.payload);
+              }
+            };
+
+            const cleanup = () => {
+              clearTimeout(timer);
+              runtime.peerManager.off("frame", handler);
+            };
+
+            runtime.peerManager.on("frame", handler);
+            const sent = runtime.peerManager.router.sendTo(sentinelNodeId, frame as any);
+            if (!sent) {
+              cleanup();
+              reject(new Error(`No route to ${sentinelNodeId}`));
+            }
+          });
+
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    // ── Notify gateway method ────────────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.notify",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { action = "start", taskId: providedTaskId, title, detail, progress, tool, success = true } = (params ?? {}) as {
+            action?: string; taskId?: string; title?: string; detail?: string;
+            progress?: number; tool?: string; success?: boolean;
+          };
+
+          const peers = runtime.peerManager.router.getAllPeers();
+          const mobileTargets = peers.filter((p) =>
+            p.tags.some((t: string) => t === "mobile" || t === "ios" || t === "phone"),
+          );
+
+          if (mobileTargets.length === 0) {
+            respond(false, undefined, { code: "NO_MOBILE_PEERS", message: "No mobile peers connected" });
+            return;
+          }
+
+          const { randomUUID } = require("node:crypto");
+          const taskId = providedTaskId || randomUUID();
+          const now = Date.now();
+
+          let status: string;
+          if (action === "start") status = "started";
+          else if (action === "end") status = success ? "completed" : "failed";
+          else status = "progress";
+
+          const frame = {
+            type: "task_activity",
+            from: runtime.config.nodeId,
+            timestamp: now,
+            payload: {
+              taskId,
+              taskType: "notify",
+              status,
+              agent: title || runtime.config.nodeId,
+              nodeId: runtime.config.nodeId,
+              title: title || runtime.config.nodeId,
+              detail,
+              startedAt: now,
+              elapsedMs: 0,
+              progress,
+              tool,
+            },
+          };
+
+          for (const target of mobileTargets) {
+            runtime.peerManager.sendTo(target.nodeId, { ...frame, to: target.nodeId });
+          }
+
+          respond(true, { taskId, action, targets: mobileTargets.length });
+        } catch {
+          respond(false, undefined, { code: "SERVICE_ERROR", message: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    // ── Terminal gateway methods ──────────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.list",
+      ({ respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          respond(true, runtime.terminalManager.listSessions());
+        } catch {
+          respond(false, { error: "ClawMatrix service not running" });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.open",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { node, shell, cols, rows, cwd } = (params ?? {}) as {
+            node?: string; shell?: string; cols?: number; rows?: number; cwd?: string;
+          };
+          if (!node) {
+            respond(false, { error: "Missing required param: node" });
+            return;
+          }
+          const sessionId = await runtime.terminalManager.open(node, { shell, cols, rows, cwd });
+          await new Promise((r) => setTimeout(r, 500));
+          const initial = runtime.terminalManager.readOutput(sessionId);
+          respond(true, { sessionId, nodeId: node, initialOutput: initial.data });
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.input",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { sessionId, data } = (params ?? {}) as { sessionId?: string; data?: string };
+          if (!sessionId || !data) {
+            respond(false, { error: "Missing required params: sessionId, data" });
+            return;
+          }
+          runtime.terminalManager.sendInput(sessionId, data);
+          respond(true, { sent: true });
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.read",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { sessionId } = (params ?? {}) as { sessionId?: string };
+          if (!sessionId) {
+            respond(false, { error: "Missing required param: sessionId" });
+            return;
+          }
+          const output = runtime.terminalManager.readOutput(sessionId);
+          respond(true, output);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.resize",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { sessionId, cols, rows } = (params ?? {}) as { sessionId?: string; cols?: number; rows?: number };
+          if (!sessionId) {
+            respond(false, { error: "Missing required param: sessionId" });
+            return;
+          }
+          runtime.terminalManager.resize(sessionId, cols ?? 80, rows ?? 24);
+          respond(true, { resized: true });
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    api.registerGatewayMethod(
+      "clawmatrix.terminal.close",
+      ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const { sessionId } = (params ?? {}) as { sessionId?: string };
+          if (!sessionId) {
+            respond(false, { error: "Missing required param: sessionId" });
+            return;
+          }
+          runtime.terminalManager.close(sessionId);
+          respond(true, { closed: true });
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
+    // ── File transfer gateway method ─────────────────────────────────
+
+    api.registerGatewayMethod(
+      "clawmatrix.transfer",
+      async ({ params, respond }: GatewayRequestHandlerOptions) => {
+        try {
+          const runtime = getClusterRuntime();
+          const ftm = runtime.fileTransferManager;
+          if (!ftm) {
+            respond(false, { error: "File transfer not enabled" });
+            return;
+          }
+          const { source_node, source_path, target_node, target_path } = (params ?? {}) as {
+            source_node?: string; source_path?: string; target_node?: string; target_path?: string;
+          };
+          if (!source_path || !target_path) {
+            respond(false, { error: "Missing required params: source_path, target_path" });
+            return;
+          }
+          if ((source_node && target_node) || (!source_node && !target_node)) {
+            respond(false, { error: "Provide exactly one of source_node (pull) or target_node (push)" });
+            return;
+          }
+          let result;
+          if (source_node) {
+            result = await ftm.pullFile(source_node, source_path, target_path);
+          } else {
+            result = await ftm.pushFile(target_node!, source_path, target_path);
+          }
+          respond(true, result);
+        } catch (err) {
+          respond(false, { error: err instanceof Error ? err.message : String(err) });
+        }
+      },
+    );
+
     // Log model selection on each LLM call (fire-and-forget)
     api.on("llm_input", (event) => {
       api.logger.debug(`[clawmatrix] llm_input: provider=${event.provider} model=${event.model}`);
     });
 
-    // CLI subcommand
-    api.registerCli(registerClusterCli, { commands: ["clawmatrix"] });
+    // Auto-install global `clawmatrix` shim next to the `openclaw` binary.
+    // Runs once on plugin load; non-blocking, best-effort.
+    installGlobalCliShim(api.logger);
 
     // Plugin command: /clawmatrix approve|deny|revoke
     // Handles Telegram callback buttons and other chat surfaces.
@@ -646,19 +1266,11 @@ const plugin = {
         // Rebuild system context only when peer count changes
         if (peerCount !== cachedPeerCount) {
           cachedPeerCount = peerCount;
-          const lines: string[] = [];
           if (peerCount === 0) {
-            lines.push("[ClawMatrix] No peers online. Use cluster_peers to check cluster status.");
+            cachedSystemContext = `[ClawMatrix] node="${config.nodeId}" — no peers online.`;
           } else {
-            lines.push(
-              `[ClawMatrix Cluster] YOU ARE node="${config.nodeId}"${config.tags.length ? ` tags=${config.tags.join(",")}` : ""}. This is YOUR identity — never target yourself with cluster tools.`,
-              ...(config.agents.length > 0 ? [`Role: ${config.agents[0]!.description}`] : []),
-              `${peerCount} remote peer(s) online. Use cluster_peers to see topology, agents, and models.`,
-              "Prefer cluster_tool for device-specific tools (screenshot, battery, etc.); cluster_exec/read/write for file/shell ops; cluster_handoff for complex multi-step tasks.",
-              "IMPORTANT: Always tell user which remote node you're targeting before calling cluster tools.",
-            );
+            cachedSystemContext = `[ClawMatrix] node="${config.nodeId}"${config.tags.length ? ` tags=${config.tags.join(",")}` : ""}, ${peerCount} peer(s) online.${config.agents.length > 0 ? ` Role: ${config.agents[0]!.description}` : ""}`;
           }
-          cachedSystemContext = lines.join("\n");
         }
 
         // Per-turn: only push pending events (agent must react proactively)
@@ -753,6 +1365,9 @@ function mergeSentinelPeers(
       status: effectiveStatus,
       reachableVia: p.reachableVia,
       latencyMs: p.latencyMs,
+      toolProxy: p.toolProxy,
+      acpAgents: p.acpAgents,
+      deviceInfo: p.deviceInfo,
       ...(sentinel ? { sentinel: sentinelOnline ? "online" : "offline" } : {}),
     });
   }
@@ -777,4 +1392,61 @@ function mergeSentinelPeers(
   return result;
 }
 
+/** Auto-install a global `clawmatrix` CLI shim next to the `openclaw` binary. */
+function installGlobalCliShim(logger: { info: (msg: string) => void; warn: (msg: string) => void }) {
+  try {
+    const fs = require("node:fs") as typeof import("node:fs");
+    const path = require("node:path") as typeof import("node:path");
+
+    // Find the bin directory where `openclaw` symlink lives (NOT the realpath).
+    // e.g. fnm puts symlinks in .../bin/openclaw -> ../lib/node_modules/openclaw/openclaw.mjs
+    // We want the .../bin/ directory so clawmatrix shim is on PATH.
+    let binDir: string | null = null;
+    const envPath = process.env.PATH ?? "";
+    for (const dir of envPath.split(path.delimiter)) {
+      const candidate = path.join(dir, "openclaw");
+      try {
+        fs.accessSync(candidate, fs.constants.X_OK);
+        binDir = dir;
+        break;
+      } catch {
+        // Not in this dir
+      }
+    }
+    if (!binDir) return;
+
+    const shimPath = path.join(binDir, "clawmatrix");
+
+    // CRITICAL: If shimPath is a symlink (e.g. fnm/npm may create one),
+    // writeFileSync follows the symlink and overwrites the TARGET file.
+    // This previously destroyed openclaw.mjs. Always remove stale symlinks first.
+    try {
+      const stat = fs.lstatSync(shimPath);
+      if (stat.isSymbolicLink()) {
+        fs.unlinkSync(shimPath);
+        // Proceed to create a regular file below
+      } else if (stat.isFile()) {
+        // Regular file — check if it's already our shim
+        const existing = fs.readFileSync(shimPath, "utf-8");
+        if (existing.includes("clawmatrix-shim")) return; // already installed
+      }
+    } catch {
+      // File doesn't exist, proceed to create
+    }
+
+    // Standalone CLI: bypasses openclaw plugin loading entirely.
+    // Resolves cli/bin/clawmatrix.mjs relative to the plugin directory.
+    const cliScript = path.resolve(__dirname, "..", "cli", "bin", "clawmatrix.mjs");
+    const shim = `#!/usr/bin/env sh
+# clawmatrix-shim: auto-installed by clawmatrix plugin
+exec node "${cliScript}" "$@"
+`;
+
+    fs.writeFileSync(shimPath, shim, { mode: 0o755 });
+    logger.info(`[clawmatrix] Installed global CLI shim: ${shimPath}`);
+  } catch {
+    // Best-effort: don't break plugin loading if shim install fails
+  }
+}
+
 export default plugin;