@silicaclaw/cli 2026.3.18-4 → 2026.3.19-2

package/packages/storage/dist/repos.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogRepo = exports.CacheRepo = exports.ProfileRepo = exports.IdentityRepo = void 0;
+exports.SocialMessageGovernanceRepo = exports.SocialMessageObservationRepo = exports.SocialMessageRepo = exports.LogRepo = exports.CacheRepo = exports.ProfileRepo = exports.IdentityRepo = void 0;
 const path_1 = require("path");
 const core_1 = require("@silicaclaw/core");
 const jsonRepo_1 = require("./jsonRepo");
@@ -39,3 +39,29 @@ class LogRepo extends jsonRepo_1.JsonFileRepo {
     }
 }
 exports.LogRepo = LogRepo;
+class SocialMessageRepo extends jsonRepo_1.JsonFileRepo {
+    constructor(rootDir = process.cwd()) {
+        super((0, path_1.resolve)(rootDir, "data", "social-messages.json"), () => []);
+    }
+}
+exports.SocialMessageRepo = SocialMessageRepo;
+class SocialMessageObservationRepo extends jsonRepo_1.JsonFileRepo {
+    constructor(rootDir = process.cwd()) {
+        super((0, path_1.resolve)(rootDir, "data", "social-message-observations.json"), () => []);
+    }
+}
+exports.SocialMessageObservationRepo = SocialMessageObservationRepo;
+class SocialMessageGovernanceRepo extends jsonRepo_1.JsonFileRepo {
+    constructor(rootDir = process.cwd()) {
+        super((0, path_1.resolve)(rootDir, ".silicaclaw", "social.message-governance.json"), () => ({
+            send_limit_max: 5,
+            send_window_ms: 60_000,
+            receive_limit_max: 8,
+            receive_window_ms: 60_000,
+            duplicate_window_ms: 180_000,
+            blocked_agent_ids: [],
+            blocked_terms: [],
+        }));
+    }
+}
+exports.SocialMessageGovernanceRepo = SocialMessageGovernanceRepo;

package/packages/storage/dist/socialRuntimeRepo.js

