clawmatrix 0.6.0 → 0.6.1

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

@@ -3,151 +3,58 @@ name: clawmatrix
 description: Use the clawmatrix CLI to interact with remote devices (phones, computers, servers) in a mesh cluster — run tools, check location, get battery status, read/write files, execute commands, and more on any connected node.
 ---
 
-Use the `clawmatrix` CLI to interact with the ClawMatrix mesh cluster. Remote nodes can be phones (iPhone/Android), computers, or servers. You can invoke any tool available on remote nodes — including getting device location, battery status, running shell commands, reading/writing files, and more.
+Use the `clawmatrix` CLI to interact with the ClawMatrix mesh cluster. Remote nodes can be phones (iPhone/Android), computers, or servers.
 
-All commands output LLM-friendly text (no ANSI colors) when stdout is not a TTY.
+Run `clawmatrix --help` or `clawmatrix <command> --help` for detailed usage.
 
-## Quick Start
+## Capabilities
 
-1. Run `clawmatrix status` to see connected nodes and their capabilities
-2. Run `clawmatrix tools <nodeId>` to see what tools a node offers
-3. Run `clawmatrix call <nodeId> <tool> '<params>'` to invoke a tool
+**Cluster & Discovery**
+- View cluster topology, peer status, node config, and uptime/availability
+- Check reachability of specific nodes with latency
+- Approve/deny/revoke peer connections
 
-## Cluster Status
+**Remote Tool Execution**
+- Discover tools across all nodes (filter by keyword, describe params)
+- Invoke single tools or batch multiple in one round-trip
+- Tools include device-specific capabilities: location, battery, camera, clipboard, contacts, calendar, health data, HomeKit, etc.
 
-```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
-```
+**Models**
+- List all LLM models available across the cluster, filterable by node
 
-Always start with `clawmatrix status` to understand the current topology before performing other operations.
+**Agent Delegation**
+- `handoff` — delegate tasks to remote agents with streaming output and failover
+- `send` — fire-and-forget messages to remote nodes
+- `acp` — manage persistent coding agent sessions (Claude Code, Codex, Gemini) with prompt/resume/cancel/close
 
-## Remote Tools
+**Events & Automations**
+- Query, consume, and ingest events from external sources (iOS Shortcuts, webhooks, etc.)
+- Manage automation rules: list, create/save, manually trigger, replay historical executions
 
-```bash
-clawmatrix tools                        # List all remote tools (compact)
-clawmatrix tools <nodeId>               # Tools on a specific node
-clawmatrix tools --describe <tool>      # Full usage and parameter schema
-clawmatrix tools --filter <keyword>     # Search by name or description
-```
+**Infrastructure**
+- `diagnostic` — sentinel-based diagnostics (works even when gateway is down)
+- `terminal` — interactive PTY sessions on remote nodes
+- `transfer` — push/pull files up to 100MB between nodes with integrity verification
+- `notify` — push Dynamic Island / Live Activity notifications to iOS devices
 
-Use `--describe` to understand a tool's parameters before calling it.
+**Knowledge Sync (CRDT)**
+- List synced workspace files, view change history, line-by-line blame, read file content
+- All knowledge is CRDT-based and mesh-synced across nodes
 
-## Invoke Tools
+**Kanban Board**
+- Distributed task board: create, list, get, update, claim, move, annotate, delete cards
+- Filter by stage/priority/label/node; stages flow from `backlog` → `done` → `archived`
 
-```bash
-clawmatrix call <nodeId> <tool> '<json-params>'    # Single tool invocation
-clawmatrix call <nodeId> <tool> '<json-params>' -t 30000  # With timeout (ms)
-```
+**Config Management**
+- View runtime config summary
+- Read/write config files under `~/.openclaw/` (for remote node configuration)
 
-```bash
-clawmatrix batch <nodeId> '[{"tool":"t1","params":{}},{"tool":"t2","params":{}}]'
-clawmatrix batch <nodeId> --no-stop-on-error '[...]'  # Continue on failure
-```
+## Important Notes
 
-Batch supports stdin: `echo '<json>' | clawmatrix batch <nodeId>`
-
-## Models
-
-```bash
-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
-clawmatrix events                       # Unconsumed events
-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
-
-```bash
-clawmatrix approve <approvalId>         # Approve a pending peer
-clawmatrix deny <approvalId>            # Deny a pending peer
-clawmatrix approval list                # List pending/approved/denied peers
-clawmatrix approval revoke <nodeId>     # Revoke an approved peer
-```
-
-## Notifications (Dynamic Island / Live Activity)
-
-Push progress notifications to the user's iPhone via `clawmatrix notify`. This triggers the Dynamic Island and lock screen Live Activity.
-
-**Use this proactively when running long tasks** (iOS builds, large refactors, test suites, batch operations) so the user can track progress without watching the terminal.
-
-```bash
-# Start a notification
-clawmatrix notify "iOS 构建" --detail "正在编译..."
-# Returns: {"taskId":"<id>", "action":"start", "targets":1}
-
-# Update progress
-clawmatrix notify "iOS 构建" --action update --task-id <id> --detail "链接中..." --progress 80
-
-# End (success)
-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
-2. Use `clawmatrix tools --filter <keyword>` to find relevant tools
-3. Use `clawmatrix tools --describe <tool>` to check parameters
-4. Use `clawmatrix call` or `clawmatrix batch` to invoke tools
-5. If a call fails, run `clawmatrix check <nodeId>` to verify connectivity
-6. For long-running tasks, use `clawmatrix notify` to push progress to the user's phone
+- **Always start with `clawmatrix status`** to understand the cluster topology before other operations
+- **Use `clawmatrix tools --describe <tool>`** to check a tool's parameter schema before calling it
+- **Use `clawmatrix notify` proactively during long tasks** (builds, tests, large refactors) so the user can track progress on their phone without watching the terminal
+- Output is **LLM-optimized**: no ANSI colors and compact format when stdout is not a TTY; add `--json` for structured output
+- Target nodes by exact `nodeId` or by tag expression `tags:<tag>`
+- Most commands support `--json` for structured output
+- `batch` and `automations save` support stdin for piping data

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmatrix",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "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/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/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,