clawmatrix 0.6.0 → 0.6.2

package/cli/bin/clawmatrix.mjs

@@ -650,6 +650,8 @@ function cmdHelpJson() {
     { name: "peers", args: "", options: [], description: "List known peers (JSON)" },
     { name: "check", args: "<nodeId>", options: [], description: "Check if a specific node is reachable" },
     { name: "config", args: "", options: ["--json"], description: "Show local node configuration" },
+    { name: "config read", args: "<path>", options: [], description: "Read a config file under ~/.openclaw/" },
+    { name: "config write", args: "<path> <content|->", options: [], description: "Write a config file under ~/.openclaw/" },
     { name: "availability", args: "[range]", options: ["--json"], description: "Show node uptime (24h|7d|90d)" },
     // Tools & Execution
     { name: "tools", args: "[node]", options: ["--json", "-v", "-f <keyword>", "-d <tool>"], description: "List available tools on remote nodes" },
@@ -677,6 +679,7 @@ function cmdHelpJson() {
     { name: "kb files", args: "", options: ["--json"], description: "List all synced knowledge files" },
     { name: "kb history", args: "<path>", options: ["--json"], description: "Show change history for a synced file" },
     { name: "kb blame", args: "<path>", options: ["--json"], description: "Show line-by-line attribution for a synced file" },
+    { name: "kb content", args: "<path>", options: [], description: "Read the content of a synced file" },
     { name: "board", args: "", options: ["--json"], description: "Kanban board summary" },
     { name: "board list", args: "", options: ["--json", "--stage <s>", "--label <l>", "--priority <p>", "--node <n>"], description: "List kanban cards" },
     { name: "board create", args: "<title>", options: ["--desc <text>", "--priority <p>", "--labels <l1,l2>", "--node <n>", "--agent <a>"], description: "Create a new kanban card" },
@@ -972,7 +975,8 @@ async function cmdKb(args) {
 Subcommands:
   files [--json]          List all synced files with metadata
   history <path> [--json] Show change history for a synced file
-  blame <path> [--json]   Show line-by-line attribution for a synced file`);
+  blame <path> [--json]   Show line-by-line attribution for a synced file
+  content <path>          Read the content of a synced file`);
     return;
   }
 
@@ -1043,6 +1047,19 @@ Subcommands:
       return;
     }
 