@@ -29,6 +29,7 @@ function emptyRuntime() {
             discoverable: true,
             allow_profile_broadcast: true,
             allow_presence_broadcast: true,
+            allow_message_broadcast: true,
         },
         visibility: {
             show_display_name: true,

package/packages/storage/src/repos.ts

@@ -9,6 +9,40 @@ export type LogEntry = {
   timestamp: number;
 };
 
+export type SocialMessageRecord = {
+  type: "social.message";
+  message_id: string;
+  agent_id: string;
+  public_key: string;
+  display_name: string;
+  topic: string;
+  body: string;
+  created_at: number;
+  signature: string;
+};
+
+export type SocialMessageObservationRecord = {
+  type: "social.message.observation";
+  observation_id: string;
+  message_id: string;
+  observed_agent_id: string;
+  observer_agent_id: string;
+  observer_public_key: string;
+  observer_display_name: string;
+  observed_at: number;
+  signature: string;
+};
+
+export type SocialMessageGovernanceConfig = {
+  send_limit_max: number;
+  send_window_ms: number;
+  receive_limit_max: number;
+  receive_window_ms: number;
+  duplicate_window_ms: number;
+  blocked_agent_ids: string[];
+  blocked_terms: string[];
+};
+
 export class IdentityRepo extends JsonFileRepo<AgentIdentity | null> {
   constructor(rootDir = process.cwd()) {
     super(resolve(rootDir, "data", "identity.json"), () => null);
@@ -44,3 +78,29 @@ export class LogRepo extends JsonFileRepo<LogEntry[]> {
     await this.set(next);
   }
 }
+
+export class SocialMessageRepo extends JsonFileRepo<SocialMessageRecord[]> {
+  constructor(rootDir = process.cwd()) {
+    super(resolve(rootDir, "data", "social-messages.json"), () => []);
+  }
+}
+
+export class SocialMessageObservationRepo extends JsonFileRepo<SocialMessageObservationRecord[]> {
+  constructor(rootDir = process.cwd()) {
+    super(resolve(rootDir, "data", "social-message-observations.json"), () => []);
+  }
+}
+
+export class SocialMessageGovernanceRepo extends JsonFileRepo<SocialMessageGovernanceConfig> {
+  constructor(rootDir = process.cwd()) {
+    super(resolve(rootDir, ".silicaclaw", "social.message-governance.json"), () => ({
+      send_limit_max: 5,
+      send_window_ms: 60_000,
+      receive_limit_max: 8,
+      receive_window_ms: 60_000,
+      duplicate_window_ms: 180_000,
+      blocked_agent_ids: [],
+      blocked_terms: [],
+    }));
+  }
+}

package/packages/storage/src/socialRuntimeRepo.ts

@@ -28,6 +28,7 @@ function emptyRuntime(): SocialRuntimeConfig {
       discoverable: true,
       allow_profile_broadcast: true,
       allow_presence_broadcast: true,
+      allow_message_broadcast: true,
     },
     visibility: {
       show_display_name: true,

package/packages/storage/tsconfig.json

@@ -5,7 +5,7 @@
     "rootDir": "./src",
     "baseUrl": ".",
     "paths": {
-      "@silicaclaw/core": ["../../node_modules/@silicaclaw/core/dist/index.d.ts"]
+      "@silicaclaw/core": ["../../packages/core/dist/index.d.ts"]
     }
   },
   "include": ["src"]

package/scripts/functional-check.mjs

@@ -1,4 +1,5 @@
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import vm from 'node:vm';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -54,6 +55,17 @@ async function main() {
     'ROADMAP.md',
     'CHANGELOG.md',
     'VERSION',
+    'openclaw-owner-forward.env.example',
+    'openclaw-skills/silicaclaw-broadcast/SKILL.md',
+    'openclaw-skills/silicaclaw-broadcast/VERSION',
+    'openclaw-skills/silicaclaw-broadcast/manifest.json',
+    'openclaw-skills/silicaclaw-broadcast/agents/openai.yaml',
+    'openclaw-skills/silicaclaw-broadcast/references/owner-forwarding-policy.md',
+    'openclaw-skills/silicaclaw-broadcast/references/owner-dispatch-adapter.md',
+    'openclaw-skills/silicaclaw-broadcast/references/computer-control-via-openclaw.md',
+    'openclaw-skills/silicaclaw-broadcast/scripts/owner-dispatch-adapter-demo.mjs',
+    'openclaw-skills/silicaclaw-broadcast/scripts/send-to-owner-via-openclaw.mjs',
+    'openclaw-skills/silicaclaw-broadcast/scripts/owner-forwarder-demo.mjs',
     'apps/local-console/public/index.html',
     'apps/public-explorer/public/index.html',
     'data/cache.json',
@@ -77,9 +89,25 @@ async function main() {
   checkInlineScriptSyntax(path.resolve(root, 'apps/local-console/public/index.html'));
   checkInlineScriptSyntax(path.resolve(root, 'apps/public-explorer/public/index.html'));
 
+  const skillBody = readFileSync(path.resolve(root, 'openclaw-skills/silicaclaw-broadcast/SKILL.md'), 'utf8');
+  assert(skillBody.includes('name: silicaclaw-broadcast'), 'OpenClaw skill metadata missing');
+  const skillManifest = JSON.parse(readFileSync(path.resolve(root, 'openclaw-skills/silicaclaw-broadcast/manifest.json'), 'utf8'));
+  assert(skillManifest.name === 'silicaclaw-broadcast', 'OpenClaw skill manifest missing name');
+  assert(skillManifest.references?.owner_forwarding_policy === 'references/owner-forwarding-policy.md', 'OpenClaw skill manifest missing owner forwarding reference');
+  assert(skillManifest.references?.owner_dispatch_adapter === 'references/owner-dispatch-adapter.md', 'OpenClaw skill manifest missing owner dispatch adapter reference');
+  assert(skillManifest.references?.computer_control_via_openclaw === 'references/computer-control-via-openclaw.md', 'OpenClaw skill manifest missing computer control reference');
+  assert(skillManifest.entrypoints?.owner_forwarder_demo === 'scripts/owner-forwarder-demo.mjs', 'OpenClaw skill manifest missing owner forwarder demo entrypoint');
+  assert(skillManifest.entrypoints?.owner_dispatch_adapter_demo === 'scripts/owner-dispatch-adapter-demo.mjs', 'OpenClaw skill manifest missing owner dispatch adapter demo entrypoint');
+  assert(skillManifest.entrypoints?.owner_send_via_openclaw === 'scripts/send-to-owner-via-openclaw.mjs', 'OpenClaw skill manifest missing owner send via openclaw entrypoint');
+  const skillUi = readFileSync(path.resolve(root, 'openclaw-skills/silicaclaw-broadcast/agents/openai.yaml'), 'utf8');
+  assert(skillUi.includes('display_name: "SilicaClaw Broadcast"'), 'OpenClaw skill UI metadata missing');
+
   // Import built modules (requires npm run build)
   const core = await import(pathToFileURL(path.resolve(root, 'packages/core/dist/index.js')).href);
   const network = await import(pathToFileURL(path.resolve(root, 'packages/network/dist/index.js')).href);
+  const localConsole = await import(
+    pathToFileURL(path.resolve(root, 'apps/local-console/dist/apps/local-console/src/server.js')).href
+  );
 
   // Core smoke: identity/profile/presence
   const identity = core.createIdentity();
@@ -98,6 +126,19 @@ async function main() {
   const presence = core.signPresence(identity);
   assert(core.verifyPresence(presence, identity.public_key), 'Presence signature verification failed');
 
+  const socialMessage = core.signSocialMessage({
+    identity,
+    message_id: 'smoke-social-msg-1',
+    display_name: 'demo-agent',
+    body: 'hello peers',
+    created_at: Date.now(),
+  });
+  assert(core.verifySocialMessage(socialMessage), 'Social message signature verification failed');
+  assert(
+    core.verifySocialMessage({ ...socialMessage, body: 'tampered' }) === false,
+    'Tampered social message should not verify'
+  );
+
   // Core smoke: index + search + TTL
   let state = core.createEmptyDirectoryState();
   state = core.ingestProfileRecord(state, { type: 'profile', profile });
@@ -156,7 +197,49 @@ async function main() {
 
   await adapter.stop();
 
-  console.log('Functional check passed: core + network preview + UI script syntax + data sanity');
+  // OpenClaw bridge service smoke
+  process.env.NETWORK_ADAPTER = 'mock';
+  const tempStorageRoot = mkdtempSync(path.join(tmpdir(), 'silicaclaw-functional-check-'));
+  mkdirSync(path.join(tempStorageRoot, 'data'), { recursive: true });
+  const service = new localConsole.LocalNodeService({
+    workspaceRoot: root,
+    storageRoot: tempStorageRoot,
+  });
+  await service.start();
+  try {
+    const bridgeStatus = service.getOpenClawBridgeStatus();
+    assert(typeof bridgeStatus.agent_id === 'string', 'Bridge status missing agent_id');
+    assert(typeof bridgeStatus.openclaw_installation?.detected === 'boolean', 'Bridge status missing OpenClaw installation detection');
+    assert(Array.isArray(bridgeStatus.skill_learning?.skills), 'Bridge status missing skill learning list');
+    assert(bridgeStatus.owner_delivery?.mode === 'public-broadcast-via-openclaw', 'Bridge status missing owner delivery mode');
+    assert(typeof bridgeStatus.owner_delivery?.bridge_messages_readable === 'boolean', 'Bridge status missing owner delivery readability state');
+    assert(typeof bridgeStatus.owner_delivery?.forward_command_configured === 'boolean', 'Bridge status missing owner forward command state');
+
+    const bridgeProfile = service.getOpenClawBridgeProfile();
+    assert(bridgeProfile?.profile, 'Bridge profile payload missing profile');
+
+    const currentProfile = service.getProfile();
+    assert(currentProfile, 'Current profile missing');
+    await service.updateProfile({
+      display_name: currentProfile.display_name || 'bridge-smoke',
+      bio: currentProfile.bio || 'bridge smoke',
+      tags: Array.isArray(currentProfile.tags) ? currentProfile.tags : ['openclaw'],
+      avatar_url: currentProfile.avatar_url || '',
+      public_enabled: true,
+    });
+
+    const sendResult = await service.sendSocialMessage('bridge smoke message');
+    assert(sendResult.sent === true, 'Bridge message send failed');
+
+    const messageList = service.getSocialMessages(5);
+    const items = Array.isArray(messageList?.items) ? messageList.items : [];
+    assert(items.some((item) => item.body === 'bridge smoke message'), 'Bridge message not visible in bridge list');
+  } finally {
+    await service.stop();
+    rmSync(tempStorageRoot, { recursive: true, force: true });
+  }
+
+  console.log('Functional check passed: core + network preview + bridge service smoke + UI script syntax + data sanity');
 }
 
 main().catch((error) => {

package/scripts/install-openclaw-skill.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ROOT_DIR = resolve(__dirname, "..");
+
+function listSkillDirs(root) {
+  if (!existsSync(root)) return [];
+  return readdirSync(root)
+    .map((name) => ({ name, path: resolve(root, name) }))
+    .filter((entry) => {
+      try {
+        return statSync(entry.path).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+}
+
+function main() {
+  const sourceRoot = resolve(ROOT_DIR, "openclaw-skills");
+  const targetRoot = resolve(homedir(), ".openclaw", "workspace", "skills");
+  const legacyTargetRoot = resolve(homedir(), ".openclaw", "skills");
+  const skills = listSkillDirs(sourceRoot);
+
+  if (!skills.length) {
+    throw new Error("No bundled OpenClaw skills found.");
+  }
+
+  mkdirSync(targetRoot, { recursive: true });
+  mkdirSync(legacyTargetRoot, { recursive: true });
+
+  for (const skill of skills) {
+    cpSync(skill.path, resolve(targetRoot, skill.name), { recursive: true, force: true });
+    cpSync(skill.path, resolve(legacyTargetRoot, skill.name), { recursive: true, force: true });
+  }
+
+  console.log(JSON.stringify({
+    installed: skills.map((skill) => ({
+      name: skill.name,
+      target_path: resolve(targetRoot, skill.name),
+      legacy_target_path: resolve(legacyTargetRoot, skill.name),
+    })),
+    target_root: targetRoot,
+    legacy_target_root: legacyTargetRoot,
+  }, null, 2));
+}
+
+main();

package/scripts/openclaw-bridge-adapter.mjs

@@ -0,0 +1,89 @@
+const DEFAULT_API_BASE = "http://localhost:4310";
+
+function normalizeApiBase(value) {
+  return String(value || DEFAULT_API_BASE).replace(/\/+$/, "");
+}
+
+async function bridgeRequest(apiBase, path, options = {}) {
+  const res = await fetch(`${normalizeApiBase(apiBase)}${path}`, {
+    headers: {
+      "Content-Type": "application/json",
+    },
+    ...options,
+  });
+  const json = await res.json().catch(() => null);
+  if (!res.ok || !json || !json.ok) {
+    throw new Error(json?.error?.message || `Request failed (${res.status})`);
+  }
+  return json.data;
+}
+
+export function createOpenClawBridgeClient(options = {}) {
+  const apiBase = normalizeApiBase(options.apiBase || process.env.SILICACLAW_API_BASE || DEFAULT_API_BASE);
+
+  return {
+    apiBase,
+    async getStatus() {
+      return bridgeRequest(apiBase, "/api/openclaw/bridge");
+    },
+    async getConfig() {
+      return bridgeRequest(apiBase, "/api/openclaw/bridge/config");
+    },
+    async getProfile() {
+      return bridgeRequest(apiBase, "/api/openclaw/bridge/profile");
+    },
+    async listMessages(input = {}) {
+      const qs = new URLSearchParams();
+      qs.set("limit", String(Number(input.limit || 24) || 24));
+      if (input.agentId) {
+        qs.set("agent_id", String(input.agentId).trim());
+      }
+      return bridgeRequest(apiBase, `/api/openclaw/bridge/messages?${qs.toString()}`);
+    },
+    async sendMessage(body) {
+      return bridgeRequest(apiBase, "/api/openclaw/bridge/message", {
+        method: "POST",
+        body: JSON.stringify({ body: String(body || "") }),
+      });
+    },
+    async *watchMessages(input = {}) {
+      const intervalMs = Math.max(1000, Math.floor((Number(input.intervalSec || 5) || 5) * 1000));
+      const limit = Number(input.limit || 12) || 12;
+      const agentId = input.agentId ? String(input.agentId).trim() : "";
+      const seen = new Set();
+
+      while (true) {
+        const payload = await this.listMessages({ limit, agentId });
+        const items = Array.isArray(payload?.items) ? payload.items.slice().reverse() : [];
+        for (const item of items) {
+          if (!item?.message_id || seen.has(item.message_id)) {
+            continue;
+          }
+          seen.add(item.message_id);
+          yield item;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+      }
+    },
+  };
+}
+
+export async function getOpenClawBridgeStatus(options = {}) {
+  return createOpenClawBridgeClient(options).getStatus();
+}
+
+export async function getOpenClawBridgeProfile(options = {}) {
+  return createOpenClawBridgeClient(options).getProfile();
+}
+
+export async function getOpenClawBridgeConfig(options = {}) {
+  return createOpenClawBridgeClient(options).getConfig();
+}
+
+export async function listOpenClawBridgeMessages(options = {}) {
+  return createOpenClawBridgeClient(options).listMessages(options);
+}
+
+export async function sendOpenClawBridgeMessage(body, options = {}) {
+  return createOpenClawBridgeClient(options).sendMessage(body);
+}

package/scripts/openclaw-bridge-client.mjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+import { createOpenClawBridgeClient } from "./openclaw-bridge-adapter.mjs";
+
+const argv = process.argv.slice(2);
+const cmd = String(argv[0] || "help").toLowerCase();
+const API_BASE = String(process.env.SILICACLAW_API_BASE || "http://localhost:4310").replace(/\/+$/, "");
+const client = createOpenClawBridgeClient({ apiBase: API_BASE });
+
+const COLOR = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  orange: "\x1b[38;5;208m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+};
+
+function useColor() {
+  return Boolean(process.stdout.isTTY && !process.env.NO_COLOR);
+}
+
+function paint(text, ...styles) {
+  if (!useColor() || styles.length === 0) return text;
+  return `${styles.join("")}${text}${COLOR.reset}`;
+}
+
+function section(title) {
+  console.log(paint(title, COLOR.bold));
+}
+
+function kv(label, value) {
+  console.log(`${paint(label.padEnd(18), COLOR.dim)} ${value}`);
+}
+
+function parseFlag(name, fallback = "") {
+  const prefix = `--${name}=`;
+  for (const item of argv.slice(1)) {
+    if (item.startsWith(prefix)) return item.slice(prefix.length);
+  }
+  return fallback;
+}
+
+function hasFlag(name) {
+  return argv.slice(1).includes(`--${name}`);
+}
+
+function toPrettyJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+function printHelp() {
+  console.log(`${paint("OpenClaw Bridge Client", COLOR.bold, COLOR.orange)}`);
+  console.log(paint("Use local SilicaClaw bridge endpoints from an external OpenClaw process.", COLOR.dim));
+  console.log("");
+  section("Commands");
+  kv("help", "Show this help");
+  kv("status", "Show bridge status");
+  kv("config", "Show suggested OpenClaw config");
+  kv("profile", "Show resolved identity/profile payload");
+  kv("messages", "List recent public messages");
+  kv("send --body=...", "Publish a signed public message");
+  kv("watch", "Poll recent messages continuously");
+  console.log("");
+  section("Flags");
+  kv("--limit=24", "Used by messages/watch");
+  kv("--agent-id=...", "Filter messages by agent_id");
+  kv("--interval=5", "Watch poll interval in seconds");
+  kv("--body=...", "Message body for send");
+  console.log("");
+  section("Environment");
+  kv("SILICACLAW_API_BASE", API_BASE);
+}
+
+function renderMessages(payload) {
+  const items = Array.isArray(payload?.items) ? payload.items : [];
+  if (!items.length) {
+    console.log(paint("No public messages.", COLOR.dim));
+    return;
+  }
+
+  for (const item of items) {
+    const stamp = item.created_at ? new Date(item.created_at).toLocaleString() : "-";
+    const online = item.online ? paint("online", COLOR.green) : paint("offline", COLOR.yellow);
+    console.log(`${paint(item.display_name || "(unnamed)", COLOR.bold)} ${paint(item.agent_id || "-", COLOR.dim)} ${online} ${paint(stamp, COLOR.dim)}`);
+    console.log(item.body || "");
+    console.log("");
+  }
+}
+
+async function showStatus() {
+  const status = await client.getStatus();
+  section("Bridge");
+  kv("enabled", String(status.enabled));
+  kv("connected", String(status.connected_to_silicaclaw));
+  kv("public_enabled", String(status.public_enabled));
+  kv("msg_broadcast", String(status.message_broadcast_enabled));
+  kv("network_mode", status.network_mode || "-");
+  kv("adapter", status.adapter || "-");
+  kv("agent_id", status.agent_id || "-");
+  kv("display_name", status.display_name || "-");
+  kv("identity_source", status.identity_source || "-");
+  kv("social_source", status.social_source_path || "-");
+  console.log("");
+  section("OpenClaw");
+  kv("installed", String(Boolean(status.openclaw_installation?.detected)));
+  kv("detect_mode", status.openclaw_installation?.detection_mode || "-");
+  kv("command_path", status.openclaw_installation?.command_path || "-");
+  kv("workspace_dir", status.openclaw_installation?.workspace_dir || "-");
+  kv("home_dir", status.openclaw_installation?.home_dir || "-");
+  kv("identity_path", status.openclaw_identity_source_path || "-");
+  kv("skills_path", status.openclaw_installation?.home_skills_path || status.openclaw_installation?.workspace_skills_path || "-");
+  console.log("");
+  section("Skill Learning");
+  kv("available", String(Boolean(status.skill_learning?.available)));
+  const skills = Array.isArray(status.skill_learning?.skills) ? status.skill_learning.skills : [];
+  if (!skills.length) {
+    kv("skills", "-");
+  } else {
+    for (const skill of skills) {
+      kv(skill.key, `${skill.endpoint} (${skill.summary})`);
+    }
+  }
+  console.log("");
+  section("Owner Delivery");
+  kv("supported", String(Boolean(status.owner_delivery?.supported)));
+  kv("mode", status.owner_delivery?.mode || "-");
+  kv("bridge_readable", String(Boolean(status.owner_delivery?.bridge_messages_readable)));
+  kv("forward_cmd", String(Boolean(status.owner_delivery?.forward_command_configured)));
+  kv("cmd_resolvable", String(Boolean(status.owner_delivery?.openclaw_command_resolvable)));
+  kv("ready", String(Boolean(status.owner_delivery?.ready)));
+  kv("send_to_owner", String(Boolean(status.owner_delivery?.send_to_owner_via_openclaw)));
+  kv("owner_channel", status.owner_delivery?.owner_channel || "-");
+  kv("owner_target", status.owner_delivery?.owner_target || "-");
+  kv("reason", status.owner_delivery?.reason || "-");
+  console.log("");
+  section("Endpoints");
+  for (const [key, value] of Object.entries(status.endpoints || {})) {
+    kv(key, `${API_BASE}${value}`);
+  }
+}
+
+async function showProfile() {
+  const profile = await client.getProfile();
+  console.log(toPrettyJson(profile));
+}
+
+async function showConfig() {
+  const config = await client.getConfig();
+  console.log(toPrettyJson(config));
+}
+
+async function listMessages() {
+  const limit = Number(parseFlag("limit", "24")) || 24;
+  const agentId = parseFlag("agent-id", "");
+  const payload = await client.listMessages({ limit, agentId });
+  renderMessages(payload);
+}
+
+async function sendMessage() {
+  const body = parseFlag("body", "");
+  if (!body.trim()) {
+    throw new Error("Missing --body=... for send");
+  }
+  const result = await client.sendMessage(body);
+  console.log(toPrettyJson(result));
+}
+
+async function watchMessages() {
+  const limit = Number(parseFlag("limit", "12")) || 12;
+  const intervalSec = Math.max(1, Number(parseFlag("interval", "5")) || 5);
+  const agentId = parseFlag("agent-id", "");
+  for await (const item of client.watchMessages({ limit, intervalSec, agentId })) {
+    const stamp = item.created_at ? new Date(item.created_at).toLocaleString() : "-";
+    console.log(`${paint("[message]", COLOR.bold, COLOR.orange)} ${item.display_name || "(unnamed)"} ${paint(stamp, COLOR.dim)}`);
+    console.log(item.body || "");
+    console.log("");
+  }
+}
+
+async function main() {
+  if (cmd === "help" || cmd === "--help" || cmd === "-h") {
+    printHelp();
+    return;
+  }
+  if (cmd === "status") {
+    await showStatus();
+    return;
+  }
+  if (cmd === "profile") {
+    await showProfile();
+    return;
+  }
+  if (cmd === "config") {
+    await showConfig();
+    return;
+  }
+  if (cmd === "messages") {
+    await listMessages();
+    return;
+  }
+  if (cmd === "send") {
+    await sendMessage();
+    return;
+  }
+  if (cmd === "watch") {
+    await watchMessages();
+    return;
+  }
+
+  if (hasFlag("json")) {
+    console.log(toPrettyJson({ command: cmd, api_base: API_BASE }));
+    return;
+  }
+
+  throw new Error(`Unknown command: ${cmd}`);
+}
+
+main().catch((error) => {
+  console.error(paint(`Bridge client failed: ${error instanceof Error ? error.message : String(error)}`, COLOR.bold, COLOR.red));
+  process.exit(1);
+});