clawmatrix 0.5.1 → 0.6.1

package/cli/bin/clawmatrix.mjs

@@ -645,27 +645,56 @@ async function cmdApprovalRevoke(nodeId) {
 
 function cmdHelpJson() {
   const commands = [
+    // Cluster
     { name: "status", args: "", options: ["--json"], description: "Show cluster topology and peer status" },
     { 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" },
     { name: "call", args: "<node> <tool> [json]", options: ["-t <ms>"], description: "Invoke a tool on a remote node" },
     { name: "batch", args: "<node> [json]", options: ["--no-stop-on-error", "-t <ms>"], description: "Invoke multiple tools in sequence" },
     { name: "models", args: "", options: ["--json", "-n <nodeId>"], description: "List all cluster models" },
-    { name: "events", args: "", options: ["--json", "-t <type>", "-s <source>", "-l <n>", "-a", "--consume <ids>"], description: "Query and consume events" },
+    // Agents
     { name: "send", args: "<node> <message>", options: [], description: "Send a message to a remote node" },
     { name: "handoff", args: "<task>", options: ["--agent <agent>", "--node <node>", "-t <ms>"], description: "Delegate a task to a remote agent" },
-    { name: "acp", args: "<action>", options: ["-n <node>", "-a <agent>", "--session <id>", "--mode <mode>", "--cwd <dir>"], description: "Manage ACP agent sessions" },
+    { name: "acp", args: "<action>", options: ["-n <node>", "-a <agent>", "--session <id>", "--mode <mode>", "--cwd <dir>"], description: "Manage ACP agent sessions (list|prompt|resume|cancel|close)" },
+    // Events & Automations
+    { name: "events", args: "", options: ["--json", "-t <type>", "-s <source>", "-l <n>", "-a", "--consume <ids>"], description: "Query and consume events" },
+    { name: "events ingest", args: "<json>", options: [], description: "Ingest events from external sources" },
+    { name: "automations rules", args: "", options: ["--json"], description: "List automation rules" },
+    { name: "automations history", args: "", options: ["--json", "--limit <n>"], description: "Show automation execution history" },
+    { name: "automations run", args: "<ruleId>", options: ["--json"], description: "Manually trigger an automation rule" },
+    { name: "automations replay", args: "<executionId>", options: ["--json"], description: "Re-run a historical execution" },
+    { name: "automations save", args: "<json-file|->", options: [], description: "Save automation rules from JSON" },
+    // Infrastructure
     { name: "diagnostic", args: "<node>", options: ["--action status|exec", "-c <command>", "-t <seconds>"], description: "Diagnose a remote node via sentinel" },
     { name: "notify", args: "<title>", options: ["--detail <text>", "--progress <0-100>", "--action start|update|end", "--task-id <id>", "--tool <name>"], description: "Push notification to mobile devices" },
     { name: "terminal", args: "<node>", options: ["--shell <shell>", "--cwd <dir>", "--action list|close|read|input", "--session <id>"], description: "Open/manage remote terminal sessions" },
     { name: "transfer", args: "<node> <path> [remote]", options: ["--pull", "-t <ms>"], description: "Transfer files to/from a remote node" },
+    // Knowledge & Kanban
+    { 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" },
+    { name: "board get", args: "<cardId>", options: ["--json"], description: "Get kanban card details" },
+    { name: "board update", args: "<cardId>", options: ["--title <t>", "--desc <d>", "--priority <p>", "--labels <l1,l2>"], description: "Update kanban card properties" },
+    { name: "board claim", args: "<cardId>", options: ["--agent <a>"], description: "Claim a kanban card" },
+    { name: "board move", args: "<cardId> <stage>", options: [], description: "Move kanban card to a stage" },
+    { name: "board annotate", args: "<cardId> <text>", options: ["--type <t>"], description: "Add annotation to a kanban card" },
+    { name: "board delete", args: "<cardId>", options: [], description: "Delete a kanban card" },
+    // Access Control
     { name: "approve", args: "<approvalId>", options: [], description: "Approve a pending peer" },
     { name: "deny", args: "<approvalId>", options: [], description: "Deny a pending peer" },
     { name: "approval list", args: "", options: [], description: "List approved/pending peers" },
     { name: "approval revoke", args: "<nodeId>", options: [], description: "Revoke an approved peer" },
-    { 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" },
+    // Other
     { name: "install-skill", args: "", options: [], description: "Symlink skill into ~/.claude/skills/" },
   ];
   console.log(jsonOut({ prefix: "clawmatrix", commands }));
@@ -945,7 +974,9 @@ async function cmdKb(args) {
 
 Subcommands:
   files [--json]          List all synced files with metadata
-  history <path> [--json] Show change history for a synced file`);
+  history <path> [--json] Show change history 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;
   }
 
@@ -1016,6 +1047,57 @@ 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); }
+      const result = await callGateway("clawmatrix.kb.blame", { path: filePath });
+      if (isJson) { console.log(jsonOut(result)); return; }
+
+      const blame = result?.blame;
+      if (!Array.isArray(blame) || blame.length === 0) {
+        console.log(`No blame data for: ${filePath}`);
+        return;
+      }
+
+      if (!isTTY) {
+        for (const b of blame) {
+          const parts = [b.line !== undefined ? `L${b.line}` : "?"];
+          if (b.nodeId) parts.push(`node=${b.nodeId}`);
+          if (b.agentId) parts.push(`agent=${b.agentId}`);
+          parts.push(`actor=${b.actor}`);
+          parts.push(new Date(b.timestamp).toISOString());
+          parts.push(b.content || "");
+          console.log(parts.join(" | "));
+        }
+        return;
+      }
+
+      console.log();
+      console.log(`  ${cyan("◆")}  ${bold("File Blame")}  ${dim(filePath)}`);
+      console.log(`  ${bar}`);
+      for (const b of blame) {
+        const lineNum = b.line !== undefined ? dim(`L${String(b.line).padStart(4)}`) : dim("   ?");
+        const attr = b.nodeId ? yellow(b.nodeId) : dim(b.actor || "?");
+        const content = b.content || "";
+        console.log(`  ${bar}  ${lineNum}  ${attr}  ${content}`);
+      }
+      console.log();
+      return;
+    }
+
     console.error(`Unknown kb subcommand: ${subCmd}`);
     process.exit(1);
   } catch (e) {
@@ -1041,6 +1123,8 @@ Subcommands:
   create <title> [--desc <text>] [--priority <p>] [--labels <l1,l2>]
                                 Create a new card
   get <cardId>                  Get card details
+  update <cardId> [--title <t>] [--desc <d>] [--priority <p>] [--labels <l1,l2>]
+                                Update card properties
   claim <cardId> [--agent <a>]  Claim a backlog card
   move <cardId> <stage>         Move card to a stage (backlog|claimed|in_progress|review|done|archived)
   annotate <cardId> <text> [--type <t>]
@@ -1150,6 +1234,29 @@ Subcommands:
       return;
     }
 
+    if (subCmd === "update" || subCmd === "edit") {
+      const cardId = subArgs.filter((a) => !a.startsWith("--"))[0];
+      if (!cardId) { console.error("Usage: clawmatrix board update <cardId> [--title <t>] [--desc <d>] [--priority <p>] [--labels <l1,l2>]"); process.exit(1); }
+      const params = { cardId };
+      const titleIdx = subArgs.indexOf("--title");
+      if (titleIdx !== -1) params.title = subArgs[titleIdx + 1];
+      const descIdx = subArgs.indexOf("--desc");
+      if (descIdx !== -1) params.description = subArgs[descIdx + 1];
+      const prioIdx = subArgs.indexOf("--priority");
+      if (prioIdx !== -1) params.priority = subArgs[prioIdx + 1];
+      const labelsIdx = subArgs.indexOf("--labels");
+      if (labelsIdx !== -1) params.labels = subArgs[labelsIdx + 1]?.split(",");
+      const nodeIdx = subArgs.indexOf("--node");
+      if (nodeIdx !== -1) params.targetNode = subArgs[nodeIdx + 1];
+      const agentIdx = subArgs.indexOf("--agent");
+      if (agentIdx !== -1) params.targetAgent = subArgs[agentIdx + 1];
+
+      const card = await callGateway("clawmatrix.board.update", params);
+      if (isJson) { console.log(jsonOut(card)); return; }
+      console.log(`Updated: ${card.id} — ${card.title}`);
+      return;
+    }
+
     if (subCmd === "claim") {
       const cardId = subArgs.filter((a) => !a.startsWith("--"))[0];
       if (!cardId) { console.error("Usage: clawmatrix board claim <cardId>"); process.exit(1); }
@@ -1226,35 +1333,397 @@ Subcommands:
   }
 }
 
+// ── Availability command ──────────────────────────────────────────
+
+async function cmdAvailability(args) {
+  const isJson = args.includes("--json");
+  const range = args.find((a) => ["24h", "7d", "90d"].includes(a)) || "24h";
+
+  try {
+    const data = await callGateway("clawmatrix.availability", { range });
+    if (isJson) { console.log(jsonOut(data)); return; }
+
+    if (!isTTY) {
+      console.log(`Range: ${data.range} | Bucket: ${data.bucketMinutes}min`);
+      for (const node of (data.nodes || [])) {
+        const uptimeStr = node.uptimeRatio !== undefined ? `${(node.uptimeRatio * 100).toFixed(1)}%` : "N/A";
+        console.log(`${node.nodeId} | uptime: ${uptimeStr} | buckets: ${node.buckets?.length ?? 0}`);
+      }
+      return;
+    }
+
+    console.log();
+    console.log(`  ${cyan("◆")}  ${bold("Availability")}  ${dim(`range: ${data.range}, bucket: ${data.bucketMinutes}min`)}`);
+    console.log(`  ${bar}`);
+
+    for (const node of (data.nodes || [])) {
+      const uptimeStr = node.uptimeRatio !== undefined ? `${(node.uptimeRatio * 100).toFixed(1)}%` : "N/A";
+      const uptimeColor = node.uptimeRatio >= 0.99 ? green : node.uptimeRatio >= 0.9 ? yellow : red;
+      console.log(`  ${bar}  ${bold(node.nodeId)}  ${lbl("uptime")}${uptimeColor(uptimeStr)}`);
+
+      if (node.buckets?.length > 0) {
+        // Render a compact timeline bar
+        const chars = node.buckets.map((b) => {
+          if (b.status === "up") return green("▓");
+          if (b.status === "degraded") return yellow("▒");
+          if (b.status === "down") return red("░");
+          return dim("·");
+        });
+        // Show at most 60 chars for readability
+        const maxWidth = 60;
+        const step = Math.max(1, Math.ceil(chars.length / maxWidth));
+        const compressed = [];
+        for (let i = 0; i < chars.length; i += step) {
+          compressed.push(chars[i]);
+        }
+        console.log(`  ${bar}    ${compressed.join("")}`);
+      }
+    }
+
+    if (data.gaps?.length > 0) {
+      console.log(`  ${bar}`);
+      console.log(`  ${bar}  ${bold("Gaps")}`);
+      for (const gap of data.gaps.slice(0, 10)) {
+        const from = new Date(gap.from).toLocaleString();
+        const to = new Date(gap.to).toLocaleString();
+        const dur = Math.round((gap.to - gap.from) / 60000);
+        console.log(`  ${bar}    ${gap.nodeId}  ${dim(from)} → ${dim(to)}  ${red(`${dur}min`)}`);
+      }
+    }
+    console.log();
+  } catch (err) {
+    console.error(`Error: ${err.message || String(err)}`);
+    process.exitCode = 1;
+  }
+}
+
+// ── Automations command ──────────────────────────────────────────
+
+async function cmdAutomations(args) {
+  const isJson = args.includes("--json");
+  const subCmd = args[0];
+  const subArgs = args.slice(1);
+
+  if (!subCmd || subCmd === "--help" || subCmd === "-h") {
+    console.log(`Usage: clawmatrix automations [subcommand]
+
+Subcommands:
+  rules [--json]              List all automation rules
+  history [--limit <n>] [--json]
+                              Show execution history
+  run <ruleId> [--json]       Manually trigger a rule
+  replay <executionId> [--json]
+                              Re-run a historical execution
+  save <json-file|->          Save rules from JSON file or stdin`);
+    return;
+  }
+
+  try {
+    if (subCmd === "rules" || subCmd === "list") {
+      const data = await callGateway("clawmatrix.automations.rules");
+      if (isJson) { console.log(jsonOut(data)); return; }
+      const rules = data.rules || [];
+      if (rules.length === 0) { console.log("No automation rules configured."); return; }
+
+      if (!isTTY) {
+        for (const r of rules) {
+          const status = r.enabled ? "enabled" : "disabled";
+          const trigger = r.trigger?.type || "unknown";
+          console.log(`${r.id} | ${status} | trigger:${trigger} | ${r.name || "(unnamed)"}`);
+        }
+        return;
+      }
+
+      console.log();
+      console.log(`  ${cyan("◆")}  ${bold("Automation Rules")}  ${dim(`${rules.length} rule(s)`)}`);
+      console.log(`  ${bar}`);
+      for (const r of rules) {
+        const dot = r.enabled ? green("●") : red("○");
+        const trigger = r.trigger?.type || "unknown";
+        console.log(`  ${bar}  ${dot} ${bold(r.id)} ${r.name || dim("(unnamed)")}  ${dim(`trigger: ${trigger}`)}`);
+      }
+      console.log();
+      return;
+    }
+
+    if (subCmd === "history") {
+      const lIdx = subArgs.indexOf("--limit") !== -1 ? subArgs.indexOf("--limit") : subArgs.indexOf("-l");
+      const limit = lIdx !== -1 ? parseInt(subArgs[lIdx + 1], 10) : 20;
+      const data = await callGateway("clawmatrix.automations.history", { limit });
+      if (isJson) { console.log(jsonOut(data)); return; }
+      const executions = data.executions || [];
+      if (executions.length === 0) { console.log("No execution history."); return; }
+
+      if (!isTTY) {
+        for (const ex of executions) {
+          const ts = new Date(ex.startedAt || ex.ts).toISOString();
+          const dur = ex.durationMs ? `${ex.durationMs}ms` : "?";
+          console.log(`${ts} | ${ex.ruleId} | ${ex.status} | ${dur}`);
+        }
+        return;
+      }
+
+      console.log();
+      console.log(`  ${cyan("◆")}  ${bold("Execution History")}  ${dim(`${executions.length} execution(s)`)}`);
+      console.log(`  ${bar}`);
+      for (const ex of executions) {
+        const ts = new Date(ex.startedAt || ex.ts).toLocaleString();
+        const dur = ex.durationMs ? dim(`${ex.durationMs}ms`) : "";
+        const statusColor = ex.status === "success" ? green : ex.status === "error" ? red : yellow;
+        console.log(`  ${bar}  ${statusColor("●")} ${bold(ex.ruleId)}  ${statusColor(ex.status)}  ${dur}  ${dim(ts)}`);
+        if (ex.error) console.log(`  ${bar}    ${red(ex.error)}`);
+      }
+      console.log();
+      return;
+    }
+
+    if (subCmd === "run") {
+      const ruleId = subArgs.filter((a) => !a.startsWith("--"))[0];
+      if (!ruleId) { console.error("Usage: clawmatrix automations run <ruleId>"); process.exit(1); }
+      const data = await callGateway("clawmatrix.automations.run", { ruleId }, 60000);
+      if (isJson) { console.log(jsonOut(data)); return; }
+      const ex = data.execution;
+      const statusColor = ex?.status === "success" ? green : red;
+      console.log(`${statusColor("●")} Rule ${ruleId}: ${statusColor(ex?.status || "unknown")}${ex?.durationMs ? ` (${ex.durationMs}ms)` : ""}`);
+      if (ex?.error) console.log(`  ${red(ex.error)}`);
+      return;
+    }
+
+    if (subCmd === "replay") {
+      const executionId = subArgs.filter((a) => !a.startsWith("--"))[0];
+      if (!executionId) { console.error("Usage: clawmatrix automations replay <executionId>"); process.exit(1); }
+      const data = await callGateway("clawmatrix.automations.replay", { executionId }, 60000);
+      if (isJson) { console.log(jsonOut(data)); return; }
+      console.log(`Replayed: ${executionId} → ${data.execution?.status || "unknown"}`);
+      return;
+    }
+
+    if (subCmd === "save") {
+      let jsonStr = subArgs.filter((a) => !a.startsWith("--"))[0];
+      if (jsonStr === "-" || (!jsonStr && !process.stdin.isTTY)) {
+        const chunks = [];
+        for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+        jsonStr = Buffer.concat(chunks).toString("utf-8").trim();
+      } else if (jsonStr && !jsonStr.startsWith("[")) {
+        // Treat as file path
+        try { jsonStr = readFileSync(resolve(jsonStr), "utf-8"); } catch (e) {
+          console.error(`Error: Could not read file: ${jsonStr}`);
+          process.exit(1);
+        }
+      }
+      if (!jsonStr) { console.error("Usage: clawmatrix automations save <json-file|->"); process.exit(1); }
+      const rules = JSON.parse(jsonStr);
+      const data = await callGateway("clawmatrix.automations.save", { rules });
+      console.log(`Saved ${data.count} rule(s)`);
+      return;
+    }
+
+    console.error(`Unknown automations subcommand: ${subCmd}`);
+    process.exit(1);
+  } catch (err) {
+    console.error(`Error: ${err.message || String(err)}`);
+    process.exitCode = 1;
+  }
+}
+
+// ── Config command ───────────────────────────────────────────────
+
+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");
+    if (isJson) { console.log(jsonOut(data)); return; }
+
+    if (!isTTY) {
+      const parts = [`nodeId: ${data.nodeId}`];
+      parts.push(`listen: ${data.listen !== false ? data.listen : "disabled"}`);
+      parts.push(`e2ee: ${data.e2ee ?? false}`);
+      parts.push(`tags: ${(data.tags || []).join(",") || "none"}`);
+      parts.push(`agents: ${(data.agents || []).map((a) => a.id).join(",") || "none"}`);
+      parts.push(`models: ${(data.models || []).map((m) => m.id).join(",") || "none"}`);
+      parts.push(`toolProxy: ${data.toolProxy?.enabled ? "enabled" : "disabled"}`);
+      parts.push(`terminal: ${data.terminal?.enabled ? "enabled" : "disabled"}`);
+      parts.push(`acp: ${data.acp?.enabled ? "enabled" : "disabled"}`);
+      parts.push(`knowledge: ${data.knowledge?.enabled ? "enabled" : "disabled"}`);
+      parts.push(`proxyModels: ${data.proxyModels}`);
+      parts.push(`peers: ${data.peers}`);
+      console.log(parts.join(" | "));
+      return;
+    }
+
+    console.log();
+    console.log(`  ${cyan("◆")}  ${bold("ClawMatrix Config")}`);
+    console.log(`  ${bar}`);
+    console.log(`  ${bar}  ${lbl("Node ID")}${bold(String(data.nodeId))}`);
+    console.log(`  ${bar}  ${lbl("Listen")}${data.listen !== false ? `:${data.listen}` : dim("disabled")}`);
+    console.log(`  ${bar}  ${lbl("E2EE")}${data.e2ee ? green("enabled") : dim("disabled")}`);
+    console.log(`  ${bar}  ${lbl("Tags")}${(data.tags || []).join(dim(", ")) || dim("none")}`);
+    console.log(`  ${bar}`);
+    console.log(`  ${bar}  ${bold("Agents")}`);
+    for (const a of (data.agents || [])) {
+      console.log(`  ${bar}    ${green("●")} ${a.id}  ${dim(a.model || "")}`);
+    }
+    if ((data.agents || []).length === 0) console.log(`  ${bar}    ${dim("none")}`);
+    console.log(`  ${bar}`);
+    console.log(`  ${bar}  ${bold("Models")}`);
+    for (const m of (data.models || [])) {
+      console.log(`  ${bar}    ${green("●")} ${m.id}  ${dim(m.provider || "")}`);
+    }
+    if ((data.models || []).length === 0) console.log(`  ${bar}    ${dim("none")}`);
+    console.log(`  ${bar}`);
+    console.log(`  ${bar}  ${bold("Features")}`);
+    const feat = (name, enabled) => `  ${bar}    ${enabled ? green("●") : red("○")} ${name}`;
+    console.log(feat("Tool Proxy", data.toolProxy?.enabled));
+    if (data.toolProxy?.enabled) {
+      const allow = data.toolProxy.allow?.join(", ") || "*";
+      const deny = data.toolProxy.deny?.length > 0 ? `, deny: ${data.toolProxy.deny.join(", ")}` : "";
+      console.log(`  ${bar}      ${dim(`allow: ${allow}${deny}`)}`);
+    }
+    console.log(feat("Terminal", data.terminal?.enabled));
+    console.log(feat("ACP", data.acp?.enabled));
+    console.log(feat("Knowledge Sync", data.knowledge?.enabled));
+    console.log(`  ${bar}`);
+    console.log(`  ${bar}  ${lbl("Proxy Models")}${data.proxyModels}`);
+    console.log(`  ${bar}  ${lbl("Peers")}${data.peers}`);
+    console.log();
+  } catch (err) {
+    console.error(`Error: ${err.message || String(err)}`);
+    process.exitCode = 1;
+  }
+}
+
+// ── Events ingest subcommand ─────────────────────────────────────
+
+async function cmdEventsIngest(args) {
+  let jsonStr = args.find((a) => a.startsWith("[") || a.startsWith("{"));
+  if (!jsonStr && !process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+    jsonStr = Buffer.concat(chunks).toString("utf-8").trim();
+  }
+  if (!jsonStr) {
+    console.error('Usage: clawmatrix events ingest \'[{"type":"x","source":"y","data":{}}]\' or pipe via stdin');
+    process.exit(1);
+  }
+  try {
+    const raw = JSON.parse(jsonStr);
+    const events = Array.isArray(raw) ? raw : [raw];
+    const result = await callGateway("clawmatrix.events.ingest", { events });
+    console.log(jsonOut(result));
+  } catch (err) {
+    console.error(`Error: ${err.message || String(err)}`);
+    process.exitCode = 1;
+  }
+}
+
 const HELP = `ClawMatrix - Decentralized mesh cluster CLI
 
 Usage: clawmatrix <command> [options]
 
-Commands:
+Cluster:
   status                  Show cluster topology and peer status
+  peers                   List known peers (JSON)
   check <nodeId>          Check if a specific node is reachable
+  config [subcmd]         Node config (read|write or show summary)
+  availability [range]    Show node uptime (24h|7d|90d)
+
+Tools & Execution:
   tools [node]            List available tools on remote nodes
   call <node> <tool> [p]  Invoke a tool on a remote node
   batch <node> [json]     Invoke multiple tools in sequence
   models                  List all models available across the cluster
-  events                  Query and consume ingested events
+
+Agents:
   send <node> <message>   Send a message to a remote node
   handoff <task> [opts]   Delegate a task to a remote agent
-  acp <action> [opts]     Manage ACP agent sessions (list|prompt|resume|cancel|close)
+  acp <action> [opts]     ACP sessions (list|prompt|resume|cancel|close)
+
+Events & Automations:
+  events                  Query, consume, or ingest events
+  automations [subcmd]    Manage automation rules (rules|history|run|replay|save)
+
+Infrastructure:
   diagnostic <node>       Diagnose a remote node via sentinel
-  notify <title> [opts]   Push notification to mobile devices (Dynamic Island)
+  notify <title> [opts]   Push notification to mobile (Dynamic Island)
   terminal <node>         Open/manage remote terminal sessions
   transfer <node> <path>  Transfer files to/from a remote node
+
+Knowledge & Kanban:
+  kb [subcommand]         Knowledge sync (files|history|blame)
+  board [subcommand]      Kanban board (list|create|get|update|claim|move|annotate|delete)
+
+Access Control:
   approve <approvalId>    Approve a pending peer join request
   deny <approvalId>       Deny a pending peer join request
-  kb [subcommand]         Knowledge sync (files|history)
-  board [subcommand]      Kanban board (list|create|get|claim|move|annotate|delete)
   approval list|revoke    Manage approved peers
+
+Other:
   install-skill           Symlink skill into ~/.claude/skills/
   help-json               Structured command reference (JSON)
 
 Options:
   --help, -h              Show this help message
+  --json                  Output as JSON (most commands)
 
 Run 'clawmatrix <command> --help' for command-specific options.`;
 
@@ -1273,7 +1742,10 @@ try {
     case "call":          await cmdCall(rest[0], rest[1], rest[2], rest); break;
     case "batch":         await cmdBatch(rest[0], rest.find((a) => a.startsWith("[") || a.startsWith("{")), rest); break;
     case "models":        await cmdModels(rest); break;
-    case "events":        await cmdEvents(rest); break;
+    case "events":
+      if (rest[0] === "ingest") await cmdEventsIngest(rest.slice(1));
+      else await cmdEvents(rest);
+      break;
     case "send":          await cmdSend(rest[0], rest.slice(1).join(" ")); break;
     case "handoff":       await cmdHandoff(rest); break;
     case "acp":           await cmdAcp(rest[0], rest.slice(1)); break;
@@ -1283,6 +1755,9 @@ try {
     case "transfer":      await cmdTransfer(rest[0], rest[1], rest.slice(2)); break;
     case "kb": case "knowledge": await cmdKb(rest); break;
     case "board":          await cmdBoard(rest); break;
+    case "availability":  await cmdAvailability(rest); break;
+    case "automations": case "automation": await cmdAutomations(rest); break;
+    case "config":        await cmdConfig(rest); break;
     case "approve":       await cmdApprove(rest[0]); break;
     case "deny":          await cmdDeny(rest[0]); break;
     case "approval":