+    if (subCmd === "content" || subCmd === "read" || subCmd === "cat") {
+      const filePath = subArgs.filter((a) => !a.startsWith("--"))[0];
+      if (!filePath) { console.error("Usage: clawmatrix kb content <path>"); process.exit(1); }
+      const result = await callGateway("clawmatrix.kb.content", { path: filePath });
+      if (result.content !== undefined) {
+        console.log(result.content);
+      } else {
+        console.error(`Error: ${result.error || "File not found"}`);
+        process.exitCode = 1;
+      }
+      return;
+    }
+
     if (subCmd === "blame") {
       const filePath = subArgs.filter((a) => !a.startsWith("--"))[0];
       if (!filePath) { console.error("Usage: clawmatrix kb blame <path>"); process.exit(1); }
@@ -1513,6 +1530,65 @@ Subcommands:
 
 async function cmdConfig(args) {
   const isJson = args.includes("--json");
+  const subCmd = args[0];
+
+  // config read <path> — read a config file under ~/.openclaw/
+  if (subCmd === "read") {
+    const configPath = args[1];
+    if (!configPath) { console.error("Usage: clawmatrix config read <path>  (path under ~/.openclaw/)"); process.exit(1); }
+    try {
+      const data = await callGateway("clawmatrix.config.read", { path: configPath });
+      if (data.content !== undefined) {
+        console.log(data.content);
+      } else {
+        console.error(`Error: ${data.error || "Failed to read config"}`);
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      console.error(`Error: ${err.message || String(err)}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  // config write <path> <content|-> — write a config file under ~/.openclaw/
+  if (subCmd === "write") {
+    const configPath = args[1];
+    let content = args[2];
+    if (!configPath) { console.error("Usage: clawmatrix config write <path> <content|->"); process.exit(1); }
+    if (content === "-" || (!content && !process.stdin.isTTY)) {
+      const chunks = [];
+      for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+      content = Buffer.concat(chunks).toString("utf-8");
+    }
+    if (!content) { console.error("Error: No content provided. Pass content as argument or pipe via stdin."); process.exit(1); }
+    try {
+      const data = await callGateway("clawmatrix.config.write", { path: configPath, content });
+      if (data.success) {
+        console.log(`Written: ${configPath}`);
+      } else {
+        console.error(`Error: ${data.error || "Failed to write config"}`);
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      console.error(`Error: ${err.message || String(err)}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  if (subCmd === "--help" || subCmd === "-h") {
+    console.log(`Usage: clawmatrix config [subcommand]
+
+Subcommands:
+  (no args)               Show local node configuration summary
+  read <path>             Read a config file under ~/.openclaw/
+  write <path> <content|->
+                          Write a config file under ~/.openclaw/
+Options:
+  --json                  Output as JSON`);
+    return;
+  }
 
   try {
     const data = await callGateway("clawmatrix.config.get");
@@ -1608,7 +1684,7 @@ Cluster:
   status                  Show cluster topology and peer status
   peers                   List known peers (JSON)
   check <nodeId>          Check if a specific node is reachable
-  config                  Show local node configuration
+  config [subcmd]         Node config (read|write or show summary)
   availability [range]    Show node uptime (24h|7d|90d)
 
 Tools & Execution:

package/cli/skills/clawmatrix/SKILL.md

@@ -18,10 +18,7 @@ All commands output LLM-friendly text (no ANSI colors) when stdout is not a TTY.
 ```bash
 clawmatrix status          # Cluster topology: peers, agents, models, tags
 clawmatrix status --json   # Structured JSON output
-clawmatrix peers           # List known peers (JSON)
 clawmatrix check <nodeId>  # Quick reachability check with latency
-clawmatrix config          # Show local node configuration
-clawmatrix config --json   # Config as JSON
 ```
 
 Always start with `clawmatrix status` to understand the current topology before performing other operations.
@@ -58,14 +55,6 @@ clawmatrix models                   # All cluster models
 clawmatrix models --node <nodeId>   # Filter by node
 ```
 
-## Availability
-
-```bash
-clawmatrix availability              # Node uptime (default: 24h)
-clawmatrix availability 7d           # 7-day uptime
-clawmatrix availability 90d --json   # 90-day as JSON
-```
-
 ## Events
 
 ```bash
@@ -74,19 +63,6 @@ clawmatrix events --type <type>         # Filter by type
 clawmatrix events --source <nodeId>     # Filter by source node
 clawmatrix events --consume <id1,id2>   # Mark events as consumed
 clawmatrix events --all                 # Include consumed events
-clawmatrix events ingest '[{"type":"x","source":"y","data":{}}]'  # Ingest events
-```
-
-## Automations
-
-```bash
-clawmatrix automations rules             # List automation rules
-clawmatrix automations history           # Execution history
-clawmatrix automations history --limit 5 # Limit results
-clawmatrix automations run <ruleId>      # Manually trigger a rule
-clawmatrix automations replay <execId>   # Re-run historical execution
-clawmatrix automations save rules.json   # Save rules from JSON file
-cat rules.json | clawmatrix automations save -  # Save from stdin
 ```
 
 ## Peer Approval
@@ -118,31 +94,6 @@ clawmatrix notify "iOS 构建" --action end --task-id <id>
 
 Options: `--detail <text>`, `--progress <0-100>`, `--action start|update|end`, `--task-id <id>`, `--tool <name>`
 
-## Knowledge Sync
-
-```bash
-clawmatrix kb files                     # List synced knowledge files
-clawmatrix kb history <path>            # File change history
-clawmatrix kb blame <path>              # Line-by-line attribution
-```
-
-## Kanban Board
-
-```bash
-clawmatrix board                        # Board summary
-clawmatrix board list                   # List all cards
-clawmatrix board list --stage in_progress --priority urgent  # Filter cards
-clawmatrix board create "Task title" --priority high --labels "bug,p0"
-clawmatrix board get <cardId>           # Card details
-clawmatrix board update <cardId> --title "New title" --desc "Updated"
-clawmatrix board claim <cardId>         # Claim a card
-clawmatrix board move <cardId> done     # Move to stage
-clawmatrix board annotate <cardId> "Progress note" --type progress
-clawmatrix board delete <cardId>        # Delete a card
-```
-
-Stages: `backlog` → `claimed` → `in_progress` → `review` → `done` → `archived`
-
 ## Workflow
 
 1. Run `clawmatrix status` to see the cluster topology

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmatrix",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Decentralized mesh cluster plugin for OpenClaw — inter-gateway communication, model proxy, task handoff, and tool proxy.",
   "type": "module",
   "license": "MIT",

package/src/api.ts

@@ -733,32 +733,6 @@ export class ApiHandler {
     return resolved;
   }
 
-  /** Read a config file (for gateway methods). */
-  async readConfigFile(configPath: string): Promise<{ success: boolean; content?: string; error?: string }> {
-    const resolved = this.resolveConfigPath(configPath);
-    if (!resolved) return { success: false, error: "Path must be under ~/.openclaw/" };
-    try {
-      const content = await readFile(resolved, "utf-8");
-      return { success: true, content };
-    } catch (err: unknown) {
-      if ((err as NodeJS.ErrnoException).code === "ENOENT") return { success: true, content: "{}" };
-      return { success: false, error: err instanceof Error ? err.message : "Failed to read config" };
-    }
-  }
-
-  /** Write a config file (for gateway methods). */
-  async writeConfigFile(configPath: string, content: string): Promise<{ success: boolean; error?: string }> {
-    const resolved = this.resolveConfigPath(configPath);
-    if (!resolved) return { success: false, error: "Path must be under ~/.openclaw/" };
-    try {
-      await mkdir(dirname(resolved), { recursive: true });
-      await writeFile(resolved, content, "utf-8");
-      return { success: true };
-    } catch (err) {
-      return { success: false, error: err instanceof Error ? err.message : "Failed to write config" };
-    }
-  }
-
   /** GET /api/config/read?path=<configPath> — read a local config file. */
   private async handleConfigRead(req: IncomingMessage, res: ServerResponse) {
     const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
@@ -1609,46 +1583,6 @@ export class ApiHandler {
     return events.slice(-(opts?.limit ?? 50)).reverse();
   }
 
-  /** Ingest events programmatically (from gateway methods, CLI, etc.). */
-  ingestEvents(items: Array<Record<string, unknown>>): { count: number; ids: string[] } {
-    const ingested: IngestedEvent[] = [];
-    for (const item of items) {
-      if (!item.type) continue;
-      const event: IngestedEvent = {
-        id: nanoid(),
-        source: String(item.source || "unknown"),
-        type: String(item.type),
-        data: (typeof item.data === "object" && item.data !== null ? item.data : { value: item.data ?? item }) as Record<string, unknown>,
-        ts: typeof item.ts === "number" ? Math.min(item.ts as number, Date.now()) : Date.now(),
-        consumed: false,
-      };
-      this.ingestedEvents.push(event);
-      ingested.push(event);
-      try {
-        this.store?.insertIngestedEvent({
-          id: event.id, ts: event.ts, type: event.type, source: event.source,
-          data: JSON.stringify(event.data),
-        });
-      } catch { /* non-fatal */ }
-    }
-    if (this.ingestedEvents.length > MAX_INGESTED_EVENTS) {
-      this.ingestedEvents.splice(0, this.ingestedEvents.length - MAX_INGESTED_EVENTS);
-    }
-    for (const event of ingested) {
-      this.pushSatelliteEvent({
-        ts: event.ts,
-        type: "event_ingested" as SatelliteEvent["type"],
-        data: { id: event.id, source: event.source, type: event.type },
-      });
-    }
-    if (this.automationManager) {
-      for (const event of ingested) {
-        this.automationManager.onEventIngested(event);
-      }
-    }
-    return { count: ingested.length, ids: ingested.map(e => e.id) };
-  }
-
   /** Mark events as consumed by id(s). */
   consumeEvents(ids: string[]): number {
     if (this.store) {

package/src/connection.ts

@@ -147,7 +147,17 @@ export class Connection extends EventEmitter<ConnectionEvents> {
 
   /** Bind standard WebSocket event listeners. Call this for outbound connections. */
   bindWebSocket(ws: WebSocket) {
-    ws.addEventListener("message", (ev) => this.onRawMessage(ev.data));
+    // Node.js 22+ built-in WebSocket defaults binaryType to "blob", which
+    // onRawMessage cannot handle (Blob is async-only).  Set "arraybuffer"
+    // so binary frames arrive as ArrayBuffer, then normalize to Buffer below.
+    if ("binaryType" in ws) {
+      (ws as any).binaryType = "arraybuffer";
+    }
+    ws.addEventListener("message", (ev) => {
+      // Normalize ArrayBuffer → Buffer for consistent handling across runtimes
+      const data = ev.data instanceof ArrayBuffer ? Buffer.from(ev.data) : ev.data;
+      this.onRawMessage(data);
+    });
     ws.addEventListener("close", (ev) => {
       this.close(ev.code, ev.reason);
     });
@@ -208,11 +218,19 @@ export class Connection extends EventEmitter<ConnectionEvents> {
 
   /** Send raw data. Buffers sent as binary frames; strings as-is; objects JSON-encoded. */
   private sendRaw(data: unknown) {
-    if (this.transport.readyState === WebSocket.OPEN) {
-      if (Buffer.isBuffer(data)) {
-        this.transport.send(data);
-      } else {
-        this.transport.send(typeof data === "string" ? data : JSON.stringify(data));
+    try {
+      if (this.transport.readyState === WebSocket.OPEN) {
+        if (Buffer.isBuffer(data)) {
+          this.transport.send(data);
+        } else {
+          this.transport.send(typeof data === "string" ? data : JSON.stringify(data));
+        }
+      }
+    } catch (err) {
+      debug("send", `sendRaw failed for ${this.remoteNodeId ?? "unknown"}: ${err}`);
+      // Transport is broken — schedule close on next tick to avoid re-entrancy
+      if (!this.closed) {
+        queueMicrotask(() => this.close(4002, "send failed"));
       }
     }
   }
@@ -269,25 +287,6 @@ export class Connection extends EventEmitter<ConnectionEvents> {
   private async onRawMessage(data: unknown) {
     this.lastReceivedAt = Date.now();
 
-    // Debug: log data type for unauthenticated connections to diagnose auth issues
-    if (!this.authenticated && this.role === "outbound") {
-      const dtype = Buffer.isBuffer(data) ? `Buffer(${(data as Buffer).length})` :
-        data instanceof ArrayBuffer ? `ArrayBuffer(${data.byteLength})` :
-        typeof data === "string" ? `string(${data.length})` :
-        `${data?.constructor?.name ?? typeof data}`;
-      debug("auth", `onRawMessage[outbound] dataType=${dtype}`);
-    }
-
-    // Normalize non-Buffer binary types to Buffer.
-    // Node.js 24+'s built-in WebSocket (undici) delivers binary frames as Blob
-    // (binaryType "blob") or ArrayBuffer (binaryType "arraybuffer").
-    // The ws package delivers Buffer (binaryType "nodebuffer").
-    if (data instanceof ArrayBuffer) {
-      data = Buffer.from(data);
-    } else if (typeof Blob !== "undefined" && data instanceof Blob) {
-      data = Buffer.from(await data.arrayBuffer());
-    }
-
     let frame: AnyClusterFrame | undefined;
 
     // Binary frame (Buffer) — decrypt directly without base64
@@ -403,7 +402,7 @@ export class Connection extends EventEmitter<ConnectionEvents> {
     }
 
     if (frame.type === "ping") {
-      this.send({ type: "pong", from: this.nodeId, timestamp: Date.now() } as AnyClusterFrame);
+      this.sendDirect({ type: "pong", from: this.nodeId, timestamp: Date.now() } as AnyClusterFrame);
       return;
     }
     if (frame.type === "pong") {
@@ -579,7 +578,6 @@ export class Connection extends EventEmitter<ConnectionEvents> {
       }
 
       // auth_ok (decrypted from binary envelope, or plaintext legacy)
-      debug("auth", `Outbound received frame type=${frame.type} (authenticated=${this.authenticated})`);
       if (frame.type === "auth_ok") {
         const ok = frame as AuthOk;
         this.remoteNodeId = ok.payload.nodeId;
@@ -718,7 +716,7 @@ export class Connection extends EventEmitter<ConnectionEvents> {
         return;
       }
       this.lastPingSentAt = Date.now();
-      this.send({
+      this.sendDirect({
         type: "ping",
         from: this.nodeId,
         timestamp: this.lastPingSentAt,
@@ -755,7 +753,7 @@ export class Connection extends EventEmitter<ConnectionEvents> {
   close(code = 1000, reason = "normal") {
     if (this.closed) return;
     // Flush any pending batch before closing
-    this.flushBatch();
+    try { this.flushBatch(); } catch { /* transport may already be dead */ }
     this.closed = true;
     this.clearAuthTimer();
     if (this.heartbeatTimer) {

package/src/health-tracker.ts

@@ -55,6 +55,10 @@ export class HealthTracker {
   private readonly nodeId: string;
   private store: Store | null;
   private logReplicator: LogReplicator | null;
+  /** In-memory timestamp of when start() was called (survives store failures). */
+  private startedAt: number | null = null;
+  /** In-memory tracking of currently connected peers (timestamp of connection). */
+  private readonly connectedPeers = new Map<string, number>();
 
   constructor(opts: HealthTrackerOptions) {
     this.nodeId = opts.nodeId;
@@ -66,14 +70,23 @@ export class HealthTracker {
   setStore(store: Store, logReplicator?: LogReplicator) {
     this.store = store;
     this.logReplicator = logReplicator ?? this.logReplicator;
+    // Flush deferred events that occurred before store was available
+    if (this.startedAt !== null) {
+      this.recordEvent({ ts: this.startedAt, type: "start" });
+    }
+    for (const [peerId, ts] of this.connectedPeers) {
+      this.recordEvent({ ts, type: "peer_online", peer: peerId, via: "direct" });
+    }
   }
 
   async start() {
-    this.recordEvent({ ts: Date.now(), type: "start" });
+    this.startedAt = Date.now();
+    this.recordEvent({ ts: this.startedAt, type: "start" });
     debug(TAG, `health tracker started for node "${this.nodeId}"`);
   }
 
   async stop() {
+    this.startedAt = null;
     this.recordEvent({ ts: Date.now(), type: "stop" });
     debug(TAG, "health tracker stopped");
   }
@@ -98,10 +111,12 @@ export class HealthTracker {
   }
 
   recordPeerOnline(peerId: string, via: "direct" | "relay") {
+    this.connectedPeers.set(peerId, Date.now());
     this.recordEvent({ ts: Date.now(), type: "peer_online", peer: peerId, via });
   }
 
   recordPeerOffline(peerId: string, reason?: string) {
+    this.connectedPeers.delete(peerId);
     this.recordEvent({ ts: Date.now(), type: "peer_offline", peer: peerId, reason });
   }
 
@@ -143,6 +158,18 @@ export class HealthTracker {
 
     // Find observation gaps (periods where THIS node was down)
     const selfEvents = this.getEventsForNode(this.nodeId);
+    // Inject current in-memory session if not reflected in persisted events.
+    // This handles the case where the store wasn't ready when start() was called,
+    // or the start event failed to persist for any reason.
+    if (this.startedAt !== null) {
+      const hasCurrentStart = selfEvents.some(
+        (e) => e.type === "start" && e.ts === this.startedAt,
+      );
+      if (!hasCurrentStart) {
+        selfEvents.push({ ts: this.startedAt, type: "start" });
+        selfEvents.sort((a, b) => a.ts - b.ts);
+      }
+    }
     const gaps = this.getObservationGaps(selfEvents, startTs, endTs);
 
     // Build timeline for each node (including self)
@@ -154,15 +181,22 @@ export class HealthTracker {
     for (const ev of allEvents) {
       if (ev.peer) everConnected.add(ev.peer);
     }
+    // Include currently connected peers (in-memory, survives store failures)
+    for (const peerId of this.connectedPeers.keys()) {
+      everConnected.add(peerId);
+    }
 
     const knownNodes = new Set(this.getKnownNodes());
+    // Always include self node
+    knownNodes.add(this.nodeId);
     // Also include nodes we've observed via peer_online events
     for (const peerId of everConnected) knownNodes.add(peerId);
 
     for (const nodeId of knownNodes) {
       if (nodeId !== this.nodeId && !everConnected.has(nodeId)) continue;
 
-      const events = this.getEventsForNode(nodeId);
+      // Reuse selfEvents (with injected in-memory start) for the self node
+      const events = nodeId === this.nodeId ? selfEvents : this.getEventsForNode(nodeId);
       const timeline = this.buildNodeTimeline(
         nodeId, events, startTs, endTs, bucketMs, bucketCount, gaps,
       );
@@ -190,7 +224,15 @@ export class HealthTracker {
       ? this.buildPeerIntervals(nodeId, startTs, endTs)
       : [];
 
-    if (sorted.length === 0 && peerIntervals.length === 0) return null;
+    if (sorted.length === 0 && peerIntervals.length === 0) {
+      // For self node with no events (store not initialized), treat as currently online
+      if (nodeId === this.nodeId) {
+        const now = Date.now();
+        const buckets: BucketState[] = Array(bucketCount).fill("up");
+        return { nodeId, firstSeen: now, lastSeen: now, buckets, uptimeRatio: 1 };
+      }
+      return null;
+    }
 
     // Determine firstSeen/lastSeen from both self-reported events and peer observations
     let firstSeen = Infinity;
@@ -300,13 +342,29 @@ export class HealthTracker {
     startTs: number,
     endTs: number,
   ): Array<[number, number]> {
-    if (!this.store) return [];
+    const relevantEvents: HealthEvent[] = [];
+
+    if (this.store) {
+      // Collect peer_online/peer_offline events about this node from ALL observers
+      const relevantRows = this.store.queryHealth({ peer: targetNodeId });
+      for (const r of relevantRows) {
+        if (r.type === "peer_online" || r.type === "peer_offline") {
+          relevantEvents.push({ ts: r.ts, type: r.type as HealthEvent["type"], peer: r.peer ?? undefined });
+        }
+      }
+    }
+
+    // Inject in-memory connected peer if not reflected in persisted events
+    const connectedAt = this.connectedPeers.get(targetNodeId);
+    if (connectedAt !== undefined) {
+      const hasRecentOnline = relevantEvents.some(
+        (e) => e.type === "peer_online" && e.ts === connectedAt,
+      );
+      if (!hasRecentOnline) {
+        relevantEvents.push({ ts: connectedAt, type: "peer_online", peer: targetNodeId });
+      }
+    }
 
-    // Collect peer_online/peer_offline events about this node from ALL observers
-    const relevantRows = this.store.queryHealth({ peer: targetNodeId });
-    const relevantEvents: HealthEvent[] = relevantRows
-      .filter(r => r.type === "peer_online" || r.type === "peer_offline")
-      .map(r => ({ ts: r.ts, type: r.type as HealthEvent["type"], peer: r.peer ?? undefined }));
     relevantEvents.sort((a, b) => a.ts - b.ts);
 
     const intervals: Array<[number, number]> = [];

package/src/index.ts

@@ -1537,291 +1537,6 @@ const plugin = {
       },
     );
 
-    // ── Availability gateway method ──────────────────────────────────
-
-    api.registerGatewayMethod(
-      "clawmatrix.availability",
-      ({ params, respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          const { range } = (params ?? {}) as { range?: string };
-          const validRanges = ["24h", "7d", "90d"];
-          const r = validRanges.includes(range ?? "") ? (range as "24h" | "7d" | "90d") : "24h";
-          const result = runtime.healthTracker.getAvailability(r);
-          respond(true, result);
-        } catch {
-          respond(false, { error: "ClawMatrix service not running" });
-        }
-      },
-    );
-
-    // ── Automation gateway methods ──────────────────────────────────
-
-    api.registerGatewayMethod(
-      "clawmatrix.automations.rules",
-      ({ respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          if (!runtime.automationManager) {
-            respond(true, { rules: [] });
-            return;
-          }
-          respond(true, { rules: runtime.automationManager.getRules() });
-        } catch {
-          respond(false, { error: "ClawMatrix service not running" });
-        }
-      },
-    );
-
-    api.registerGatewayMethod(
-      "clawmatrix.automations.save",
-      async ({ params, respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          if (!runtime.automationManager) {
-            respond(false, { error: "Automations not available" });
-            return;
-          }
-          const { rules } = (params ?? {}) as { rules?: unknown[] };
-          if (!Array.isArray(rules)) {
-            respond(false, { error: "Missing required param: rules (array)" });
-            return;
-          }
-          await runtime.automationManager.saveRules(rules as Parameters<typeof runtime.automationManager.saveRules>[0]);
-          respond(true, { ok: true, count: rules.length });
-        } catch (err) {
-          respond(false, { error: String(err) });
-        }
-      },
-    );
-
-    api.registerGatewayMethod(
-      "clawmatrix.automations.history",
-      ({ params, respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          if (!runtime.automationManager) {
-            respond(true, { executions: [] });
-            return;
-          }
-          const { limit } = (params ?? {}) as { limit?: number };
-          respond(true, { executions: runtime.automationManager.getExecutions(limit ?? 50) });
-        } catch {
-          respond(false, { error: "ClawMatrix service not running" });
-        }
-      },
-    );
-
-    api.registerGatewayMethod(
-      "clawmatrix.automations.run",
-      async ({ params, respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          if (!runtime.automationManager) {
-            respond(false, { error: "Automations not available" });
-            return;
-          }
-          const { ruleId, event } = (params ?? {}) as { ruleId?: string; event?: Record<string, unknown> };
-          if (!ruleId) {
-            respond(false, { error: "Missing required param: ruleId" });
-            return;
-          }
-          const evt = event ? {
-            id: nanoid(),
-            source: String(event.source || "cli"),
-            type: String(event.type || "manual"),
-            data: (event.data ?? {}) as Record<string, unknown>,
-            ts: typeof event.ts === "number" ? event.ts : Date.now(),
-            consumed: false,
-          } as import("./types.ts").IngestedEvent : undefined;
-          const execution = await runtime.automationManager.runRuleById(ruleId, evt);
-          respond(true, { ok: true, execution });
-        } catch (err) {
-          respond(false, { error: String(err) });
-        }
-      },
-    );
-
-    api.registerGatewayMethod(
-      "clawmatrix.automations.replay",
-      async ({ params, respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          if (!runtime.automationManager) {
-            respond(false, { error: "Automations not available" });
-            return;
-          }
-          const { executionId } = (params ?? {}) as { executionId?: string };
-          if (!executionId) {
-            respond(false, { error: "Missing required param: executionId" });
-            return;
-          }
-          const execution = await runtime.automationManager.replayExecution(executionId);
-          respond(true, { ok: true, execution });
-        } catch (err) {
-          respond(false, { error: String(err) });
-        }
-      },
-    );
-
-    // ── Events ingest gateway method ──────────────────────────────────
-
-    api.registerGatewayMethod(
-      "clawmatrix.events.ingest",
-      ({ params, respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          if (!runtime.apiHandler) {
-            respond(false, { error: "API handler not available (listen mode required)" });
-            return;
-          }
-          const { events } = (params ?? {}) as { events?: unknown[] };
-          if (!Array.isArray(events) || events.length === 0) {
-            respond(false, { error: "Missing required param: events (non-empty array)" });
-            return;
-          }
-          const result = runtime.apiHandler.ingestEvents(events as Array<Record<string, unknown>>);
-          respond(true, { ok: true, ...result });
-        } catch {
-          respond(false, { error: "ClawMatrix service not running" });
-        }
-      },
-    );
-
-    // ── Board update gateway method ──────────────────────────────────
-
-    api.registerGatewayMethod(
-      "clawmatrix.board.update",
-      ({ params, respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          if (!runtime.kanbanManager) {
-            respond(false, { error: "Kanban not enabled" });
-            return;
-          }
-          const { cardId, ...updates } = (params ?? {}) as {
-            cardId?: string; title?: string; description?: string;
-            priority?: string; targetNode?: string; targetAgent?: string;
-            cwd?: string; labels?: string[];
-          };
-          if (!cardId) {
-            respond(false, { error: "Missing required param: cardId" });
-            return;
-          }
-          const card = runtime.kanbanManager.updateCard(cardId, updates as Parameters<typeof runtime.kanbanManager.updateCard>[1]);
-          if (!card) {
-            respond(false, { error: `Card not found: ${cardId}` });
-            return;
-          }
-          respond(true, card);
-        } catch {
-          respond(false, { error: "ClawMatrix service not running" });
-        }
-      },
-    );
-
-    // ── Config gateway method ──────────────────────────────────────────
-
-    api.registerGatewayMethod(
-      "clawmatrix.config.get",
-      ({ respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          const c = runtime.config;
-          respond(true, {
-            nodeId: c.nodeId,
-            listen: c.listen,
-            tags: c.tags,
-            agents: c.agents.map((a) => ({ id: a.id, model: a.model })),
-            models: c.models.map((m) => ({ id: m.id, provider: m.provider })),
-            e2ee: c.e2ee,
-            toolProxy: c.toolProxy ? { enabled: c.toolProxy.enabled, allow: c.toolProxy.allow, deny: c.toolProxy.deny } : undefined,
-            terminal: c.terminal,
-            acp: c.acp ? { enabled: c.acp.enabled } : undefined,
-            knowledge: c.knowledge ? { enabled: c.knowledge.enabled } : undefined,
-            proxyModels: c.proxyModels?.length ?? 0,
-            peers: c.peers?.length ?? 0,
-          });
-        } catch {
-          respond(false, { error: "ClawMatrix service not running" });
-        }
-      },
-    );
-
-    // ── Config file read/write gateway methods ──────────────────────
-
-    api.registerGatewayMethod(
-      "clawmatrix.config.read",
-      async ({ params, respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          if (!runtime.apiHandler) {
-            respond(false, { error: "API handler not available" });
-            return;
-          }
-          const { path: configPath } = (params ?? {}) as { path?: string };
-          if (!configPath) {
-            respond(false, { error: "Missing required param: path" });
-            return;
-          }
-          const result = await runtime.apiHandler.readConfigFile(configPath);
-          respond(result.success, result);
-        } catch (err) {
-          respond(false, { error: String(err) });
-        }
-      },
-    );
-
-    api.registerGatewayMethod(
-      "clawmatrix.config.write",
-      async ({ params, respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          if (!runtime.apiHandler) {
-            respond(false, { error: "API handler not available" });
-            return;
-          }
-          const { path: configPath, content } = (params ?? {}) as { path?: string; content?: string };
-          if (!configPath || typeof content !== "string") {
-            respond(false, { error: "Missing required params: path, content" });
-            return;
-          }
-          const result = await runtime.apiHandler.writeConfigFile(configPath, content);
-          respond(result.success, result);
-        } catch (err) {
-          respond(false, { error: String(err) });
-        }
-      },
-    );
-
-    // ── Knowledge content gateway method ──────────────────────────────
-
-    api.registerGatewayMethod(
-      "clawmatrix.kb.content",
-      ({ params, respond }: GatewayRequestHandlerOptions) => {
-        try {
-          const runtime = getClusterRuntime();
-          if (!runtime.knowledgeSync) {
-            respond(false, { error: "Knowledge sync not enabled" });
-            return;
-          }
-          const { path } = (params ?? {}) as { path?: string };
-          if (!path) {
-            respond(false, { error: "Missing required param: path" });
-            return;
-          }
-          const content = runtime.knowledgeSync.getFileContent(path);
-          if (content === null) {
-            respond(false, { error: "File not found or content not yet synced" });
-            return;
-          }
-          respond(true, { path, content });
-        } catch {
-          respond(false, { error: "ClawMatrix service not running" });
-        }
-      },
-    );
-
     // 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}`);

package/src/knowledge-sync.ts

@@ -191,6 +191,11 @@ export class KnowledgeSync {
 
   // ── Public API ─────────────────────────────────────────────────
 
+  /** The resolved workspace directory that knowledge files are synced under. */
+  get workspacePath(): string {
+    return this.opts.workspacePath;
+  }
+
   async start() {
     debug(TAG, `starting knowledge sync: workspace=${this.opts.workspacePath}`);
 
@@ -536,7 +541,7 @@ export class KnowledgeSync {
   }
 
   /** List all synced files with metadata. */
-  listSyncedFiles(): Array<{ path: string; version: number; updatedAt: number; deleted: boolean }> {
+  listSyncedFiles(): Array<{ path: string; version: number; updatedAt: number; deleted: boolean; synced: boolean }> {
     const files = this.registry.files;
     if (!files) return [];
     return Object.entries(files).map(([path, meta]) => ({
@@ -544,6 +549,7 @@ export class KnowledgeSync {
       version: meta.version,
       updatedAt: meta.updatedAt,
       deleted: meta.deleted,
+      synced: this.fileDocs.has(path) && this.fileDocs.get(path)!.content !== undefined,
     })).filter(f => !f.deleted);
   }
 

package/src/peer-manager.ts

@@ -140,7 +140,19 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     super();
     this.config = config;
     this.localDeviceInfo = collectDeviceInfo(openclawVersion, openclawConfig);
-    const acpAgents = config.acp?.enabled ? config.acp.agents : undefined;
+    // Determine initial ACP agents: ClawMatrix config → OpenClaw config fallback.
+    // When ACP is enabled via OpenClaw but ClawMatrix has no explicit agents list,
+    // use OpenClaw's allowedAgents so auth_ok advertises them before async detection.
+    const ocAcp = (openclawConfig as Record<string, any>)?.acp;
+    const acpEnabled = config.acp?.enabled || ocAcp?.enabled;
+    let acpAgents: { id: string; description: string }[] | undefined;
+    if (acpEnabled) {
+      if (config.acp?.agents?.length) {
+        acpAgents = config.acp.agents;
+      } else if (Array.isArray(ocAcp?.allowedAgents) && ocAcp.allowedAgents.length > 0) {
+        acpAgents = ocAcp.allowedAgents.map((id: string) => ({ id, description: "" }));
+      }
+    }
     this.localCapabilities = {
       nodeId: config.nodeId,
       agents: config.agents,
@@ -707,9 +719,15 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         debug("peer", `connectToChannel(${nodeId}): self-connection, will not reconnect`);
         return;
       }
-      // Don't reconnect warm-up pruned channels
-      if (ev.reason === "warm-up pruned") {
-        debug("peer", `connectToChannel(${nodeId}): warm-up pruned, will not reconnect`);
+      // Don't reconnect deliberate closures that shouldn't trigger reconnection
+      const skipReasons = ["warm-up pruned", "route switch", "replaced by new connection"];
+      if (skipReasons.includes(ev.reason)) {
+        debug("peer", `connectToChannel(${nodeId}): ${ev.reason}, will not reconnect`);
+        return;
+      }
+      // Don't reconnect when peer approval was denied — retrying is futile
+      if (ev.code === 4005) {
+        debug("peer", `connectToChannel(${nodeId}): approval denied, will not reconnect`);
         return;
       }
       // Record close code for adaptive backoff

package/src/sentinel.ts

@@ -177,7 +177,7 @@ function buildCapabilities(): NodeCapabilities {
 }
 
 function connectToPeer(peer: { nodeId: string; url: string }) {
-  const ws = new WsWebSocket(peer.url, ["graphql-transport-ws"]);
+  const ws = new WebSocket(peer.url, ["graphql-transport-ws"]);
   const e2eeOpts: ConnectionE2eeOptions = {
     e2ee: config.e2ee,
     compression: config.compression,