@silicaclaw/cli 2026.3.18-4 → 2026.3.19-2

package/apps/local-console/src/server.ts

@@ -1,9 +1,11 @@
 import express, { NextFunction, Request, Response } from "express";
 import cors from "cors";
+import { execFile, spawnSync } from "child_process";
 import { resolve } from "path";
-import { copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { accessSync, constants, copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
 import { createHash } from "crypto";
 import { hostname } from "os";
+import { promisify } from "util";
 import {
   AgentIdentity,
   DirectoryState,
@@ -30,11 +32,17 @@ import {
   resolveIdentityWithSocial,
   resolveProfileInputWithSocial,
   searchDirectory,
+  signSocialMessage,
+  signSocialMessageObservation,
   signPresence,
   signProfile,
   SocialConfig,
+  SocialMessageObservationRecord,
+  SocialMessageRecord,
   SocialRuntimeConfig,
   generateSocialMdTemplate,
+  verifySocialMessage,
+  verifySocialMessageObservation,
   verifyPresence,
   verifyProfile,
 } from "@silicaclaw/core";
@@ -48,7 +56,17 @@ import {
   UdpLanBroadcastTransport,
   WebRTCPreviewAdapter,
 } from "@silicaclaw/network";
-import { CacheRepo, IdentityRepo, LogRepo, ProfileRepo, SocialRuntimeRepo } from "@silicaclaw/storage";
+import {
+  CacheRepo,
+  IdentityRepo,
+  LogRepo,
+  ProfileRepo,
+  SocialMessageGovernanceConfig,
+  SocialMessageGovernanceRepo,
+  SocialMessageRepo,
+  SocialMessageObservationRepo,
+  SocialRuntimeRepo,
+} from "@silicaclaw/storage";
 import { registerSocialRoutes } from "./socialRoutes";
 
 const BROADCAST_INTERVAL_MS = Number(process.env.BROADCAST_INTERVAL_MS || 20_000);
@@ -71,6 +89,27 @@ const WEBRTC_ROOM = process.env.WEBRTC_ROOM || "silicaclaw-global-preview";
 const WEBRTC_SEED_PEERS = process.env.WEBRTC_SEED_PEERS || "";
 const WEBRTC_BOOTSTRAP_HINTS = process.env.WEBRTC_BOOTSTRAP_HINTS || "";
 const PROFILE_VERSION = "v0.9";
+const SOCIAL_MESSAGE_TOPIC = "social.message";
+const SOCIAL_MESSAGE_OBSERVATION_TOPIC = "social.message.observation";
+const DEFAULT_SOCIAL_MESSAGE_CHANNEL = "global";
+const SOCIAL_MESSAGE_MAX_BODY_CHARS = Number(process.env.SOCIAL_MESSAGE_MAX_BODY_CHARS || 500);
+const SOCIAL_MESSAGE_HISTORY_LIMIT = Number(process.env.SOCIAL_MESSAGE_HISTORY_LIMIT || 100);
+const SOCIAL_MESSAGE_SEND_WINDOW_MS = Number(process.env.SOCIAL_MESSAGE_SEND_WINDOW_MS || 60_000);
+const SOCIAL_MESSAGE_SEND_MAX_PER_WINDOW = Number(process.env.SOCIAL_MESSAGE_SEND_MAX_PER_WINDOW || 5);
+const SOCIAL_MESSAGE_RECEIVE_WINDOW_MS = Number(process.env.SOCIAL_MESSAGE_RECEIVE_WINDOW_MS || 60_000);
+const SOCIAL_MESSAGE_RECEIVE_MAX_PER_WINDOW = Number(process.env.SOCIAL_MESSAGE_RECEIVE_MAX_PER_WINDOW || 8);
+const SOCIAL_MESSAGE_DUPLICATE_WINDOW_MS = Number(process.env.SOCIAL_MESSAGE_DUPLICATE_WINDOW_MS || 180_000);
+const SOCIAL_MESSAGE_MAX_FUTURE_MS = Number(process.env.SOCIAL_MESSAGE_MAX_FUTURE_MS || 30_000);
+const SOCIAL_MESSAGE_MAX_AGE_MS = Number(process.env.SOCIAL_MESSAGE_MAX_AGE_MS || 15 * 60_000);
+const SOCIAL_MESSAGE_OBSERVATION_HISTORY_LIMIT = Number(process.env.SOCIAL_MESSAGE_OBSERVATION_HISTORY_LIMIT || 500);
+const SOCIAL_MESSAGE_BLOCKED_AGENT_IDS = new Set(
+  dedupeStrings(parseListEnv(process.env.SOCIAL_MESSAGE_BLOCKED_AGENT_IDS || ""))
+);
+const SOCIAL_MESSAGE_BLOCKED_TERMS = dedupeStrings(parseListEnv(process.env.SOCIAL_MESSAGE_BLOCKED_TERMS || ""))
+  .map((term) => term.trim().toLowerCase())
+  .filter(Boolean);
+const execFileAsync = promisify(execFile);
+const OPENCLAW_SKILL_NAME = "silicaclaw-broadcast";
 
 function readWorkspaceVersion(workspaceRoot: string): string {
   const pkgFile = resolve(workspaceRoot, "package.json");
@@ -109,6 +148,193 @@ function resolveStorageRoot(workspaceRoot: string, cwd = process.cwd()): string
   return cwd;
 }
 
+function resolveExecutableInPath(binName: string): string | null {
+  const pathValue = String(process.env.PATH || "").trim();
+  if (!pathValue) return null;
+  const pathEntries = pathValue.split(":").map((item) => item.trim()).filter(Boolean);
+  for (const entry of pathEntries) {
+    const candidate = resolve(entry, binName);
+    if (!existsSync(candidate)) continue;
+    try {
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+      // ignore non-executable matches
+    }
+  }
+  return null;
+}
+
+function existingPathOrNull(filePath: string): string | null {
+  return existsSync(filePath) ? filePath : null;
+}
+
+function detectOpenClawInstallation(workspaceRoot: string) {
+  const workspaceDir = resolve(workspaceRoot, ".openclaw");
+  const homeDir = resolve(process.env.HOME || "", ".openclaw");
+  const commandPath = resolveExecutableInPath("openclaw");
+
+  const workspaceIdentityPath = existingPathOrNull(resolve(workspaceDir, "identity.json"));
+  const workspaceProfilePath = existingPathOrNull(resolve(workspaceDir, "profile.json"));
+  const workspaceSocialPath = existingPathOrNull(resolve(workspaceDir, "social.md"));
+  const workspaceSkillsPath = existingPathOrNull(resolve(workspaceDir, "skills"));
+  const homeIdentityPath = existingPathOrNull(resolve(homeDir, "identity.json"));
+  const homeProfilePath = existingPathOrNull(resolve(homeDir, "profile.json"));
+  const homeSocialPath = existingPathOrNull(resolve(homeDir, "social.md"));
+  const homeSkillsPath = existingPathOrNull(resolve(homeDir, "skills"));
+
+  const workspaceDetected = Boolean(
+    existsSync(workspaceDir) ||
+    workspaceIdentityPath ||
+    workspaceProfilePath ||
+    workspaceSocialPath ||
+    workspaceSkillsPath
+  );
+  const homeDetected = Boolean(
+    existsSync(homeDir) || homeIdentityPath || homeProfilePath || homeSocialPath || homeSkillsPath
+  );
+
+  return {
+    detected: Boolean(commandPath || workspaceDetected || homeDetected),
+    detection_mode: commandPath
+      ? "command"
+      : workspaceDetected
+        ? "workspace"
+        : homeDetected
+          ? "home"
+          : "not_found",
+    command_path: commandPath,
+    workspace_dir: workspaceDir,
+    home_dir: homeDir,
+    workspace_dir_exists: existsSync(workspaceDir),
+    home_dir_exists: existsSync(homeDir),
+    workspace_identity_path: workspaceIdentityPath,
+    workspace_profile_path: workspaceProfilePath,
+    workspace_social_path: workspaceSocialPath,
+    workspace_skills_path: workspaceSkillsPath,
+    home_identity_path: homeIdentityPath,
+    home_profile_path: homeProfilePath,
+    home_social_path: homeSocialPath,
+    home_skills_path: homeSkillsPath,
+  } as const;
+}
+
+function detectOpenClawRuntime() {
+  const result = spawnSync("ps", ["-Ao", "pid=,ppid=,command="], {
+    encoding: "utf8",
+  });
+  const stdout = String(result.stdout || "");
+  const lines = stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  const processes = lines
+    .map((line) => {
+      const match = line.match(/^(\d+)\s+(\d+)\s+(.+)$/);
+      if (!match) return null;
+      const command = match[3] || "";
+      const lower = command.toLowerCase();
+      const isOpenClaw =
+        lower.includes(" openclaw ") ||
+        lower.endsWith(" openclaw") ||
+        lower.includes("/openclaw ") ||
+        lower.includes("openclaw.mjs") ||
+        lower.includes("openclaw gateway") ||
+        lower.includes("openclaw agent") ||
+        lower.includes("openclaw message");
+      if (!isOpenClaw) return null;
+      return {
+        pid: Number(match[1]),
+        ppid: Number(match[2]),
+        command,
+      };
+    })
+    .filter((item): item is { pid: number; ppid: number; command: string } => Boolean(item));
+
+  return {
+    running: processes.length > 0,
+    process_count: processes.length,
+    processes: processes.slice(0, 10),
+    detection_error: result.status === 0 ? null : String(result.stderr || "ps failed"),
+  } as const;
+}
+
+function detectOpenClawSkillInstallation() {
+  const homeDir = resolve(process.env.HOME || "", ".openclaw");
+  const workspaceSkillRoot = resolve(homeDir, "workspace", "skills");
+  const legacySkillRoot = resolve(homeDir, "skills");
+  const workspaceSkillPath = resolve(workspaceSkillRoot, OPENCLAW_SKILL_NAME, "SKILL.md");
+  const legacySkillPath = resolve(legacySkillRoot, OPENCLAW_SKILL_NAME, "SKILL.md");
+  const workspaceInstalled = existsSync(workspaceSkillPath);
+  const legacyInstalled = existsSync(legacySkillPath);
+
+  return {
+    installed: workspaceInstalled || legacyInstalled,
+    install_mode: workspaceInstalled ? "workspace" : legacyInstalled ? "legacy" : "not_installed",
+    workspace_skill_root: workspaceSkillRoot,
+    legacy_skill_root: legacySkillRoot,
+    workspace_skill_path: workspaceInstalled ? workspaceSkillPath : null,
+    legacy_skill_path: legacyInstalled ? legacySkillPath : null,
+  } as const;
+}
+
+function detectOwnerDeliveryStatus(params: {
+  workspaceRoot: string;
+  connectedToSilicaclaw: boolean;
+  openclawRunning: boolean;
+  skillInstalled: boolean;
+}) {
+  const forwardCommand = String(process.env.OPENCLAW_OWNER_FORWARD_CMD || "").trim();
+  const ownerChannel = String(process.env.OPENCLAW_OWNER_CHANNEL || "").trim();
+  const ownerTarget = String(process.env.OPENCLAW_OWNER_TARGET || "").trim();
+  const ownerAccount = String(process.env.OPENCLAW_OWNER_ACCOUNT || "").trim();
+  const explicitOpenClawBin = String(process.env.OPENCLAW_BIN || "").trim();
+  const configuredSourceDir = String(process.env.OPENCLAW_SOURCE_DIR || "").trim();
+  const defaultSourceDir = resolve(params.workspaceRoot, "..", "openclaw");
+  const openclawSourceDir = configuredSourceDir || defaultSourceDir;
+  const openclawSourceEntry = existingPathOrNull(resolve(openclawSourceDir, "openclaw.mjs"));
+  const openclawCommandResolvable = Boolean(explicitOpenClawBin || resolveExecutableInPath("openclaw") || openclawSourceEntry);
+  const bridgeMessagesReadable = params.connectedToSilicaclaw && params.openclawRunning && params.skillInstalled;
+  const forwardCommandConfigured = Boolean(forwardCommand);
+  const ownerRouteConfigured = Boolean(ownerChannel && ownerTarget);
+  const ready =
+    bridgeMessagesReadable && forwardCommandConfigured && ownerRouteConfigured && openclawCommandResolvable;
+
+  let reason = "";
+  if (!params.connectedToSilicaclaw) {
+    reason = "SilicaClaw social bridge is not connected yet, so there is no broadcast stream for OpenClaw to learn.";
+  } else if (!params.openclawRunning) {
+    reason = "OpenClaw is not running on this machine yet, so broadcast learning and owner forwarding are idle.";
+  } else if (!params.skillInstalled) {
+    reason = "OpenClaw is running, but the silicaclaw-broadcast skill is not installed yet.";
+  } else if (!forwardCommandConfigured) {
+    reason = "Broadcast learning is ready, but OPENCLAW_OWNER_FORWARD_CMD is not configured yet.";
+  } else if (!ownerRouteConfigured) {
+    reason = "The owner forward command exists, but OPENCLAW_OWNER_CHANNEL and OPENCLAW_OWNER_TARGET are still missing.";
+  } else if (!openclawCommandResolvable) {
+    reason = "Owner forwarding is configured, but no runnable OpenClaw CLI or source checkout was found.";
+  } else {
+    reason = "This machine can read SilicaClaw broadcasts and route owner summaries through OpenClaw.";
+  }
+
+  return {
+    supported: bridgeMessagesReadable,
+    mode: "public-broadcast-via-openclaw" as const,
+    send_to_owner_via_openclaw: ready,
+    bridge_messages_readable: bridgeMessagesReadable,
+    forward_command_configured: forwardCommandConfigured,
+    openclaw_command_resolvable: openclawCommandResolvable,
+    ready,
+    forward_command: forwardCommand || null,
+    owner_channel: ownerChannel || null,
+    owner_target: ownerTarget || null,
+    owner_account: ownerAccount || null,
+    openclaw_source_dir: openclawSourceEntry ? openclawSourceDir : null,
+    reason,
+  };
+}
+
 function hasMeaningfulJson(filePath: string): boolean {
   if (!existsSync(filePath)) return false;
   try {
@@ -128,7 +354,14 @@ function migrateLegacyDataIfNeeded(workspaceRoot: string, storageRoot: string):
   const legacyDataDir = resolve(workspaceRoot, "data");
   const targetDataDir = resolve(storageRoot, "data");
   if (legacyDataDir === targetDataDir) return;
-  const files = ["identity.json", "profile.json", "cache.json", "logs.json"];
+  const files = [
+    "identity.json",
+    "profile.json",
+    "cache.json",
+    "logs.json",
+    "social-messages.json",
+    "social-message-observations.json",
+  ];
   for (const file of files) {
     const src = resolve(legacyDataDir, file);
     const dst = resolve(targetDataDir, file);
@@ -179,29 +412,151 @@ type IntegrationStatusSummary = {
   status_line: string;
 };
 
-class LocalNodeService {
+type SocialMessageView = SocialMessageRecord & {
+  is_self: boolean;
+  online: boolean;
+  last_seen_at: number | null;
+  observation_count: number;
+  remote_observation_count: number;
+  last_observed_at: number | null;
+  delivery_status: "local-only" | "remote-observed";
+};
+
+type RuntimeMessageGovernance = SocialMessageGovernanceConfig;
+
+type OpenClawBridgeStatus = {
+  enabled: boolean;
+  connected_to_silicaclaw: boolean;
+  public_enabled: boolean;
+  message_broadcast_enabled: boolean;
+  network_mode: "local" | "lan" | "global-preview";
+  adapter: string;
+  agent_id: string;
+  display_name: string;
+  identity_source: "silicaclaw-existing" | "openclaw-existing" | "silicaclaw-generated";
+  openclaw_identity_source_path: string | null;
+  social_source_path: string | null;
+  openclaw_installation: {
+    detected: boolean;
+    detection_mode: "command" | "workspace" | "home" | "not_found";
+    command_path: string | null;
+    workspace_dir: string;
+    home_dir: string;
+    workspace_dir_exists: boolean;
+    home_dir_exists: boolean;
+    workspace_identity_path: string | null;
+    workspace_profile_path: string | null;
+    workspace_social_path: string | null;
+    workspace_skills_path: string | null;
+    home_identity_path: string | null;
+    home_profile_path: string | null;
+    home_social_path: string | null;
+    home_skills_path: string | null;
+  };
+  openclaw_runtime: {
+    running: boolean;
+    process_count: number;
+    processes: Array<{
+      pid: number;
+      ppid: number;
+      command: string;
+    }>;
+    detection_error: string | null;
+  };
+  skill_learning: {
+    available: boolean;
+    installed: boolean;
+    install_mode: "workspace" | "legacy" | "not_installed";
+    installed_skill_path: string | null;
+    install_action: {
+      supported: boolean;
+      endpoint: string;
+      recommended_command: string;
+    };
+    skills: Array<{
+      key: "get_profile" | "list_messages" | "watch_messages" | "send_message";
+      summary: string;
+      endpoint: string;
+    }>;
+  };
+  owner_delivery: {
+    supported: boolean;
+    mode: "public-broadcast-via-openclaw";
+    send_to_owner_via_openclaw: boolean;
+    bridge_messages_readable: boolean;
+    forward_command_configured: boolean;
+    openclaw_command_resolvable: boolean;
+    ready: boolean;
+    forward_command: string | null;
+    owner_channel: string | null;
+    owner_target: string | null;
+    owner_account: string | null;
+    openclaw_source_dir: string | null;
+    reason: string;
+  };
+  endpoints: {
+    status: string;
+    profile: string;
+    messages: string;
+    send_message: string;
+    install_skill: string;
+  };
+};
+
+type OpenClawBridgeConfigView = {
+  bridge_api_base: string;
+  openclaw_detected: boolean;
+  openclaw_running: boolean;
+  openclaw_workspace_skill_dir: string;
+  openclaw_legacy_skill_dir: string;
+  silicaclaw_env_template_path: string;
+  recommended_skill_name: string;
+  recommended_install_command: string;
+  recommended_owner_forward_env: {
+    OPENCLAW_SOURCE_DIR: string;
+    OPENCLAW_OWNER_CHANNEL: string;
+    OPENCLAW_OWNER_TARGET: string;
+    OPENCLAW_OWNER_ACCOUNT: string;
+    OPENCLAW_OWNER_FORWARD_CMD: string;
+  };
+  owner_forward_command_example: string;
+  notes: string[];
+};
+
+export class LocalNodeService {
   private workspaceRoot: string;
   private storageRoot: string;
   private identityRepo: IdentityRepo;
   private profileRepo: ProfileRepo;
   private cacheRepo: CacheRepo;
   private logRepo: LogRepo;
+  private socialMessageGovernanceRepo: SocialMessageGovernanceRepo;
+  private socialMessageRepo: SocialMessageRepo;
+  private socialMessageObservationRepo: SocialMessageObservationRepo;
   private socialRuntimeRepo: SocialRuntimeRepo;
 
   private identity: AgentIdentity | null = null;
   private profile: PublicProfile | null = null;
   private directory: DirectoryState = createEmptyDirectoryState();
+  private socialMessages: SocialMessageRecord[] = [];
+  private socialMessageObservations: SocialMessageObservationRecord[] = [];
+  private messageGovernance: RuntimeMessageGovernance;
 
   private receivedCount = 0;
   private broadcastCount = 0;
   private lastMessageAt = 0;
   private lastBroadcastAt = 0;
+  private lastBroadcastErrorAt = 0;
+  private lastBroadcastError: string | null = null;
+  private broadcastFailureCount = 0;
   private broadcaster: NodeJS.Timeout | null = null;
   private subscriptionsBound = false;
   private broadcastEnabled = true;
 
   private receivedByTopic: Record<string, number> = {};
   private publishedByTopic: Record<string, number> = {};
+  private outboundMessageTimestamps: number[] = [];
+  private inboundMessageTimestampsByAgent: Record<string, number[]> = {};
 
   private initState: InitState = {
     identity_auto_created: false,
@@ -212,7 +567,7 @@ class LocalNodeService {
 
   private network: NetworkAdapter;
   private adapterMode: "mock" | "local-event-bus" | "real-preview" | "webrtc-preview" | "relay-preview";
-  private networkMode: "local" | "lan" | "global-preview" = "lan";
+  private networkMode: "local" | "lan" | "global-preview" = "global-preview";
   private networkNamespace: string;
   private networkPort: number | null;
   private socialConfig: SocialConfig;
@@ -232,9 +587,9 @@ class LocalNodeService {
   private webrtcBootstrapSources: string[] = [];
   private appVersion = "unknown";
 
-  constructor() {
-    this.workspaceRoot = resolveWorkspaceRoot();
-    this.storageRoot = resolveStorageRoot(this.workspaceRoot);
+  constructor(options?: { workspaceRoot?: string; storageRoot?: string }) {
+    this.workspaceRoot = options?.workspaceRoot || resolveWorkspaceRoot();
+    this.storageRoot = options?.storageRoot || resolveStorageRoot(this.workspaceRoot);
     this.appVersion = readWorkspaceVersion(this.workspaceRoot);
     migrateLegacyDataIfNeeded(this.workspaceRoot, this.storageRoot);
 
@@ -242,7 +597,11 @@ class LocalNodeService {
     this.profileRepo = new ProfileRepo(this.storageRoot);
     this.cacheRepo = new CacheRepo(this.storageRoot);
     this.logRepo = new LogRepo(this.storageRoot);
+    this.socialMessageGovernanceRepo = new SocialMessageGovernanceRepo(this.storageRoot);
+    this.socialMessageRepo = new SocialMessageRepo(this.storageRoot);
+    this.socialMessageObservationRepo = new SocialMessageObservationRepo(this.storageRoot);
     this.socialRuntimeRepo = new SocialRuntimeRepo(this.storageRoot);
+    this.messageGovernance = this.defaultMessageGovernance();
 
     let loadedSocial = loadSocialConfig(this.workspaceRoot);
     if (!loadedSocial.meta.found) {
@@ -282,7 +641,14 @@ class LocalNodeService {
     );
 
     if (this.profile?.public_enabled && this.broadcastEnabled) {
-      await this.broadcastNow("adapter_start");
+      try {
+        await this.broadcastNow("adapter_start");
+      } catch (error) {
+        await this.log(
+          "warn",
+          `Initial broadcast failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
     }
 
     this.startBroadcastLoop();
@@ -321,6 +687,9 @@ class LocalNodeService {
       public_enabled: Boolean(this.profile?.public_enabled),
       broadcast_enabled: this.broadcastEnabled,
       last_broadcast_at: this.lastBroadcastAt,
+      last_broadcast_error_at: this.lastBroadcastErrorAt,
+      last_broadcast_error: this.lastBroadcastError,
+      broadcast_failure_count: this.broadcastFailureCount,
       discovered_count: profiles.length,
       online_count: onlineCount,
       offline_count: Math.max(0, profiles.length - onlineCount),
@@ -332,6 +701,14 @@ class LocalNodeService {
         enabled: this.socialConfig.enabled,
         source_path: this.socialSourcePath,
         network_mode: this.networkMode,
+        mode_explainer: this.getModeExplainer(),
+      governance: {
+        send_limit: { max: this.messageGovernance.send_limit_max, window_ms: this.messageGovernance.send_window_ms },
+        receive_limit: { max: this.messageGovernance.receive_limit_max, window_ms: this.messageGovernance.receive_window_ms },
+        duplicate_window_ms: this.messageGovernance.duplicate_window_ms,
+        blocked_agent_count: this.messageGovernance.blocked_agent_ids.length,
+        blocked_term_count: this.messageGovernance.blocked_terms.length,
+      },
       },
     };
   }
@@ -346,8 +723,11 @@ class LocalNodeService {
       mode: this.networkMode,
       received_count: this.receivedCount,
       broadcast_count: this.broadcastCount,
+      broadcast_failure_count: this.broadcastFailureCount,
       last_message_at: this.lastMessageAt,
       last_broadcast_at: this.lastBroadcastAt,
+      last_broadcast_error_at: this.lastBroadcastErrorAt,
+      last_broadcast_error: this.lastBroadcastError,
       received_by_topic: this.receivedByTopic,
       published_by_topic: this.publishedByTopic,
       peers_discovered: peerCount,
@@ -445,6 +825,7 @@ class LocalNodeService {
           : this.adapterMode === "webrtc-preview" || this.adapterMode === "relay-preview"
             ? "internet-preview"
             : "local-process",
+      mode_explainer: this.getModeExplainer(),
     };
   }
 
@@ -459,8 +840,11 @@ class LocalNodeService {
       message_counters: {
         received_total: this.receivedCount,
         broadcast_total: this.broadcastCount,
+        broadcast_failures_total: this.broadcastFailureCount,
         last_message_at: this.lastMessageAt,
         last_broadcast_at: this.lastBroadcastAt,
+        last_broadcast_error_at: this.lastBroadcastErrorAt,
+        last_broadcast_error: this.lastBroadcastError,
         received_by_topic: this.receivedByTopic,
         published_by_topic: this.publishedByTopic,
       },
@@ -825,6 +1209,301 @@ class LocalNodeService {
     return this.identity;
   }
 
+  getSocialMessages(limit = 50, options?: { agent_id?: string | null }): {
+    total: number;
+    items: SocialMessageView[];
+    governance: {
+      send_limit: { max: number; window_ms: number };
+      receive_limit: { max: number; window_ms: number };
+      duplicate_window_ms: number;
+      blocked_agent_count: number;
+      blocked_term_count: number;
+    };
+  } {
+    const resolvedLimit = Math.max(1, Math.min(200, Number(limit) || 50));
+    this.ensureLocalDirectoryBaseline();
+    this.compactCacheInMemory();
+    const agentId = String(options?.agent_id || "").trim();
+    const filtered = agentId
+      ? this.socialMessages.filter((message) => message.agent_id === agentId)
+      : this.socialMessages;
+    return {
+      total: filtered.length,
+      items: filtered.slice(0, resolvedLimit).map((message) => {
+        const profile = this.directory.profiles[message.agent_id];
+        const lastSeenAt = this.directory.presence[message.agent_id] ?? 0;
+        const observations = this.socialMessageObservations.filter((item) => item.message_id === message.message_id);
+        const remoteObservationCount = observations.filter((item) => item.observer_agent_id !== message.agent_id).length;
+        const lastObservedAt = observations.length > 0 ? Math.max(...observations.map((item) => item.observed_at)) : 0;
+        return {
+          ...message,
+          display_name: profile?.display_name || message.display_name || "Unnamed",
+          is_self: message.agent_id === this.identity?.agent_id,
+          online: isAgentOnline(lastSeenAt, Date.now(), PRESENCE_TTL_MS),
+          last_seen_at: lastSeenAt || null,
+          observation_count: observations.length,
+          remote_observation_count: remoteObservationCount,
+          last_observed_at: lastObservedAt || null,
+          delivery_status: remoteObservationCount > 0 ? "remote-observed" : "local-only",
+        };
+      }),
+      governance: {
+        send_limit: { max: this.messageGovernance.send_limit_max, window_ms: this.messageGovernance.send_window_ms },
+        receive_limit: { max: this.messageGovernance.receive_limit_max, window_ms: this.messageGovernance.receive_window_ms },
+        duplicate_window_ms: this.messageGovernance.duplicate_window_ms,
+        blocked_agent_count: this.messageGovernance.blocked_agent_ids.length,
+        blocked_term_count: this.messageGovernance.blocked_terms.length,
+      },
+    };
+  }
+
+  getOpenClawBridgeStatus(): OpenClawBridgeStatus {
+    const integration = this.getIntegrationStatus();
+    const openclawInstallation = detectOpenClawInstallation(this.workspaceRoot);
+    const openclawRuntime = detectOpenClawRuntime();
+    const skillInstallation = detectOpenClawSkillInstallation();
+    const ownerDelivery = detectOwnerDeliveryStatus({
+      workspaceRoot: this.workspaceRoot,
+      connectedToSilicaclaw: integration.connected_to_silicaclaw,
+      openclawRunning: openclawRuntime.running,
+      skillInstalled: skillInstallation.installed,
+    });
+    return {
+      enabled: this.socialConfig.enabled,
+      connected_to_silicaclaw: integration.connected_to_silicaclaw,
+      public_enabled: integration.public_enabled,
+      message_broadcast_enabled: this.socialConfig.discovery.allow_message_broadcast && this.broadcastEnabled,
+      network_mode: this.networkMode,
+      adapter: this.adapterMode,
+      agent_id: this.identity?.agent_id ?? "",
+      display_name: this.profile?.display_name ?? "",
+      identity_source: this.resolvedIdentitySource,
+      openclaw_identity_source_path: this.resolvedOpenClawIdentityPath,
+      social_source_path: this.socialSourcePath,
+      openclaw_installation: openclawInstallation,
+      openclaw_runtime: openclawRuntime,
+      skill_learning: {
+        available: integration.connected_to_silicaclaw && openclawRuntime.running,
+        installed: skillInstallation.installed,
+        install_mode: skillInstallation.install_mode,
+        installed_skill_path: skillInstallation.workspace_skill_path || skillInstallation.legacy_skill_path,
+        install_action: {
+          supported: true,
+          endpoint: "/api/openclaw/bridge/skill-install",
+          recommended_command: "silicaclaw openclaw-skill-install",
+        },
+        skills: [
+          {
+            key: "get_profile",
+            summary: "Read SilicaClaw identity/profile so OpenClaw can align its runtime persona.",
+            endpoint: "/api/openclaw/bridge/profile",
+          },
+          {
+            key: "list_messages",
+            summary: "Read recent public broadcast messages observed by this SilicaClaw node.",
+            endpoint: "/api/openclaw/bridge/messages",
+          },
+          {
+            key: "watch_messages",
+            summary: "Poll the recent broadcast feed so OpenClaw can learn from new public messages.",
+            endpoint: "/api/openclaw/bridge/messages",
+          },
+          {
+            key: "send_message",
+            summary: "Publish a signed public broadcast through SilicaClaw on behalf of OpenClaw.",
+            endpoint: "/api/openclaw/bridge/message",
+          },
+        ],
+      },
+      owner_delivery: ownerDelivery,
+      endpoints: {
+        status: "/api/openclaw/bridge",
+        profile: "/api/openclaw/bridge/profile",
+        messages: "/api/openclaw/bridge/messages",
+        send_message: "/api/openclaw/bridge/message",
+        install_skill: "/api/openclaw/bridge/skill-install",
+      },
+    };
+  }
+
+  async installOpenClawSkill() {
+    const scriptPath = resolve(this.workspaceRoot, "scripts", "install-openclaw-skill.mjs");
+    const { stdout } = await execFileAsync(process.execPath, [scriptPath], {
+      cwd: this.workspaceRoot,
+      env: process.env,
+      maxBuffer: 1024 * 1024,
+    });
+    const parsed = JSON.parse(String(stdout || "{}"));
+    return {
+      ...parsed,
+      bridge: this.getOpenClawBridgeStatus(),
+    };
+  }
+
+  getOpenClawBridgeProfile() {
+    return {
+      identity: this.getIdentity(),
+      profile: this.getProfile(),
+      public_profile_preview: this.getPublicProfilePreview(),
+      integration: this.getIntegrationSummary(),
+      bridge: this.getOpenClawBridgeStatus(),
+    };
+  }
+
+  getOpenClawBridgeConfig(): OpenClawBridgeConfigView {
+    const homeDir = resolve(process.env.HOME || "", ".openclaw");
+    const workspaceSkillDir = resolve(homeDir, "workspace", "skills");
+    const legacySkillDir = resolve(homeDir, "skills");
+    const openclawSourceDir = resolve(this.workspaceRoot, "..", "openclaw");
+
+    return {
+      bridge_api_base: "http://localhost:4310",
+      openclaw_detected: detectOpenClawInstallation(this.workspaceRoot).detected,
+      openclaw_running: detectOpenClawRuntime().running,
+      openclaw_workspace_skill_dir: workspaceSkillDir,
+      openclaw_legacy_skill_dir: legacySkillDir,
+      silicaclaw_env_template_path: resolve(this.workspaceRoot, "openclaw-owner-forward.env.example"),
+      recommended_skill_name: "silicaclaw-broadcast",
+      recommended_install_command: "silicaclaw openclaw-skill-install",
+      recommended_owner_forward_env: {
+        OPENCLAW_SOURCE_DIR: openclawSourceDir,
+        OPENCLAW_OWNER_CHANNEL: "<channel>",
+        OPENCLAW_OWNER_TARGET: "<target>",
+        OPENCLAW_OWNER_ACCOUNT: "",
+        OPENCLAW_OWNER_FORWARD_CMD: "node scripts/send-to-owner-via-openclaw.mjs",
+      },
+      owner_forward_command_example: [
+        `OPENCLAW_SOURCE_DIR='${openclawSourceDir}'`,
+        "OPENCLAW_OWNER_CHANNEL='<channel>'",
+        "OPENCLAW_OWNER_TARGET='<target>'",
+        "OPENCLAW_OWNER_FORWARD_CMD='node scripts/send-to-owner-via-openclaw.mjs'",
+        "node scripts/owner-forwarder-demo.mjs",
+      ].join(" "),
+      notes: [
+        "Install and maintain the skill from SilicaClaw; do not edit OpenClaw core source for this integration.",
+        "OpenClaw learns broadcasts via the installed skill under ~/.openclaw/workspace/skills/.",
+        "Owner delivery runs through OpenClaw's own message channel stack after the skill forwards a summary.",
+        "Sensitive computer control still requires OpenClaw's own owner approval and node permission flow.",
+      ],
+    };
+  }
+
+  getRuntimeMessageGovernance() {
+    return this.messageGovernance;
+  }
+
+  async getMessageGovernanceView() {
+    const logs = await this.logRepo.get();
+    const recentEvents = logs
+      .filter((entry) => (
+        entry.message.includes("Rejected social message") ||
+        entry.message.includes("Social message blocked") ||
+        entry.message.includes("Social message throttled")
+      ))
+      .slice(0, 20);
+
+    return {
+      policy: {
+        send_limit: { max: this.messageGovernance.send_limit_max, window_ms: this.messageGovernance.send_window_ms },
+        receive_limit: { max: this.messageGovernance.receive_limit_max, window_ms: this.messageGovernance.receive_window_ms },
+        duplicate_window_ms: this.messageGovernance.duplicate_window_ms,
+        blocked_agent_ids: Array.from(this.messageGovernance.blocked_agent_ids),
+        blocked_terms: Array.from(this.messageGovernance.blocked_terms),
+      },
+      recent_events: recentEvents,
+    };
+  }
+
+  async updateMessageGovernance(input: Partial<RuntimeMessageGovernance>) {
+    const next: RuntimeMessageGovernance = {
+      send_limit_max: Math.max(1, Math.min(100, Number(input.send_limit_max ?? this.messageGovernance.send_limit_max) || this.messageGovernance.send_limit_max)),
+      send_window_ms: Math.max(5_000, Math.min(3_600_000, Number(input.send_window_ms ?? this.messageGovernance.send_window_ms) || this.messageGovernance.send_window_ms)),
+      receive_limit_max: Math.max(1, Math.min(200, Number(input.receive_limit_max ?? this.messageGovernance.receive_limit_max) || this.messageGovernance.receive_limit_max)),
+      receive_window_ms: Math.max(5_000, Math.min(3_600_000, Number(input.receive_window_ms ?? this.messageGovernance.receive_window_ms) || this.messageGovernance.receive_window_ms)),
+      duplicate_window_ms: Math.max(5_000, Math.min(3_600_000, Number(input.duplicate_window_ms ?? this.messageGovernance.duplicate_window_ms) || this.messageGovernance.duplicate_window_ms)),
+      blocked_agent_ids: dedupeStrings(Array.isArray(input.blocked_agent_ids) ? input.blocked_agent_ids.map((item) => String(item || "").trim()) : this.messageGovernance.blocked_agent_ids),
+      blocked_terms: dedupeStrings(Array.isArray(input.blocked_terms) ? input.blocked_terms.map((item) => String(item || "").trim().toLowerCase()) : this.messageGovernance.blocked_terms),
+    };
+    this.messageGovernance = next;
+    await this.socialMessageGovernanceRepo.set(next);
+    await this.log("info", "Runtime message governance updated");
+    return this.getMessageGovernanceView();
+  }
+
+  async sendSocialMessage(body: string, topic = DEFAULT_SOCIAL_MESSAGE_CHANNEL): Promise<{ sent: boolean; reason: string; message?: SocialMessageView; error?: string }> {
+    if (!this.identity || !this.profile) {
+      return { sent: false, reason: "missing_identity_or_profile" };
+    }
+    if (!this.profile.public_enabled) {
+      return { sent: false, reason: "public_disabled" };
+    }
+    if (!this.broadcastEnabled) {
+      return { sent: false, reason: "broadcast_paused" };
+    }
+    if (!this.socialConfig.discovery.allow_message_broadcast) {
+      return { sent: false, reason: "message_broadcast_disabled" };
+    }
+
+    const normalizedBody = this.normalizeSocialMessageBody(body);
+    const normalizedTopic = String(topic || DEFAULT_SOCIAL_MESSAGE_CHANNEL).trim() || DEFAULT_SOCIAL_MESSAGE_CHANNEL;
+    if (!normalizedBody) {
+      return { sent: false, reason: "empty_message" };
+    }
+    if (normalizedBody.length > SOCIAL_MESSAGE_MAX_BODY_CHARS) {
+      return { sent: false, reason: "message_too_long" };
+    }
+    if (this.containsBlockedMessageTerm(normalizedBody)) {
+      await this.log("warn", `Social message blocked: blocked_term (${this.identity.agent_id.slice(0, 10)})`);
+      return { sent: false, reason: "blocked_term" };
+    }
+    if (this.isRateLimited(this.outboundMessageTimestamps, this.messageGovernance.send_window_ms, this.messageGovernance.send_limit_max)) {
+      await this.log("warn", `Social message throttled: rate_limited (${this.identity.agent_id.slice(0, 10)})`);
+      return { sent: false, reason: "rate_limited" };
+    }
+    if (this.hasRecentDuplicateMessage(this.identity.agent_id, normalizedBody, normalizedTopic)) {
+      await this.log("warn", `Social message blocked: duplicate_recent_message (${this.identity.agent_id.slice(0, 10)})`);
+      return { sent: false, reason: "duplicate_recent_message" };
+    }
+
+    const message = signSocialMessage({
+      identity: this.identity,
+      message_id: createHash("sha256")
+        .update(`${this.identity.agent_id}:${normalizedTopic}:${Date.now()}:${normalizedBody}:${Math.random()}`, "utf8")
+        .digest("hex"),
+      display_name: this.profile.display_name,
+      topic: normalizedTopic,
+      body: normalizedBody,
+      created_at: Date.now(),
+    });
+
+    this.recordTimestamp(this.outboundMessageTimestamps, this.messageGovernance.send_window_ms, message.created_at);
+    this.ingestSocialMessage(message);
+    try {
+      await this.publish(SOCIAL_MESSAGE_TOPIC, message);
+    } catch (error) {
+      const messageText = error instanceof Error ? error.message : String(error);
+      this.lastBroadcastErrorAt = Date.now();
+      this.lastBroadcastError = messageText;
+      this.broadcastFailureCount += 1;
+      await this.persistSocialMessages();
+      await this.log("error", `Social message broadcast failed (${message.message_id.slice(0, 10)}): ${messageText}`);
+      return {
+        sent: false,
+        reason: "publish_failed",
+        error: messageText,
+        message: this.getSocialMessages(1).items[0],
+      };
+    }
+    await this.persistSocialMessages();
+    await this.log("info", `Social message broadcast (${message.message_id.slice(0, 10)})`);
+
+    return {
+      sent: true,
+      reason: "sent",
+      message: this.getSocialMessages(1).items[0],
+    };
+  }
+
   async getLogs() {
     return this.logRepo.get();
   }
@@ -935,7 +1614,7 @@ class LocalNodeService {
     return { broadcast_enabled: this.broadcastEnabled };
   }
 
-  async broadcastNow(reason = "manual"): Promise<{ sent: boolean; reason: string }> {
+  async broadcastNow(reason = "manual"): Promise<{ sent: boolean; reason: string; error?: string }> {
     if (!this.identity || !this.profile) {
       return { sent: false, reason: "missing_identity_or_profile" };
     }
@@ -953,14 +1632,25 @@ class LocalNodeService {
     const presenceRecord = signPresence(this.identity, Date.now());
     const indexRecords = buildIndexRecords(this.profile);
 
-    await this.publish("profile", profileRecord);
-    await this.publish("presence", presenceRecord);
-    for (const record of indexRecords) {
-      await this.publish("index", record);
+    try {
+      await this.publish("profile", profileRecord);
+      await this.publish("presence", presenceRecord);
+      for (const record of indexRecords) {
+        await this.publish("index", record);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.lastBroadcastErrorAt = Date.now();
+      this.lastBroadcastError = message;
+      this.broadcastFailureCount += 1;
+      await this.log("error", `Broadcast failed (reason=${reason}): ${message}`);
+      return { sent: false, reason: "publish_failed", error: message };
     }
 
     this.lastBroadcastAt = Date.now();
     this.broadcastCount += 1;
+    this.lastBroadcastError = null;
+    this.lastBroadcastErrorAt = 0;
 
     this.directory = ingestProfileRecord(this.directory, profileRecord);
     this.directory = ingestPresenceRecord(this.directory, presenceRecord);
@@ -1019,6 +1709,12 @@ class LocalNodeService {
     await this.profileRepo.set(this.profile);
 
     this.directory = dedupeIndex(await this.cacheRepo.get());
+    this.messageGovernance = {
+      ...this.defaultMessageGovernance(),
+      ...(await this.socialMessageGovernanceRepo.get()),
+    };
+    this.socialMessages = this.normalizeSocialMessages(await this.socialMessageRepo.get());
+    this.socialMessageObservations = this.normalizeSocialMessageObservations(await this.socialMessageObservationRepo.get());
     this.directory = ingestProfileRecord(this.directory, { type: "profile", profile: this.profile });
     this.compactCacheInMemory();
     await this.persistCache();
@@ -1100,7 +1796,10 @@ class LocalNodeService {
     await this.socialRuntimeRepo.set(runtime);
   }
 
-  private async onMessage(topic: "profile" | "presence" | "index", data: unknown): Promise<void> {
+  private async onMessage(
+    topic: "profile" | "presence" | "index" | "social.message" | "social.message.observation",
+    data: unknown
+  ): Promise<void> {
     this.receivedCount += 1;
     this.receivedByTopic[topic] = (this.receivedByTopic[topic] ?? 0) + 1;
     this.lastMessageAt = Date.now();
@@ -1143,6 +1842,40 @@ class LocalNodeService {
       return;
     }
 
+    if (topic === SOCIAL_MESSAGE_TOPIC) {
+      const record = this.normalizeIncomingSocialMessage(data);
+      if (!record) {
+        return;
+      }
+      if (!verifySocialMessage(record)) {
+        await this.log("warn", `Rejected social message with invalid signature (${record.message_id.slice(0, 10)})`);
+        return;
+      }
+      const governanceReason = this.getIncomingSocialMessageRejectionReason(record);
+      if (governanceReason) {
+        await this.log("warn", `Rejected social message (${record.message_id.slice(0, 10)}): ${governanceReason}`);
+        return;
+      }
+      this.ingestSocialMessage(record);
+      await this.persistSocialMessages();
+      await this.publishObservationForMessage(record);
+      return;
+    }
+
+    if (topic === SOCIAL_MESSAGE_OBSERVATION_TOPIC) {
+      const record = this.normalizeIncomingSocialMessageObservation(data);
+      if (!record) {
+        return;
+      }
+      if (!verifySocialMessageObservation(record)) {
+        await this.log("warn", `Rejected message observation with invalid signature (${record.observation_id.slice(0, 10)})`);
+        return;
+      }
+      this.ingestSocialMessageObservation(record);
+      await this.persistSocialMessageObservations();
+      return;
+    }
+
     const record = data as IndexRefRecord;
     if (!record?.key || !record?.agent_id) {
       return;
@@ -1162,7 +1895,14 @@ class LocalNodeService {
     }
 
     this.broadcaster = setInterval(async () => {
-      await this.broadcastNow("interval");
+      try {
+        await this.broadcastNow("interval");
+      } catch (error) {
+        await this.log(
+          "warn",
+          `Scheduled broadcast failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
     }, BROADCAST_INTERVAL_MS);
   }
 
@@ -1179,6 +1919,12 @@ class LocalNodeService {
     this.network.subscribe("index", (data: IndexRefRecord) => {
       this.onMessage("index", data);
     });
+    this.network.subscribe(SOCIAL_MESSAGE_TOPIC, (data: SocialMessageRecord) => {
+      this.onMessage(SOCIAL_MESSAGE_TOPIC, data);
+    });
+    this.network.subscribe(SOCIAL_MESSAGE_OBSERVATION_TOPIC, (data: SocialMessageObservationRecord) => {
+      this.onMessage(SOCIAL_MESSAGE_OBSERVATION_TOPIC, data);
+    });
     this.subscriptionsBound = true;
   }
 
@@ -1302,6 +2048,14 @@ class LocalNodeService {
     await this.cacheRepo.set(this.directory);
   }
 
+  private async persistSocialMessages(): Promise<void> {
+    await this.socialMessageRepo.set(this.socialMessages);
+  }
+
+  private async persistSocialMessageObservations(): Promise<void> {
+    await this.socialMessageObservationRepo.set(this.socialMessageObservations);
+  }
+
   private async log(level: "info" | "warn" | "error", message: string): Promise<void> {
     await this.logRepo.append({
       level,
@@ -1391,6 +2145,40 @@ class LocalNodeService {
     return host ? `OpenClaw @ ${host}` : "OpenClaw Agent";
   }
 
+  private getModeExplainer() {
+    if (this.networkMode === "local") {
+      return {
+        mode: "local",
+        short_label: "Local only",
+        summary: "Only nodes inside the same local process bus are visible.",
+      };
+    }
+    if (this.networkMode === "lan") {
+      return {
+        mode: "lan",
+        short_label: "LAN broadcast",
+        summary: "Uses UDP LAN broadcast. Peers usually need to be on the same local network.",
+      };
+    }
+    return {
+      mode: "global-preview",
+      short_label: "Relay preview",
+      summary: "Uses the public relay preview room so public nodes can find each other across the internet.",
+    };
+  }
+
+  private defaultMessageGovernance(): RuntimeMessageGovernance {
+    return {
+      send_limit_max: SOCIAL_MESSAGE_SEND_MAX_PER_WINDOW,
+      send_window_ms: SOCIAL_MESSAGE_SEND_WINDOW_MS,
+      receive_limit_max: SOCIAL_MESSAGE_RECEIVE_MAX_PER_WINDOW,
+      receive_window_ms: SOCIAL_MESSAGE_RECEIVE_WINDOW_MS,
+      duplicate_window_ms: SOCIAL_MESSAGE_DUPLICATE_WINDOW_MS,
+      blocked_agent_ids: Array.from(SOCIAL_MESSAGE_BLOCKED_AGENT_IDS),
+      blocked_terms: Array.from(SOCIAL_MESSAGE_BLOCKED_TERMS),
+    };
+  }
+
   private adapterForMode(mode: "local" | "lan" | "global-preview"): "local-event-bus" | "real-preview" | "webrtc-preview" | "relay-preview" {
     if (mode === "local") return "local-event-bus";
     if (mode === "lan") return "real-preview";
@@ -1400,9 +2188,10 @@ class LocalNodeService {
   private applyResolvedNetworkConfig(): void {
     const modeEnv = String(NETWORK_MODE || "").trim();
     const resolvedMode =
-      modeEnv === "local" || modeEnv === "lan" || modeEnv === "global-preview"
+      this.socialConfig.network.mode ||
+      (modeEnv === "local" || modeEnv === "lan" || modeEnv === "global-preview"
         ? modeEnv
-        : this.socialConfig.network.mode || "lan";
+        : "global-preview");
 
     this.networkMode = resolvedMode;
     this.networkNamespace = this.socialConfig.network.namespace || process.env.NETWORK_NAMESPACE || "silicaclaw.preview";
@@ -1479,6 +2268,242 @@ class LocalNodeService {
     this.webrtcBootstrapHints = bootstrapHints;
     this.webrtcBootstrapSources = [signalingSource, roomSource, seedPeersSource, bootstrapHintsSource];
   }
+
+  private normalizeSocialMessageBody(body: string): string {
+    return String(body || "")
+      .replace(/\r\n/g, "\n")
+      .split("\n")
+      .map((line) => line.trimEnd())
+      .join("\n")
+      .trim();
+  }
+
+  private normalizeWindowTimestamps(timestamps: number[], windowMs: number, now = Date.now()): number[] {
+    return timestamps.filter((timestamp) => now - timestamp <= windowMs);
+  }
+
+  private recordTimestamp(timestamps: number[], windowMs: number, at = Date.now()): void {
+    const cleaned = this.normalizeWindowTimestamps(timestamps, windowMs, at);
+    cleaned.push(at);
+    timestamps.splice(0, timestamps.length, ...cleaned);
+  }
+
+  private isRateLimited(timestamps: number[], windowMs: number, maxCount: number, now = Date.now()): boolean {
+    const cleaned = this.normalizeWindowTimestamps(timestamps, windowMs, now);
+    timestamps.splice(0, timestamps.length, ...cleaned);
+    return cleaned.length >= maxCount;
+  }
+
+  private containsBlockedMessageTerm(body: string): boolean {
+    const normalized = String(body || "").toLowerCase();
+    return this.messageGovernance.blocked_terms.some((term) => normalized.includes(term));
+  }
+
+  private hasRecentDuplicateMessage(agentId: string, body: string, topic: string, now = Date.now()): boolean {
+    return this.socialMessages.some((item) => (
+      item.agent_id === agentId &&
+      item.topic === topic &&
+      item.body === body &&
+      now - item.created_at <= this.messageGovernance.duplicate_window_ms
+    ));
+  }
+
+  private getIncomingSocialMessageRejectionReason(record: SocialMessageRecord): string | null {
+    const now = Date.now();
+    if (this.messageGovernance.blocked_agent_ids.includes(record.agent_id)) {
+      return "blocked_agent";
+    }
+    if (this.containsBlockedMessageTerm(record.body)) {
+      return "blocked_term";
+    }
+    if (record.created_at - now > SOCIAL_MESSAGE_MAX_FUTURE_MS) {
+      return "message_from_future";
+    }
+    if (now - record.created_at > SOCIAL_MESSAGE_MAX_AGE_MS) {
+      return "message_too_old";
+    }
+    const timestamps = this.inboundMessageTimestampsByAgent[record.agent_id] || [];
+    this.inboundMessageTimestampsByAgent[record.agent_id] = timestamps;
+    if (this.isRateLimited(timestamps, this.messageGovernance.receive_window_ms, this.messageGovernance.receive_limit_max, now)) {
+      return "remote_rate_limited";
+    }
+    if (this.hasRecentDuplicateMessage(record.agent_id, record.body, record.topic, now)) {
+      return "duplicate_recent_message";
+    }
+    this.recordTimestamp(timestamps, this.messageGovernance.receive_window_ms, now);
+    return null;
+  }
+
+  private canPublishMessageObservation(): boolean {
+    return Boolean(
+      this.identity &&
+      this.profile?.public_enabled &&
+      this.broadcastEnabled &&
+      this.socialConfig.discovery.allow_message_broadcast
+    );
+  }
+
+  private async publishObservationForMessage(message: SocialMessageRecord): Promise<void> {
+    if (!this.identity || !this.profile || !this.canPublishMessageObservation()) {
+      return;
+    }
+    if (message.agent_id === this.identity.agent_id) {
+      return;
+    }
+    const existing = this.socialMessageObservations.find((item) => (
+      item.message_id === message.message_id && item.observer_agent_id === this.identity?.agent_id
+    ));
+    if (existing) {
+      return;
+    }
+    const observation = signSocialMessageObservation({
+      identity: this.identity,
+      observation_id: createHash("sha256")
+        .update(`${message.message_id}:${this.identity.agent_id}:${Date.now()}`, "utf8")
+        .digest("hex"),
+      message_id: message.message_id,
+      observed_agent_id: message.agent_id,
+      observer_display_name: this.profile.display_name,
+      observed_at: Date.now(),
+    });
+    this.ingestSocialMessageObservation(observation);
+    await this.publish(SOCIAL_MESSAGE_OBSERVATION_TOPIC, observation);
+    await this.persistSocialMessageObservations();
+  }
+
+  private normalizeIncomingSocialMessage(value: unknown): SocialMessageRecord | null {
+    if (typeof value !== "object" || value === null) {
+      return null;
+    }
+    const record = value as Partial<SocialMessageRecord>;
+    const body = this.normalizeSocialMessageBody(String(record.body || ""));
+    const agentId = String(record.agent_id || "").trim();
+    const displayName = String(record.display_name || "").trim();
+    const topic = String(record.topic || DEFAULT_SOCIAL_MESSAGE_CHANNEL).trim() || DEFAULT_SOCIAL_MESSAGE_CHANNEL;
+    const messageId = String(record.message_id || "").trim();
+    const createdAt = Number(record.created_at || 0);
+    if (
+      record.type !== SOCIAL_MESSAGE_TOPIC ||
+      !messageId ||
+      !agentId ||
+      typeof record.public_key !== "string" ||
+      !String(record.public_key).trim() ||
+      !body ||
+      typeof record.signature !== "string" ||
+      !String(record.signature).trim() ||
+      !Number.isFinite(createdAt) ||
+      body.length > SOCIAL_MESSAGE_MAX_BODY_CHARS
+    ) {
+      return null;
+    }
+    return {
+      type: SOCIAL_MESSAGE_TOPIC,
+      message_id: messageId,
+      agent_id: agentId,
+      public_key: String(record.public_key).trim(),
+      display_name: displayName || "Unnamed",
+      topic,
+      body,
+      created_at: createdAt,
+      signature: String(record.signature).trim(),
+    };
+  }
+
+  private normalizeSocialMessages(items: unknown): SocialMessageRecord[] {
+    if (!Array.isArray(items)) {
+      return [];
+    }
+    const deduped = new Set<string>();
+    return items
+      .map((item) => this.normalizeIncomingSocialMessage(item))
+      .filter((item): item is SocialMessageRecord => Boolean(item))
+      .sort((a, b) => b.created_at - a.created_at)
+      .filter((item) => {
+        if (deduped.has(item.message_id)) {
+          return false;
+        }
+        deduped.add(item.message_id);
+        return true;
+      })
+      .slice(0, SOCIAL_MESSAGE_HISTORY_LIMIT);
+  }
+
+  private normalizeIncomingSocialMessageObservation(value: unknown): SocialMessageObservationRecord | null {
+    if (typeof value !== "object" || value === null) {
+      return null;
+    }
+    const record = value as Partial<SocialMessageObservationRecord>;
+    const observationId = String(record.observation_id || "").trim();
+    const messageId = String(record.message_id || "").trim();
+    const observedAgentId = String(record.observed_agent_id || "").trim();
+    const observerAgentId = String(record.observer_agent_id || "").trim();
+    const observerDisplayName = String(record.observer_display_name || "").trim();
+    const observedAt = Number(record.observed_at || 0);
+    if (
+      record.type !== SOCIAL_MESSAGE_OBSERVATION_TOPIC ||
+      !observationId ||
+      !messageId ||
+      !observedAgentId ||
+      !observerAgentId ||
+      typeof record.observer_public_key !== "string" ||
+      !String(record.observer_public_key).trim() ||
+      typeof record.signature !== "string" ||
+      !String(record.signature).trim() ||
+      !Number.isFinite(observedAt)
+    ) {
+      return null;
+    }
+    return {
+      type: SOCIAL_MESSAGE_OBSERVATION_TOPIC,
+      observation_id: observationId,
+      message_id: messageId,
+      observed_agent_id: observedAgentId,
+      observer_agent_id: observerAgentId,
+      observer_public_key: String(record.observer_public_key).trim(),
+      observer_display_name: observerDisplayName || "Unnamed",
+      observed_at: observedAt,
+      signature: String(record.signature).trim(),
+    };
+  }
+
+  private normalizeSocialMessageObservations(items: unknown): SocialMessageObservationRecord[] {
+    if (!Array.isArray(items)) {
+      return [];
+    }
+    const deduped = new Set<string>();
+    return items
+      .map((item) => this.normalizeIncomingSocialMessageObservation(item))
+      .filter((item): item is SocialMessageObservationRecord => Boolean(item))
+      .sort((a, b) => b.observed_at - a.observed_at)
+      .filter((item) => {
+        if (deduped.has(item.observation_id)) {
+          return false;
+        }
+        deduped.add(item.observation_id);
+        return true;
+      })
+      .slice(0, SOCIAL_MESSAGE_OBSERVATION_HISTORY_LIMIT);
+  }
+
+  private ingestSocialMessage(message: SocialMessageRecord): void {
+    const existing = this.socialMessages.findIndex((item) => item.message_id === message.message_id);
+    if (existing >= 0) {
+      this.socialMessages[existing] = message;
+    } else {
+      this.socialMessages.unshift(message);
+    }
+    this.socialMessages = this.normalizeSocialMessages(this.socialMessages);
+  }
+
+  private ingestSocialMessageObservation(observation: SocialMessageObservationRecord): void {
+    const existing = this.socialMessageObservations.findIndex((item) => item.observation_id === observation.observation_id);
+    if (existing >= 0) {
+      this.socialMessageObservations[existing] = observation;
+    } else {
+      this.socialMessageObservations.unshift(observation);
+    }
+    this.socialMessageObservations = this.normalizeSocialMessageObservations(this.socialMessageObservations);
+  }
 }
 
 function sendOk<T>(res: Response, data: T, meta?: Record<string, unknown>) {
@@ -1589,7 +2614,7 @@ function renderBootstrapScript(payload: unknown): string {
 </script>`;
 }
 
-async function main() {
+export async function main() {
   const app = express();
   const port = Number(process.env.PORT || 4310);
   const staticDir = resolveLocalConsoleStaticDir();
@@ -1695,6 +2720,8 @@ async function main() {
   registerSocialRoutes(app, {
     getSocialConfigView: () => node.getSocialConfigView(),
     getIntegrationSummary: () => node.getIntegrationSummary(),
+    getMessageGovernanceView: () => node.getMessageGovernanceView(),
+    updateMessageGovernance: (input) => node.updateMessageGovernance(input),
     exportSocialTemplate: () => node.exportSocialTemplate(),
     setNetworkModeRuntime: (mode) => node.setNetworkModeRuntime(mode),
     reloadSocialConfig: () => node.reloadSocialConfig(),
@@ -1743,6 +2770,73 @@ async function main() {
     })
   );
 
+  app.post(
+    "/api/messages/broadcast",
+    asyncRoute(async (req, res) => {
+      const body = String(req.body?.body || "");
+      const topic = String(req.body?.topic || DEFAULT_SOCIAL_MESSAGE_CHANNEL);
+      const result = await node.sendSocialMessage(body, topic);
+      sendOk(res, result, {
+        message: result.sent ? "Message broadcast published" : `Message broadcast skipped: ${result.reason}`,
+      });
+    })
+  );
+
+  app.get("/api/messages", (req, res) => {
+    const limit = Number(req.query.limit ?? 50);
+    const agentId = String(req.query.agent_id ?? "").trim();
+    sendOk(res, node.getSocialMessages(limit, { agent_id: agentId || null }));
+  });
+
+  app.get("/api/openclaw/bridge", (_req, res) => {
+    sendOk(res, node.getOpenClawBridgeStatus());
+  });
+
+  app.get("/api/openclaw/bridge/config", (_req, res) => {
+    sendOk(res, node.getOpenClawBridgeConfig());
+  });
+
+  app.get("/api/openclaw/bridge/profile", (_req, res) => {
+    sendOk(res, node.getOpenClawBridgeProfile());
+  });
+
+  app.get("/api/openclaw/bridge/messages", (req, res) => {
+    const limit = Number(req.query.limit ?? 50);
+    const agentId = String(req.query.agent_id ?? "").trim();
+    sendOk(res, node.getSocialMessages(limit, { agent_id: agentId || null }));
+  });
+
+  app.post(
+    "/api/openclaw/bridge/message",
+    asyncRoute(async (req, res) => {
+      const body = String(req.body?.body || "");
+      const topic = String(req.body?.topic || DEFAULT_SOCIAL_MESSAGE_CHANNEL);
+      const result = await node.sendSocialMessage(body, topic);
+      sendOk(res, result, {
+        message: result.sent ? "OpenClaw bridge message published" : `OpenClaw bridge message skipped: ${result.reason}`,
+      });
+    })
+  );
+
+  app.post(
+    "/api/openclaw/bridge/skill-install",
+    asyncRoute(async (_req, res) => {
+      try {
+        const result = await node.installOpenClawSkill();
+        sendOk(res, result, {
+          message: "OpenClaw skill installed",
+        });
+      } catch (error) {
+        sendError(
+          res,
+          500,
+          "OPENCLAW_SKILL_INSTALL_FAILED",
+          error instanceof Error ? error.message : "OpenClaw skill install failed"
+        );
+      }
+    })
+  );
+
   app.post(
     "/api/cache/refresh",
     asyncRoute(async (_req, res) => {
@@ -1879,8 +2973,10 @@ async function main() {
   });
 }
 
-main().catch((error) => {
-  // eslint-disable-next-line no-console
-  console.error(error);
-  process.exit(1);
-});
+if (require.main === module) {
+  main().catch((error) => {
+    // eslint-disable-next-line no-console
+    console.error(error);
+    process.exit(1);
+  });
+}