@silicaclaw/cli 2026.3.19-2 → 2026.3.19-21

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

@@ -2,10 +2,11 @@ import express, { NextFunction, Request, Response } from "express";
 import cors from "cors";
 import { execFile, spawnSync } from "child_process";
 import { resolve } from "path";
-import { accessSync, constants, copyFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { accessSync, constants, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "fs";
 import { createHash } from "crypto";
-import { hostname } from "os";
+import { homedir, hostname } from "os";
 import { promisify } from "util";
+import defaults from "../../../config/silicaclaw-defaults.json";
 import {
   AgentIdentity,
   DirectoryState,
@@ -27,6 +28,7 @@ import {
   ingestPresenceRecord,
   ingestProfileRecord,
   isAgentOnline,
+  rebuildIndexForProfile,
   loadSocialConfig,
   getSocialConfigSearchPaths,
   resolveIdentityWithSocial,
@@ -78,14 +80,23 @@ const NETWORK_MAX_FUTURE_DRIFT_MS = Number(process.env.NETWORK_MAX_FUTURE_DRIFT_
 const NETWORK_MAX_PAST_DRIFT_MS = Number(process.env.NETWORK_MAX_PAST_DRIFT_MS || 120_000);
 const NETWORK_HEARTBEAT_INTERVAL_MS = Number(process.env.NETWORK_HEARTBEAT_INTERVAL_MS || 12_000);
 const NETWORK_PEER_STALE_AFTER_MS = Number(process.env.NETWORK_PEER_STALE_AFTER_MS || 45_000);
+const OPENCLAW_GATEWAY_HOST = "127.0.0.1";
+const DEFAULT_NETWORK_MODE = defaults.network.default_mode as "global-preview";
+const DEFAULT_NETWORK_NAMESPACE = defaults.network.default_namespace;
+const DEFAULT_NETWORK_PORT = defaults.ports.network_default;
+const DEFAULT_GLOBAL_SIGNALING_URL = defaults.network.global_preview.relay_url;
+const DEFAULT_GLOBAL_ROOM = defaults.network.global_preview.room;
+const DEFAULT_BRIDGE_API_BASE = defaults.bridge.api_base;
+const OPENCLAW_GATEWAY_PORT = defaults.ports.openclaw_gateway;
+const OPENCLAW_GATEWAY_URL = `http://${OPENCLAW_GATEWAY_HOST}:${OPENCLAW_GATEWAY_PORT}/`;
 const NETWORK_PEER_REMOVE_AFTER_MS = Number(process.env.NETWORK_PEER_REMOVE_AFTER_MS || 180_000);
 const NETWORK_UDP_BIND_ADDRESS = process.env.NETWORK_UDP_BIND_ADDRESS || "0.0.0.0";
 const NETWORK_UDP_BROADCAST_ADDRESS = process.env.NETWORK_UDP_BROADCAST_ADDRESS || "255.255.255.255";
 const NETWORK_PEER_ID = process.env.NETWORK_PEER_ID;
 const NETWORK_MODE = process.env.NETWORK_MODE || "";
-const WEBRTC_SIGNALING_URL = process.env.WEBRTC_SIGNALING_URL || "https://relay.silicaclaw.com";
+const WEBRTC_SIGNALING_URL = process.env.WEBRTC_SIGNALING_URL || DEFAULT_GLOBAL_SIGNALING_URL;
 const WEBRTC_SIGNALING_URLS = process.env.WEBRTC_SIGNALING_URLS || "";
-const WEBRTC_ROOM = process.env.WEBRTC_ROOM || "silicaclaw-global-preview";
+const WEBRTC_ROOM = process.env.WEBRTC_ROOM || DEFAULT_GLOBAL_ROOM;
 const WEBRTC_SEED_PEERS = process.env.WEBRTC_SEED_PEERS || "";
 const WEBRTC_BOOTSTRAP_HINTS = process.env.WEBRTC_BOOTSTRAP_HINTS || "";
 const PROFILE_VERSION = "v0.9";
@@ -102,6 +113,8 @@ const SOCIAL_MESSAGE_DUPLICATE_WINDOW_MS = Number(process.env.SOCIAL_MESSAGE_DUP
 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_REPLAY_WINDOW_MS = Number(process.env.SOCIAL_MESSAGE_REPLAY_WINDOW_MS || 10 * 60_000);
+const SOCIAL_MESSAGE_REPLAY_MAX_PER_BROADCAST = Number(process.env.SOCIAL_MESSAGE_REPLAY_MAX_PER_BROADCAST || 3);
 const SOCIAL_MESSAGE_BLOCKED_AGENT_IDS = new Set(
   dedupeStrings(parseListEnv(process.env.SOCIAL_MESSAGE_BLOCKED_AGENT_IDS || ""))
 );
@@ -129,6 +142,40 @@ function readWorkspaceVersion(workspaceRoot: string): string {
   return "unknown";
 }
 
+function normalizeVersionText(value: unknown): string {
+  const text = String(value || "").trim();
+  return text.startsWith("v") ? text.slice(1) : text;
+}
+
+function tokenizeVersion(value: unknown): Array<number | string> {
+  return normalizeVersionText(value)
+    .split(/[^0-9A-Za-z]+/)
+    .map((token) => token.trim())
+    .filter(Boolean)
+    .map((token) => (/^\d+$/.test(token) ? Number(token) : token.toLowerCase()));
+}
+
+function compareVersionTokens(left: unknown, right: unknown): number {
+  const leftTokens = tokenizeVersion(left);
+  const rightTokens = tokenizeVersion(right);
+  const maxLength = Math.max(leftTokens.length, rightTokens.length);
+  for (let index = 0; index < maxLength; index += 1) {
+    const leftToken = leftTokens[index];
+    const rightToken = rightTokens[index];
+    if (leftToken === undefined && rightToken === undefined) return 0;
+    if (leftToken === undefined) return -1;
+    if (rightToken === undefined) return 1;
+    if (typeof leftToken === "number" && typeof rightToken === "number") {
+      if (leftToken !== rightToken) return leftToken > rightToken ? 1 : -1;
+      continue;
+    }
+    const leftText = String(leftToken);
+    const rightText = String(rightToken);
+    if (leftText !== rightText) return leftText.localeCompare(rightText);
+  }
+  return 0;
+}
+
 function resolveWorkspaceRoot(cwd = process.cwd()): string {
   if (existsSync(resolve(cwd, "apps", "local-console", "package.json"))) {
     return cwd;
@@ -140,7 +187,28 @@ function resolveWorkspaceRoot(cwd = process.cwd()): string {
   return cwd;
 }
 
+function resolveProjectRoot(appRoot: string, cwd = process.cwd()): string {
+  const envRoot = String(process.env.SILICACLAW_WORKSPACE_DIR || "").trim();
+  if (envRoot) {
+    return resolve(envRoot);
+  }
+  if (
+    existsSync(resolve(appRoot, "apps", "local-console", "package.json")) &&
+    existsSync(resolve(appRoot, "package.json"))
+  ) {
+    return appRoot;
+  }
+  if (!existsSync(resolve(cwd, "apps", "local-console", "package.json"))) {
+    return resolve(cwd);
+  }
+  return appRoot;
+}
+
 function resolveStorageRoot(workspaceRoot: string, cwd = process.cwd()): string {
+  const home = process.env.HOME || homedir();
+  if (home) {
+    return resolve(home, ".silicaclaw", "local-console");
+  }
   const appRoot = resolve(workspaceRoot, "apps", "local-console");
   if (existsSync(resolve(appRoot, "package.json"))) {
     return appRoot;
@@ -148,6 +216,13 @@ function resolveStorageRoot(workspaceRoot: string, cwd = process.cwd()): string
   return cwd;
 }
 
+function defaultOpenClawSourceDir(rootDir: string): string {
+  if (existsSync(resolve(rootDir, "openclaw.mjs")) || existsSync(resolve(rootDir, "package.json"))) {
+    return rootDir;
+  }
+  return resolve(rootDir, "..", "openclaw");
+}
+
 function resolveExecutableInPath(binName: string): string | null {
   const pathValue = String(process.env.PATH || "").trim();
   if (!pathValue) return null;
@@ -169,6 +244,91 @@ function existingPathOrNull(filePath: string): string | null {
   return existsSync(filePath) ? filePath : null;
 }
 
+function listDirectories(root: string) {
+  if (!root || !existsSync(root)) return [];
+  try {
+    return readdirSync(root)
+      .map((name) => {
+        const fullPath = resolve(root, name);
+        try {
+          return statSync(fullPath).isDirectory() ? { name, path: fullPath } : null;
+        } catch {
+          return null;
+        }
+      })
+      .filter((item): item is { name: string; path: string } => Boolean(item));
+  } catch {
+    return [];
+  }
+}
+
+function readJsonFileSafe(filePath: string) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8")) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+function summarizeSkillReadme(filePath: string) {
+  if (!filePath || !existsSync(filePath)) return "";
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    const lines = raw
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .filter((line) => !line.startsWith("#"));
+    return String(lines[0] || "").slice(0, 220);
+  } catch {
+    return "";
+  }
+}
+
+function readDialogueCheatsheetPreview(filePath: string, limit = 6) {
+  if (!filePath || !existsSync(filePath)) return [];
+  try {
+    return readFileSync(filePath, "utf8")
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line.startsWith("- "))
+      .map((line) => line.slice(2).trim())
+      .filter(Boolean)
+      .slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+
+function readDialogueCheatsheetSections(filePath: string, maxSections = 3, maxItemsPerSection = 5) {
+  if (!filePath || !existsSync(filePath)) return [];
+  try {
+    const lines = readFileSync(filePath, "utf8").split(/\r?\n/);
+    const sections: Array<{ title: string; items: string[] }> = [];
+    let current: { title: string; items: string[] } | null = null;
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (line.startsWith("## ")) {
+        if (current && current.items.length) sections.push(current);
+        current = { title: line.slice(3).trim(), items: [] };
+        continue;
+      }
+      if (line.startsWith("- ")) {
+        if (!current) {
+          current = { title: "Examples", items: [] };
+        }
+        if (current.items.length < maxItemsPerSection) {
+          current.items.push(line.slice(2).trim());
+        }
+      }
+    }
+    if (current && current.items.length) sections.push(current);
+    return sections.slice(0, maxSections);
+  } catch {
+    return [];
+  }
+}
+
 function detectOpenClawInstallation(workspaceRoot: string) {
   const workspaceDir = resolve(workspaceRoot, ".openclaw");
   const homeDir = resolve(process.env.HOME || "", ".openclaw");
@@ -219,7 +379,52 @@ function detectOpenClawInstallation(workspaceRoot: string) {
   } as const;
 }
 
-function detectOpenClawRuntime() {
+function readOpenClawConfiguredGateway(workspaceRoot: string) {
+  const configuredSourceDir = String(process.env.OPENCLAW_SOURCE_DIR || "").trim();
+  const defaultSourceDir = defaultOpenClawSourceDir(workspaceRoot);
+  const sourceDir = configuredSourceDir || defaultSourceDir;
+  const homeDir = resolve(process.env.HOME || "", ".openclaw");
+  const explicitConfigPath = String(process.env.OPENCLAW_CONFIG_PATH || "").trim();
+  const explicitStateDir = String(process.env.OPENCLAW_STATE_DIR || "").trim();
+  const candidates = dedupeStrings([
+    explicitConfigPath,
+    explicitStateDir ? resolve(explicitStateDir, "openclaw.json") : "",
+    resolve(homeDir, "openclaw.json"),
+    resolve(homeDir, "clawdbot.json"),
+    resolve(sourceDir, ".openclaw", "openclaw.json"),
+  ]);
+
+  for (const candidate of candidates) {
+    if (!candidate || !existsSync(candidate)) continue;
+    try {
+      const raw = readFileSync(candidate, "utf8");
+      const portMatch = raw.match(/["']?port["']?\s*:\s*(\d{2,5})/);
+      const bindMatch = raw.match(/["']?bind["']?\s*:\s*["']([^"']+)["']/);
+      const port = portMatch ? Number(portMatch[1]) : OPENCLAW_GATEWAY_PORT;
+      if (!Number.isFinite(port) || port <= 0) continue;
+      return {
+        config_path: candidate,
+        gateway_port: port,
+        gateway_host: OPENCLAW_GATEWAY_HOST,
+        gateway_bind: bindMatch?.[1] || null,
+        gateway_url: `http://${OPENCLAW_GATEWAY_HOST}:${port}/`,
+      } as const;
+    } catch {
+      continue;
+    }
+  }
+
+  return {
+    config_path: null,
+    gateway_port: OPENCLAW_GATEWAY_PORT,
+    gateway_host: OPENCLAW_GATEWAY_HOST,
+    gateway_bind: null,
+    gateway_url: OPENCLAW_GATEWAY_URL,
+  } as const;
+}
+
+function detectOpenClawRuntime(workspaceRoot: string) {
+  const configuredGateway = readOpenClawConfiguredGateway(workspaceRoot);
   const result = spawnSync("ps", ["-Ao", "pid=,ppid=,command="], {
     encoding: "utf8",
   });
@@ -252,11 +457,84 @@ function detectOpenClawRuntime() {
     })
     .filter((item): item is { pid: number; ppid: number; command: string } => Boolean(item));
 
+  const openclawPids = new Set(processes.map((item) => item.pid));
+  const gatewayProbe = spawnSync("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN"], {
+    encoding: "utf8",
+  });
+  const gatewayLines = String(gatewayProbe.stdout || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const gatewayListeners = gatewayLines
+    .slice(1)
+    .map((line) => {
+      const parts = line.split(/\s+/);
+      const pid = Number(parts[1] || 0);
+      const command = parts[0] || "";
+      const lowerCommand = command.toLowerCase();
+      const endpoint = parts[8] || parts[parts.length - 1] || "";
+      const portMatch = endpoint.match(/:(\d+)(?:\s*\(|$)/);
+      if (!pid || !command || !portMatch) return null;
+      const isOpenClawListener =
+        openclawPids.has(pid) ||
+        lowerCommand.includes("openclaw");
+      if (!isOpenClawListener) return null;
+      const port = Number(portMatch[1]);
+      if (!Number.isFinite(port) || port <= 0) return null;
+      return {
+        pid,
+        ppid: 0,
+        port,
+        command: `${command} listening on ${OPENCLAW_GATEWAY_HOST}:${port}`,
+      };
+    })
+    .filter((item): item is { pid: number; ppid: number; port: number; command: string } => Boolean(item));
+  const preferredListener =
+    gatewayListeners.find((item) => item.port === configuredGateway.gateway_port) ||
+    gatewayListeners[0] ||
+    null;
+
+  const combinedProcesses = new Map<number, { pid: number; ppid: number; command: string }>();
+  for (const process of [...processes, ...gatewayListeners]) {
+    if (!combinedProcesses.has(process.pid)) {
+      combinedProcesses.set(process.pid, process);
+      continue;
+    }
+    const current = combinedProcesses.get(process.pid);
+    if (current && current.command.length < process.command.length) {
+      combinedProcesses.set(process.pid, process);
+    }
+  }
+  const allProcesses = Array.from(combinedProcesses.values());
+  const gatewayReachable = gatewayListeners.length > 0;
+  const detectionNotes = [];
+  if (result.status !== 0) detectionNotes.push(String(result.stderr || "ps failed").trim());
+  if (gatewayProbe.status !== 0 && gatewayLines.length === 0) {
+    detectionNotes.push(String(gatewayProbe.stderr || "lsof failed").trim());
+  }
+  const gatewayPort = preferredListener?.port || configuredGateway.gateway_port;
+  const gatewayUrl = `http://${OPENCLAW_GATEWAY_HOST}:${gatewayPort}/`;
+
   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"),
+    running: allProcesses.length > 0 || gatewayReachable,
+    process_count: allProcesses.length,
+    processes: allProcesses.slice(0, 10),
+    detection_error: detectionNotes.filter(Boolean).join(" | ") || null,
+    gateway_url: gatewayUrl,
+    gateway_port: gatewayPort,
+    gateway_reachable: gatewayReachable,
+    configured_gateway_url: configuredGateway.gateway_url,
+    configured_gateway_port: configuredGateway.gateway_port,
+    configured_gateway_bind: configuredGateway.gateway_bind,
+    configured_gateway_config_path: configuredGateway.config_path,
+    detection_mode:
+      processes.length > 0 && gatewayReachable
+        ? "process+gateway"
+        : gatewayReachable
+          ? "gateway"
+          : processes.length > 0
+            ? "process"
+            : "not_running",
   } as const;
 }
 
@@ -291,7 +569,7 @@ function detectOwnerDeliveryStatus(params: {
   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 defaultSourceDir = defaultOpenClawSourceDir(params.workspaceRoot);
   const openclawSourceDir = configuredSourceDir || defaultSourceDir;
   const openclawSourceEntry = existingPathOrNull(resolve(openclawSourceDir, "openclaw.mjs"));
   const openclawCommandResolvable = Boolean(explicitOpenClawBin || resolveExecutableInPath("openclaw") || openclawSourceEntry);
@@ -350,10 +628,15 @@ function hasMeaningfulJson(filePath: string): boolean {
   }
 }
 
-function migrateLegacyDataIfNeeded(workspaceRoot: string, storageRoot: string): void {
-  const legacyDataDir = resolve(workspaceRoot, "data");
+function migrateLegacyDataIfNeeded(appRoot: string, projectRoot: string, storageRoot: string): void {
   const targetDataDir = resolve(storageRoot, "data");
-  if (legacyDataDir === targetDataDir) return;
+  const legacyDataDirs = [
+    resolve(appRoot, "data"),
+    resolve(appRoot, "apps", "local-console", "data"),
+    resolve(projectRoot, "data"),
+    resolve(projectRoot, "apps", "local-console", "data"),
+    resolve(process.cwd(), "data"),
+  ].filter((dir, index, list) => list.indexOf(dir) === index && dir !== targetDataDir);
   const files = [
     "identity.json",
     "profile.json",
@@ -363,13 +646,38 @@ function migrateLegacyDataIfNeeded(workspaceRoot: string, storageRoot: string):
     "social-message-observations.json",
   ];
   for (const file of files) {
-    const src = resolve(legacyDataDir, file);
     const dst = resolve(targetDataDir, file);
-    if (!existsSync(src)) continue;
     if (hasMeaningfulJson(dst)) continue;
-    if (!hasMeaningfulJson(src)) continue;
-    mkdirSync(targetDataDir, { recursive: true });
-    copyFileSync(src, dst);
+    for (const legacyDataDir of legacyDataDirs) {
+      const src = resolve(legacyDataDir, file);
+      if (!existsSync(src)) continue;
+      if (!hasMeaningfulJson(src)) continue;
+      mkdirSync(targetDataDir, { recursive: true });
+      copyFileSync(src, dst);
+      break;
+    }
+  }
+
+  const targetDotDir = resolve(storageRoot, ".silicaclaw");
+  const legacyDotDirs = [
+    resolve(appRoot, ".silicaclaw"),
+    resolve(appRoot, "apps", "local-console", ".silicaclaw"),
+    resolve(projectRoot, ".silicaclaw"),
+    resolve(projectRoot, "apps", "local-console", ".silicaclaw"),
+    resolve(process.cwd(), ".silicaclaw"),
+  ].filter((dir, index, list) => list.indexOf(dir) === index && dir !== targetDotDir);
+  const dotFiles = ["social.runtime.json", "social.message-governance.json"];
+  for (const file of dotFiles) {
+    const dst = resolve(targetDotDir, file);
+    if (hasMeaningfulJson(dst)) continue;
+    for (const legacyDotDir of legacyDotDirs) {
+      const src = resolve(legacyDotDir, file);
+      if (!existsSync(src)) continue;
+      if (!hasMeaningfulJson(src)) continue;
+      mkdirSync(targetDotDir, { recursive: true });
+      copyFileSync(src, dst);
+      break;
+    }
   }
 }
 
@@ -462,6 +770,14 @@ type OpenClawBridgeStatus = {
       command: string;
     }>;
     detection_error: string | null;
+    gateway_url: string;
+    gateway_port: number;
+    gateway_reachable: boolean;
+    configured_gateway_url: string;
+    configured_gateway_port: number;
+    configured_gateway_bind: string | null;
+    configured_gateway_config_path: string | null;
+    detection_mode: "process" | "gateway" | "process+gateway" | "not_running";
   };
   skill_learning: {
     available: boolean;
@@ -507,6 +823,10 @@ type OpenClawBridgeConfigView = {
   bridge_api_base: string;
   openclaw_detected: boolean;
   openclaw_running: boolean;
+  openclaw_gateway_host: string;
+  openclaw_gateway_port: number;
+  openclaw_gateway_url: string;
+  openclaw_gateway_config_path: string | null;
   openclaw_workspace_skill_dir: string;
   openclaw_legacy_skill_dir: string;
   silicaclaw_env_template_path: string;
@@ -525,6 +845,7 @@ type OpenClawBridgeConfigView = {
 
 export class LocalNodeService {
   private workspaceRoot: string;
+  private projectRoot: string;
   private storageRoot: string;
   private identityRepo: IdentityRepo;
   private profileRepo: ProfileRepo;
@@ -567,7 +888,7 @@ export class LocalNodeService {
 
   private network: NetworkAdapter;
   private adapterMode: "mock" | "local-event-bus" | "real-preview" | "webrtc-preview" | "relay-preview";
-  private networkMode: "local" | "lan" | "global-preview" = "global-preview";
+  private networkMode: "local" | "lan" | "global-preview" = DEFAULT_NETWORK_MODE;
   private networkNamespace: string;
   private networkPort: number | null;
   private socialConfig: SocialConfig;
@@ -581,17 +902,18 @@ export class LocalNodeService {
     "silicaclaw-existing";
   private resolvedOpenClawIdentityPath: string | null = null;
   private webrtcSignalingUrls: string[] = [];
-  private webrtcRoom = "silicaclaw-global-preview";
+  private webrtcRoom = DEFAULT_GLOBAL_ROOM;
   private webrtcSeedPeers: string[] = [];
   private webrtcBootstrapHints: string[] = [];
   private webrtcBootstrapSources: string[] = [];
   private appVersion = "unknown";
 
-  constructor(options?: { workspaceRoot?: string; storageRoot?: string }) {
+  constructor(options?: { workspaceRoot?: string; projectRoot?: string; storageRoot?: string }) {
     this.workspaceRoot = options?.workspaceRoot || resolveWorkspaceRoot();
+    this.projectRoot = options?.projectRoot || resolveProjectRoot(this.workspaceRoot);
     this.storageRoot = options?.storageRoot || resolveStorageRoot(this.workspaceRoot);
     this.appVersion = readWorkspaceVersion(this.workspaceRoot);
-    migrateLegacyDataIfNeeded(this.workspaceRoot, this.storageRoot);
+    migrateLegacyDataIfNeeded(this.workspaceRoot, this.projectRoot, this.storageRoot);
 
     this.identityRepo = new IdentityRepo(this.storageRoot);
     this.profileRepo = new ProfileRepo(this.storageRoot);
@@ -603,16 +925,16 @@ export class LocalNodeService {
     this.socialRuntimeRepo = new SocialRuntimeRepo(this.storageRoot);
     this.messageGovernance = this.defaultMessageGovernance();
 
-    let loadedSocial = loadSocialConfig(this.workspaceRoot);
+    let loadedSocial = loadSocialConfig(this.projectRoot);
     if (!loadedSocial.meta.found) {
-      ensureDefaultSocialMd(this.workspaceRoot, {
+      ensureDefaultSocialMd(this.projectRoot, {
         display_name: this.getDefaultDisplayName(),
         bio: "Local AI agent connected to SilicaClaw",
         tags: ["openclaw", "local-first"],
-        mode: "global-preview",
+        mode: DEFAULT_NETWORK_MODE,
         public_enabled: false,
       });
-      loadedSocial = loadSocialConfig(this.workspaceRoot);
+      loadedSocial = loadSocialConfig(this.projectRoot);
       this.initState.social_auto_created = true;
     }
     this.socialConfig = loadedSocial.config;
@@ -621,8 +943,8 @@ export class LocalNodeService {
     this.socialParseError = loadedSocial.meta.parse_error;
     this.socialRawFrontmatter = loadedSocial.raw_frontmatter;
 
-    this.networkNamespace = this.socialConfig.network.namespace || process.env.NETWORK_NAMESPACE || "silicaclaw.preview";
-    this.networkPort = Number(this.socialConfig.network.port || process.env.NETWORK_PORT || 44123);
+    this.networkNamespace = this.socialConfig.network.namespace || process.env.NETWORK_NAMESPACE || DEFAULT_NETWORK_NAMESPACE;
+    this.networkPort = Number(this.socialConfig.network.port || process.env.NETWORK_PORT || DEFAULT_NETWORK_PORT);
     this.applyResolvedNetworkConfig();
     const resolved = this.buildNetworkAdapter();
     this.network = resolved.adapter;
@@ -674,12 +996,8 @@ export class LocalNodeService {
   }
 
   getOverview() {
-    this.ensureLocalDirectoryBaseline();
-    this.compactCacheInMemory();
-    const profiles = Object.values(this.directory.profiles);
-    const onlineCount = profiles.filter((profile) =>
-      isAgentOnline(this.directory.presence[profile.agent_id], Date.now(), PRESENCE_TTL_MS)
-    ).length;
+    const discovered = this.search("");
+    const onlineCount = discovered.filter((profile) => profile.online).length;
 
     return {
       app_version: this.appVersion,
@@ -690,9 +1008,9 @@ export class LocalNodeService {
       last_broadcast_error_at: this.lastBroadcastErrorAt,
       last_broadcast_error: this.lastBroadcastError,
       broadcast_failure_count: this.broadcastFailureCount,
-      discovered_count: profiles.length,
+      discovered_count: discovered.length,
       online_count: onlineCount,
-      offline_count: Math.max(0, profiles.length - onlineCount),
+      offline_count: Math.max(0, discovered.length - onlineCount),
       init_state: this.initState,
       presence_ttl_ms: PRESENCE_TTL_MS,
       onboarding: this.getOnboardingSummary(),
@@ -714,7 +1032,9 @@ export class LocalNodeService {
   }
 
   getNetworkSummary() {
-    const diagnostics = this.getAdapterDiagnostics();
+    const network = this.getResolvedRealtimeNetworkSummary();
+    const diagnostics = network.diagnostics;
+    const relayCapable = this.adapterMode === "webrtc-preview" || this.adapterMode === "relay-preview";
     const peerCount = diagnostics?.peers.total ?? 0;
 
     return {
@@ -742,30 +1062,32 @@ export class LocalNodeService {
       real_preview_stats: diagnostics?.stats ?? null,
       real_preview_transport_stats: diagnostics?.transport_stats ?? null,
       real_preview_discovery_stats: diagnostics?.discovery_stats ?? null,
-      webrtc_preview: diagnostics && (diagnostics.adapter === "webrtc-preview" || diagnostics.adapter === "relay-preview")
+      webrtc_preview: relayCapable
         ? {
-            signaling_url: diagnostics.signaling_url ?? null,
-            signaling_endpoints: diagnostics.signaling_endpoints ?? [],
-            room: diagnostics.room ?? null,
-            bootstrap_sources: diagnostics.bootstrap_sources ?? [],
-            seed_peers_count: diagnostics.seed_peers_count ?? 0,
-            discovery_events_total: diagnostics.discovery_events_total ?? 0,
-            last_discovery_event_at: diagnostics.last_discovery_event_at ?? 0,
-            active_webrtc_peers: diagnostics.active_webrtc_peers ?? 0,
-            reconnect_attempts_total: diagnostics.reconnect_attempts_total ?? 0,
-            last_join_at: diagnostics.last_join_at ?? 0,
-            last_poll_at: diagnostics.last_poll_at ?? 0,
-            last_publish_at: diagnostics.last_publish_at ?? 0,
-            last_peer_refresh_at: diagnostics.last_peer_refresh_at ?? 0,
-            last_error_at: diagnostics.last_error_at ?? 0,
-            last_error: diagnostics.last_error ?? null,
+            signaling_url: network.signaling_url,
+            signaling_endpoints: network.signaling_endpoints,
+            room: network.room,
+            bootstrap_sources: network.bootstrap_sources,
+            seed_peers_count: network.seed_peers_count,
+            discovery_events_total: diagnostics?.discovery_events_total ?? 0,
+            last_discovery_event_at: diagnostics?.last_discovery_event_at ?? 0,
+            active_webrtc_peers: diagnostics?.active_webrtc_peers ?? 0,
+            reconnect_attempts_total: diagnostics?.reconnect_attempts_total ?? 0,
+            last_join_at: diagnostics?.last_join_at ?? 0,
+            last_poll_at: diagnostics?.last_poll_at ?? 0,
+            last_publish_at: diagnostics?.last_publish_at ?? 0,
+            last_peer_refresh_at: diagnostics?.last_peer_refresh_at ?? 0,
+            last_error_at: diagnostics?.last_error_at ?? 0,
+            last_error: diagnostics?.last_error ?? null,
           }
         : null,
     };
   }
 
   getNetworkConfig() {
-    const diagnostics = this.getAdapterDiagnostics();
+    const network = this.getResolvedRealtimeNetworkSummary();
+    const diagnostics = network.diagnostics;
+    const relayCapable = this.adapterMode === "webrtc-preview" || this.adapterMode === "relay-preview";
     return {
       adapter: this.adapterMode,
       mode: this.networkMode,
@@ -779,23 +1101,23 @@ export class LocalNodeService {
       },
       limits: diagnostics?.limits ?? null,
       adapter_config: diagnostics?.config ?? null,
-      adapter_extra: diagnostics && (diagnostics.adapter === "webrtc-preview" || diagnostics.adapter === "relay-preview")
+      adapter_extra: relayCapable
         ? {
-            signaling_url: diagnostics.signaling_url ?? null,
-            signaling_endpoints: diagnostics.signaling_endpoints ?? [],
-            room: diagnostics.room ?? null,
-            bootstrap_sources: diagnostics.bootstrap_sources ?? [],
-            seed_peers_count: diagnostics.seed_peers_count ?? 0,
-            discovery_events_total: diagnostics.discovery_events_total ?? 0,
-            last_discovery_event_at: diagnostics.last_discovery_event_at ?? 0,
-            connection_states_summary: diagnostics.connection_states_summary ?? null,
-            datachannel_states_summary: diagnostics.datachannel_states_summary ?? null,
-            last_join_at: diagnostics.last_join_at ?? 0,
-            last_poll_at: diagnostics.last_poll_at ?? 0,
-            last_publish_at: diagnostics.last_publish_at ?? 0,
-            last_peer_refresh_at: diagnostics.last_peer_refresh_at ?? 0,
-            last_error_at: diagnostics.last_error_at ?? 0,
-            last_error: diagnostics.last_error ?? null,
+            signaling_url: network.signaling_url,
+            signaling_endpoints: network.signaling_endpoints,
+            room: network.room,
+            bootstrap_sources: network.bootstrap_sources,
+            seed_peers_count: network.seed_peers_count,
+            discovery_events_total: diagnostics?.discovery_events_total ?? 0,
+            last_discovery_event_at: diagnostics?.last_discovery_event_at ?? 0,
+            connection_states_summary: diagnostics?.connection_states_summary ?? null,
+            datachannel_states_summary: diagnostics?.datachannel_states_summary ?? null,
+            last_join_at: diagnostics?.last_join_at ?? 0,
+            last_poll_at: diagnostics?.last_poll_at ?? 0,
+            last_publish_at: diagnostics?.last_publish_at ?? 0,
+            last_peer_refresh_at: diagnostics?.last_peer_refresh_at ?? 0,
+            last_error_at: diagnostics?.last_error_at ?? 0,
+            last_error: diagnostics?.last_error ?? null,
           }
         : null,
       env: {
@@ -830,7 +1152,9 @@ export class LocalNodeService {
   }
 
   getNetworkStats() {
-    const diagnostics = this.getAdapterDiagnostics();
+    const network = this.getResolvedRealtimeNetworkSummary();
+    const diagnostics = network.diagnostics;
+    const relayCapable = this.adapterMode === "webrtc-preview" || this.adapterMode === "relay-preview";
     const peers: Array<{ status?: string }> = diagnostics?.peers?.items ?? [];
     const online = peers.filter((peer: { status?: string }) => peer.status === "online").length;
 
@@ -857,34 +1181,35 @@ export class LocalNodeService {
       adapter_stats: diagnostics?.stats ?? null,
       adapter_transport_stats: diagnostics?.transport_stats ?? null,
       adapter_discovery_stats: diagnostics?.discovery_stats ?? null,
-      adapter_diagnostics_summary: diagnostics
+      adapter_diagnostics_summary: relayCapable || diagnostics
         ? {
-            signaling_url: diagnostics.signaling_url ?? null,
-            signaling_endpoints: diagnostics.signaling_endpoints ?? [],
-            room: diagnostics.room ?? null,
-            bootstrap_sources: diagnostics.bootstrap_sources ?? [],
-            seed_peers_count: diagnostics.seed_peers_count ?? 0,
-            discovery_events_total: diagnostics.discovery_events_total ?? 0,
-            last_discovery_event_at: diagnostics.last_discovery_event_at ?? 0,
-            connection_states_summary: diagnostics.connection_states_summary ?? null,
-            datachannel_states_summary: diagnostics.datachannel_states_summary ?? null,
-            signaling_messages_sent_total: diagnostics.signaling_messages_sent_total ?? null,
-            signaling_messages_received_total: diagnostics.signaling_messages_received_total ?? null,
-            reconnect_attempts_total: diagnostics.reconnect_attempts_total ?? null,
-            active_webrtc_peers: diagnostics.active_webrtc_peers ?? null,
-            last_join_at: diagnostics.last_join_at ?? 0,
-            last_poll_at: diagnostics.last_poll_at ?? 0,
-            last_publish_at: diagnostics.last_publish_at ?? 0,
-            last_peer_refresh_at: diagnostics.last_peer_refresh_at ?? 0,
-            last_error_at: diagnostics.last_error_at ?? 0,
-            last_error: diagnostics.last_error ?? null,
+            signaling_url: network.signaling_url,
+            signaling_endpoints: network.signaling_endpoints,
+            room: network.room,
+            bootstrap_sources: network.bootstrap_sources,
+            seed_peers_count: network.seed_peers_count,
+            discovery_events_total: diagnostics?.discovery_events_total ?? 0,
+            last_discovery_event_at: diagnostics?.last_discovery_event_at ?? 0,
+            connection_states_summary: diagnostics?.connection_states_summary ?? null,
+            datachannel_states_summary: diagnostics?.datachannel_states_summary ?? null,
+            signaling_messages_sent_total: diagnostics?.signaling_messages_sent_total ?? null,
+            signaling_messages_received_total: diagnostics?.signaling_messages_received_total ?? null,
+            reconnect_attempts_total: diagnostics?.reconnect_attempts_total ?? null,
+            active_webrtc_peers: diagnostics?.active_webrtc_peers ?? null,
+            last_join_at: diagnostics?.last_join_at ?? 0,
+            last_poll_at: diagnostics?.last_poll_at ?? 0,
+            last_publish_at: diagnostics?.last_publish_at ?? 0,
+            last_peer_refresh_at: diagnostics?.last_peer_refresh_at ?? 0,
+            last_error_at: diagnostics?.last_error_at ?? 0,
+            last_error: diagnostics?.last_error ?? null,
           }
         : null,
     };
   }
 
   getPeersSummary() {
-    const diagnostics = this.getAdapterDiagnostics();
+    const network = this.getResolvedRealtimeNetworkSummary();
+    const diagnostics = network.diagnostics;
     if (!diagnostics) {
       return {
         adapter: this.adapterMode,
@@ -907,11 +1232,11 @@ export class LocalNodeService {
       components: diagnostics.components,
       limits: diagnostics.limits,
       diagnostics_summary: {
-        signaling_url: diagnostics.signaling_url ?? null,
-        signaling_endpoints: diagnostics.signaling_endpoints ?? [],
-        room: diagnostics.room ?? null,
-        bootstrap_sources: diagnostics.bootstrap_sources ?? [],
-        seed_peers_count: diagnostics.seed_peers_count ?? 0,
+        signaling_url: network.signaling_url,
+        signaling_endpoints: network.signaling_endpoints,
+        room: network.room,
+        bootstrap_sources: network.bootstrap_sources,
+        seed_peers_count: network.seed_peers_count,
         discovery_events_total: diagnostics.discovery_events_total ?? 0,
         last_discovery_event_at: diagnostics.last_discovery_event_at ?? 0,
         connection_states_summary: diagnostics.connection_states_summary ?? null,
@@ -958,11 +1283,12 @@ export class LocalNodeService {
   getRuntimePaths() {
     return {
       workspace_root: this.workspaceRoot,
+      project_root: this.projectRoot,
       storage_root: this.storageRoot,
       data_dir: resolve(this.storageRoot, "data"),
       social_runtime_path: resolve(this.storageRoot, ".silicaclaw", "social.runtime.json"),
       local_console_public_dir: resolve(this.workspaceRoot, "apps", "local-console", "public"),
-      social_lookup_paths: getSocialConfigSearchPaths(this.workspaceRoot),
+      social_lookup_paths: getSocialConfigSearchPaths(this.projectRoot),
       social_source_path: this.socialSourcePath,
     };
   }
@@ -1070,20 +1396,36 @@ export class LocalNodeService {
   }
 
   async setNetworkModeRuntime(mode: "local" | "lan" | "global-preview") {
-    const currentMode = this.networkMode;
+    const before = {
+      mode: this.networkMode,
+      adapter: this.adapterMode,
+      namespace: this.networkNamespace,
+      port: this.networkPort,
+    };
     if (mode !== "local" && mode !== "lan" && mode !== "global-preview") {
       throw new Error("invalid_network_mode");
     }
     this.socialConfig.network.mode = mode;
     this.socialConfig.network.adapter = this.adapterForMode(mode);
     this.applyResolvedNetworkConfig();
-    this.socialNetworkRequiresRestart = currentMode !== mode || this.adapterMode !== this.socialConfig.network.adapter;
+
+    const needsRestart =
+      before.mode !== this.networkMode ||
+      before.adapter !== this.socialConfig.network.adapter ||
+      before.namespace !== this.networkNamespace ||
+      (before.port ?? null) !== (this.networkPort ?? null);
+
+    if (needsRestart) {
+      await this.restartNetworkAdapter("set_network_mode_runtime");
+    }
+
+    this.socialNetworkRequiresRestart = false;
     await this.writeSocialRuntime();
     return {
       mode: this.networkMode,
-      adapter: this.socialConfig.network.adapter,
-      network_requires_restart: this.socialNetworkRequiresRestart,
-      note: "Runtime mode updated. Existing social.md is unchanged.",
+      adapter: this.adapterMode,
+      network_requires_restart: false,
+      note: "Runtime mode updated and adapter restarted. Existing social.md is unchanged.",
     };
   }
 
@@ -1098,7 +1440,7 @@ export class LocalNodeService {
     this.socialConfig.network.adapter = "relay-preview";
     this.socialConfig.network.signaling_url = signalingUrl;
     this.socialConfig.network.signaling_urls = [signalingUrl];
-    this.socialConfig.network.room = room || "silicaclaw-global-preview";
+    this.socialConfig.network.room = room || DEFAULT_GLOBAL_ROOM;
     this.applyResolvedNetworkConfig();
     await this.restartNetworkAdapter("quick_connect_global_preview");
     this.socialNetworkRequiresRestart = false;
@@ -1123,7 +1465,7 @@ export class LocalNodeService {
       port: this.networkPort,
     };
 
-    const loaded = loadSocialConfig(this.workspaceRoot);
+    const loaded = loadSocialConfig(this.projectRoot);
     this.socialConfig = loaded.config;
     this.socialSourcePath = loaded.meta.source_path;
     this.socialFound = loaded.meta.found;
@@ -1145,13 +1487,18 @@ export class LocalNodeService {
       before.namespace !== after.namespace ||
       (before.port ?? null) !== (after.port ?? null);
 
+    if (this.socialNetworkRequiresRestart) {
+      await this.restartNetworkAdapter("reload_social_config");
+      this.socialNetworkRequiresRestart = false;
+    }
+
     await this.writeSocialRuntime();
 
     return this.getSocialConfigView();
   }
 
   async generateDefaultSocialMd() {
-    const result = ensureDefaultSocialMd(this.workspaceRoot, {
+    const result = ensureDefaultSocialMd(this.projectRoot, {
       display_name: this.getDefaultDisplayName(),
       bio: "Local AI agent connected to SilicaClaw",
       tags: ["openclaw", "local-first"],
@@ -1178,10 +1525,11 @@ export class LocalNodeService {
   search(keyword: string): PublicProfileSummary[] {
     this.ensureLocalDirectoryBaseline();
     this.compactCacheInMemory();
-    return searchDirectory(this.directory, keyword, { presenceTTLms: PRESENCE_TTL_MS }).map((profile) => {
+    const directMatches = searchDirectory(this.directory, keyword, { presenceTTLms: PRESENCE_TTL_MS }).map((profile) => {
       const lastSeenAt = this.directory.presence[profile.agent_id] ?? 0;
       return this.toPublicProfileSummary(profile, { last_seen_at: lastSeenAt });
     });
+    return this.mergeMessageOnlyAgentSummaries(directMatches, keyword);
   }
 
   getPublicProfilePreview(): PublicProfileSummary | null {
@@ -1259,11 +1607,11 @@ export class LocalNodeService {
 
   getOpenClawBridgeStatus(): OpenClawBridgeStatus {
     const integration = this.getIntegrationStatus();
-    const openclawInstallation = detectOpenClawInstallation(this.workspaceRoot);
-    const openclawRuntime = detectOpenClawRuntime();
+    const openclawInstallation = detectOpenClawInstallation(this.projectRoot);
+    const openclawRuntime = detectOpenClawRuntime(this.projectRoot);
     const skillInstallation = detectOpenClawSkillInstallation();
     const ownerDelivery = detectOwnerDeliveryStatus({
-      workspaceRoot: this.workspaceRoot,
+      workspaceRoot: this.projectRoot,
       connectedToSilicaclaw: integration.connected_to_silicaclaw,
       openclawRunning: openclawRuntime.running,
       skillInstalled: skillInstallation.installed,
@@ -1326,11 +1674,15 @@ export class LocalNodeService {
     };
   }
 
-  async installOpenClawSkill() {
+  async installOpenClawSkill(skillName?: string) {
     const scriptPath = resolve(this.workspaceRoot, "scripts", "install-openclaw-skill.mjs");
-    const { stdout } = await execFileAsync(process.execPath, [scriptPath], {
+    const args = [scriptPath];
+    if (skillName) {
+      args.push(`--skill=${skillName}`);
+    }
+    const { stdout } = await execFileAsync(process.execPath, args, {
       cwd: this.workspaceRoot,
-      env: process.env,
+      env: { ...process.env, SILICACLAW_WORKSPACE_DIR: this.projectRoot },
       maxBuffer: 1024 * 1024,
     });
     const parsed = JSON.parse(String(stdout || "{}"));
@@ -1354,16 +1706,21 @@ export class LocalNodeService {
     const homeDir = resolve(process.env.HOME || "", ".openclaw");
     const workspaceSkillDir = resolve(homeDir, "workspace", "skills");
     const legacySkillDir = resolve(homeDir, "skills");
-    const openclawSourceDir = resolve(this.workspaceRoot, "..", "openclaw");
+    const openclawSourceDir = defaultOpenClawSourceDir(this.projectRoot);
+    const openclawRuntime = detectOpenClawRuntime(this.projectRoot);
 
     return {
-      bridge_api_base: "http://localhost:4310",
-      openclaw_detected: detectOpenClawInstallation(this.workspaceRoot).detected,
-      openclaw_running: detectOpenClawRuntime().running,
+      bridge_api_base: DEFAULT_BRIDGE_API_BASE,
+      openclaw_detected: detectOpenClawInstallation(this.projectRoot).detected,
+      openclaw_running: openclawRuntime.running,
+      openclaw_gateway_host: OPENCLAW_GATEWAY_HOST,
+      openclaw_gateway_port: openclawRuntime.configured_gateway_port,
+      openclaw_gateway_url: openclawRuntime.configured_gateway_url,
+      openclaw_gateway_config_path: openclawRuntime.configured_gateway_config_path,
       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_skill_name: "silicaclaw-bridge-setup",
       recommended_install_command: "silicaclaw openclaw-skill-install",
       recommended_owner_forward_env: {
         OPENCLAW_SOURCE_DIR: openclawSourceDir,
@@ -1381,13 +1738,143 @@ export class LocalNodeService {
       ].join(" "),
       notes: [
         "Install and maintain the skill from SilicaClaw; do not edit OpenClaw core source for this integration.",
+        "Use silicaclaw-bridge-setup first when OpenClaw still needs local install, readiness checks, or troubleshooting guidance.",
         "OpenClaw learns broadcasts via the installed skill under ~/.openclaw/workspace/skills/.",
+        "Runtime detection prefers the actual OpenClaw gateway listener port, then falls back to OpenClaw's own openclaw.json gateway.port.",
         "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.",
       ],
     };
   }
 
+  getSkillsView() {
+    const bundledRoot = resolve(this.workspaceRoot, "openclaw-skills");
+    const openclawHome = resolve(process.env.HOME || "", ".openclaw");
+    const workspaceInstallRoot = resolve(openclawHome, "workspace", "skills");
+    const legacyInstallRoot = resolve(openclawHome, "skills");
+    const bridge = this.getOpenClawBridgeStatus();
+    const bundledSkills = listDirectories(bundledRoot).map((dir) => {
+      const manifestPath = resolve(dir.path, "manifest.json");
+      const skillPath = resolve(dir.path, "SKILL.md");
+      const versionPath = resolve(dir.path, "VERSION");
+      const manifest = readJsonFileSafe(manifestPath);
+      const references = (manifest?.references && typeof manifest.references === "object")
+        ? manifest.references as Record<string, unknown>
+        : null;
+      const ownerDialogueCheatsheetPath = references?.owner_dialogue_cheatsheet_zh
+        ? resolve(dir.path, String(references.owner_dialogue_cheatsheet_zh))
+        : null;
+      const name = String(manifest?.name || dir.name);
+      const capabilities = Array.isArray(manifest?.capabilities)
+        ? manifest.capabilities.map((item) => String(item))
+        : [];
+      const installedWorkspacePath = resolve(workspaceInstallRoot, name);
+      const installedLegacyPath = resolve(legacyInstallRoot, name);
+      const installedInWorkspace = existsSync(installedWorkspacePath);
+      const installedInLegacy = existsSync(installedLegacyPath);
+      return {
+        key: name,
+        name,
+        display_name: String(manifest?.display_name || name),
+        description: String(manifest?.description || summarizeSkillReadme(skillPath) || ""),
+        version: existsSync(versionPath) ? readFileSync(versionPath, "utf8").trim() : String(manifest?.version || ""),
+        source_path: dir.path,
+        manifest_path: existsSync(manifestPath) ? manifestPath : null,
+        skill_path: existsSync(skillPath) ? skillPath : null,
+        capabilities,
+        transport: manifest?.transport || null,
+        owner_dialogue_cheatsheet_path: ownerDialogueCheatsheetPath && existsSync(ownerDialogueCheatsheetPath) ? ownerDialogueCheatsheetPath : null,
+        owner_dialogue_examples_zh: ownerDialogueCheatsheetPath ? readDialogueCheatsheetPreview(ownerDialogueCheatsheetPath) : [],
+        owner_dialogue_sections_zh: ownerDialogueCheatsheetPath ? readDialogueCheatsheetSections(ownerDialogueCheatsheetPath) : [],
+        installed_in_openclaw: installedInWorkspace || installedInLegacy,
+        install_mode: installedInWorkspace ? "workspace" : installedInLegacy ? "legacy" : "not_installed",
+        installed_path: installedInWorkspace ? installedWorkspacePath : installedInLegacy ? installedLegacyPath : null,
+      };
+    });
+
+    const installedSkills = [
+      ...listDirectories(workspaceInstallRoot).map((dir) => ({ ...dir, install_mode: "workspace" as const })),
+      ...listDirectories(legacyInstallRoot).map((dir) => ({ ...dir, install_mode: "legacy" as const })),
+    ].map((dir) => {
+      const manifestPath = resolve(dir.path, "manifest.json");
+      const skillPath = resolve(dir.path, "SKILL.md");
+      const versionPath = resolve(dir.path, "VERSION");
+      const manifest = readJsonFileSafe(manifestPath);
+      const references = (manifest?.references && typeof manifest.references === "object")
+        ? manifest.references as Record<string, unknown>
+        : null;
+      const ownerDialogueCheatsheetPath = references?.owner_dialogue_cheatsheet_zh
+        ? resolve(dir.path, String(references.owner_dialogue_cheatsheet_zh))
+        : null;
+      return {
+        key: `${dir.install_mode}:${dir.name}`,
+        name: String(manifest?.name || dir.name),
+        display_name: String(manifest?.display_name || dir.name),
+        description: String(manifest?.description || summarizeSkillReadme(skillPath) || ""),
+        version: existsSync(versionPath) ? readFileSync(versionPath, "utf8").trim() : String(manifest?.version || ""),
+        install_mode: dir.install_mode,
+        installed_path: dir.path,
+        manifest_path: existsSync(manifestPath) ? manifestPath : null,
+        skill_path: existsSync(skillPath) ? skillPath : null,
+        capabilities: Array.isArray(manifest?.capabilities) ? manifest.capabilities.map((item) => String(item)) : [],
+        owner_dialogue_cheatsheet_path: ownerDialogueCheatsheetPath && existsSync(ownerDialogueCheatsheetPath) ? ownerDialogueCheatsheetPath : null,
+        owner_dialogue_examples_zh: ownerDialogueCheatsheetPath ? readDialogueCheatsheetPreview(ownerDialogueCheatsheetPath) : [],
+        owner_dialogue_sections_zh: ownerDialogueCheatsheetPath ? readDialogueCheatsheetSections(ownerDialogueCheatsheetPath) : [],
+        bundled_source_path: bundledSkills.find((item) => item.name === String(manifest?.name || dir.name))?.source_path || null,
+      };
+    });
+
+    const installedSkillVersions = new Map(installedSkills.map((item) => [item.name, item.version]));
+    const bundledSkillsWithUpdateState = bundledSkills.map((skill) => {
+      const installedVersion = installedSkillVersions.get(skill.name) || "";
+      const updateAvailable = Boolean(
+        skill.installed_in_openclaw &&
+        installedVersion &&
+        skill.version &&
+        compareVersionTokens(installedVersion, skill.version) < 0
+      );
+      return {
+        ...skill,
+        installed_version: installedVersion || null,
+        update_available: updateAvailable,
+      };
+    });
+    const bundledSkillVersions = new Map(bundledSkillsWithUpdateState.map((item) => [item.name, item.version]));
+    const installedSkillsWithUpdateState = installedSkills.map((skill) => {
+      const bundledVersion = bundledSkillVersions.get(skill.name) || "";
+      const updateAvailable = Boolean(
+        bundledVersion &&
+        skill.version &&
+        compareVersionTokens(skill.version, bundledVersion) < 0
+      );
+      return {
+        ...skill,
+        bundled_version: bundledVersion || null,
+        update_available: updateAvailable,
+      };
+    });
+
+    return {
+      openclaw: {
+        detected: bridge.openclaw_installation.detected,
+        running: bridge.openclaw_runtime.running,
+        detection_mode: bridge.openclaw_runtime.detection_mode,
+        gateway_url: bridge.openclaw_runtime.gateway_url,
+        workspace_install_root: workspaceInstallRoot,
+        legacy_install_root: legacyInstallRoot,
+      },
+      summary: {
+        bundled_count: bundledSkillsWithUpdateState.length,
+        installed_count: installedSkillsWithUpdateState.length,
+        installed_bundled_count: bundledSkillsWithUpdateState.filter((item) => item.installed_in_openclaw).length,
+        update_available_count: bundledSkillsWithUpdateState.filter((item) => item.update_available).length,
+      },
+      install_action: bridge.skill_learning.install_action,
+      bundled_skills: bundledSkillsWithUpdateState,
+      installed_skills: installedSkillsWithUpdateState,
+    };
+  }
+
   getRuntimeMessageGovernance() {
     return this.messageGovernance;
   }
@@ -1631,6 +2118,7 @@ export class LocalNodeService {
     };
     const presenceRecord = signPresence(this.identity, Date.now());
     const indexRecords = buildIndexRecords(this.profile);
+    const replayMessages = this.getReplayableSelfSocialMessages();
 
     try {
       await this.publish("profile", profileRecord);
@@ -1638,6 +2126,9 @@ export class LocalNodeService {
       for (const record of indexRecords) {
         await this.publish("index", record);
       }
+      for (const message of replayMessages) {
+        await this.publish(SOCIAL_MESSAGE_TOPIC, message);
+      }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.lastBroadcastErrorAt = Date.now();
@@ -1660,7 +2151,10 @@ export class LocalNodeService {
     this.compactCacheInMemory();
     await this.persistCache();
 
-    await this.log("info", `Broadcast sent (${indexRecords.length} index refs, reason=${reason})`);
+    await this.log(
+      "info",
+      `Broadcast sent (${indexRecords.length} index refs, replayed_messages=${replayMessages.length}, reason=${reason})`
+    );
     return { sent: true, reason };
   }
 
@@ -1680,7 +2174,7 @@ export class LocalNodeService {
       socialConfig: this.socialConfig,
       existingIdentity,
       generatedIdentity: createIdentity(),
-      rootDir: this.workspaceRoot,
+      rootDir: this.projectRoot,
     });
     this.identity = resolvedIdentity.identity;
     this.resolvedIdentitySource = resolvedIdentity.source;
@@ -1699,7 +2193,7 @@ export class LocalNodeService {
       socialConfig: this.socialConfig,
       agentId: this.identity.agent_id,
       existingProfile: existingProfile && existingProfile.agent_id === this.identity.agent_id ? existingProfile : null,
-      rootDir: this.workspaceRoot,
+      rootDir: this.projectRoot,
     });
     this.profile = signProfile(profileInput, this.identity);
     if (!existingProfile || existingProfile.agent_id !== this.identity.agent_id) {
@@ -1708,7 +2202,7 @@ export class LocalNodeService {
     }
     await this.profileRepo.set(this.profile);
 
-    this.directory = dedupeIndex(await this.cacheRepo.get());
+    this.directory = createEmptyDirectoryState();
     this.messageGovernance = {
       ...this.defaultMessageGovernance(),
       ...(await this.socialMessageGovernanceRepo.get()),
@@ -1731,7 +2225,7 @@ export class LocalNodeService {
       socialConfig: this.socialConfig,
       agentId: this.identity.agent_id,
       existingProfile: this.profile,
-      rootDir: this.workspaceRoot,
+      rootDir: this.projectRoot,
     });
     const nextProfile = signProfile(nextProfileInput, this.identity);
     this.profile = nextProfile;
@@ -1851,6 +2345,10 @@ export class LocalNodeService {
         await this.log("warn", `Rejected social message with invalid signature (${record.message_id.slice(0, 10)})`);
         return;
       }
+      if (this.hasSocialMessage(record.message_id)) {
+        await this.publishObservationForMessage(record);
+        return;
+      }
       const governanceReason = this.getIncomingSocialMessageRejectionReason(record);
       if (governanceReason) {
         await this.log("warn", `Rejected social message (${record.message_id.slice(0, 10)}): ${governanceReason}`);
@@ -2023,6 +2521,7 @@ export class LocalNodeService {
     this.network = next.adapter;
     this.adapterMode = next.mode;
     this.networkPort = next.port;
+    this.subscriptionsBound = false;
 
     await this.network.start();
     this.bindNetworkSubscriptions();
@@ -2045,7 +2544,22 @@ export class LocalNodeService {
   }
 
   private async persistCache(): Promise<void> {
-    await this.cacheRepo.set(this.directory);
+    const persisted = createEmptyDirectoryState();
+    if (this.profile) {
+      const selfProfileRecord: SignedProfileRecord = {
+        type: "profile",
+        profile: this.profile,
+      };
+      this.directory = ingestProfileRecord(this.directory, selfProfileRecord);
+      persisted.profiles[this.profile.agent_id] = this.profile;
+      const selfLastSeenAt = this.directory.presence[this.profile.agent_id];
+      if (typeof selfLastSeenAt === "number" && Number.isFinite(selfLastSeenAt)) {
+        persisted.presence[this.profile.agent_id] = selfLastSeenAt;
+      }
+      const indexed = rebuildIndexForProfile(persisted, this.profile);
+      persisted.index = indexed.index;
+    }
+    await this.cacheRepo.set(persisted);
   }
 
   private async persistSocialMessages(): Promise<void> {
@@ -2071,6 +2585,19 @@ export class LocalNodeService {
     return (this.network as any).getDiagnostics();
   }
 
+  private getResolvedRealtimeNetworkSummary() {
+    const diagnostics = this.getAdapterDiagnostics();
+    const relayCapable = this.adapterMode === "webrtc-preview" || this.adapterMode === "relay-preview";
+    return {
+      diagnostics,
+      signaling_url: diagnostics?.signaling_url ?? (relayCapable ? this.webrtcSignalingUrls[0] ?? null : null),
+      signaling_endpoints: diagnostics?.signaling_endpoints ?? (relayCapable ? this.webrtcSignalingUrls : []),
+      room: diagnostics?.room ?? (relayCapable ? this.webrtcRoom : null),
+      bootstrap_sources: diagnostics?.bootstrap_sources ?? (relayCapable ? this.webrtcBootstrapSources : []),
+      seed_peers_count: diagnostics?.seed_peers_count ?? this.webrtcSeedPeers.length,
+    };
+  }
+
   private toPublicProfileSummary(
     profile: PublicProfile,
     options?: { last_seen_at?: number }
@@ -2114,6 +2641,72 @@ export class LocalNodeService {
     });
   }
 
+  private mergeMessageOnlyAgentSummaries(
+    summaries: PublicProfileSummary[],
+    keyword: string
+  ): PublicProfileSummary[] {
+    const normalizedKeyword = String(keyword || "").trim().toLowerCase();
+    const knownAgentIds = new Set(summaries.map((item) => item.agent_id));
+    const messageOnly: PublicProfileSummary[] = [];
+
+    for (const message of this.socialMessages) {
+      if (!message?.agent_id || knownAgentIds.has(message.agent_id)) {
+        continue;
+      }
+
+      const displayName = String(message.display_name || "Unnamed").trim() || "Unnamed";
+      if (normalizedKeyword) {
+        const haystacks = [
+          displayName.toLowerCase(),
+          message.agent_id.toLowerCase(),
+          String(message.topic || "").toLowerCase(),
+        ];
+        if (!haystacks.some((value) => value.includes(normalizedKeyword))) {
+          continue;
+        }
+      }
+
+      knownAgentIds.add(message.agent_id);
+      messageOnly.push(
+        buildPublicProfileSummary({
+          profile: {
+            agent_id: message.agent_id,
+            display_name: displayName,
+            bio: "Seen from signed public message. Profile/presence not synced yet.",
+            tags: ["message-only"],
+            avatar_url: "",
+            public_enabled: true,
+            updated_at: message.created_at,
+            signature: "",
+          },
+          online: false,
+          last_seen_at: null,
+          network_mode: "unknown",
+          openclaw_bound: false,
+          profile_version: PROFILE_VERSION,
+          public_key_fingerprint: null,
+          verified_profile: false,
+          now: Date.now(),
+          presence_ttl_ms: PRESENCE_TTL_MS,
+        })
+      );
+    }
+
+    return [...summaries, ...messageOnly].sort((a, b) => {
+      if (a.online !== b.online) {
+        return a.online ? -1 : 1;
+      }
+      if (a.updated_at !== b.updated_at) {
+        return b.updated_at - a.updated_at;
+      }
+      const byName = a.display_name.localeCompare(b.display_name);
+      if (byName !== 0) {
+        return byName;
+      }
+      return a.agent_id.localeCompare(b.agent_id);
+    });
+  }
+
   private fingerprintPublicKey(publicKey: string): string {
     const digest = createHash("sha256").update(publicKey, "utf8").digest("hex");
     return `${digest.slice(0, 12)}:${digest.slice(-8)}`;
@@ -2122,6 +2715,22 @@ export class LocalNodeService {
   private getOnboardingSummary() {
     const summary = this.getIntegrationSummary();
     const publicEnabled = Boolean(this.profile?.public_enabled);
+    const nextSteps: string[] = [];
+    if (!String(this.profile?.display_name || "").trim()) {
+      nextSteps.push("Update display name in Profile page");
+    }
+    if (!publicEnabled) {
+      nextSteps.push("Enable Public Enabled in Profile");
+    }
+    if (!summary.running) {
+      nextSteps.push("Start broadcast in Network");
+    }
+    if (!summary.discoverable) {
+      nextSteps.push("Announce node once after the network is running");
+    }
+    if (nextSteps.length === 0) {
+      nextSteps.push("Node is public and discoverable");
+    }
     return {
       first_run: Boolean(
         this.initState.social_auto_created ||
@@ -2133,10 +2742,7 @@ export class LocalNodeService {
       mode: this.networkMode,
       public_enabled: publicEnabled,
       can_enable_public_discovery: !publicEnabled,
-      next_steps: [
-        "Update display name in Profile page",
-        "Export social.md from Social Config",
-      ],
+      next_steps: nextSteps,
     };
   }
 
@@ -2161,7 +2767,7 @@ export class LocalNodeService {
       };
     }
     return {
-      mode: "global-preview",
+      mode: DEFAULT_NETWORK_MODE,
       short_label: "Relay preview",
       summary: "Uses the public relay preview room so public nodes can find each other across the internet.",
     };
@@ -2191,14 +2797,14 @@ export class LocalNodeService {
       this.socialConfig.network.mode ||
       (modeEnv === "local" || modeEnv === "lan" || modeEnv === "global-preview"
         ? modeEnv
-        : "global-preview");
+        : DEFAULT_NETWORK_MODE);
 
     this.networkMode = resolvedMode;
-    this.networkNamespace = this.socialConfig.network.namespace || process.env.NETWORK_NAMESPACE || "silicaclaw.preview";
-    this.networkPort = Number(this.socialConfig.network.port || process.env.NETWORK_PORT || 44123);
+    this.networkNamespace = this.socialConfig.network.namespace || process.env.NETWORK_NAMESPACE || DEFAULT_NETWORK_NAMESPACE;
+    this.networkPort = Number(this.socialConfig.network.port || process.env.NETWORK_PORT || DEFAULT_NETWORK_PORT);
 
-    const builtInGlobalSignalingUrls = ["https://relay.silicaclaw.com"];
-    const builtInGlobalRoom = "silicaclaw-global-preview";
+    const builtInGlobalSignalingUrls = [DEFAULT_GLOBAL_SIGNALING_URL];
+    const builtInGlobalRoom = DEFAULT_GLOBAL_ROOM;
 
     const signalingUrlsSocial = dedupeStrings(this.socialConfig.network.signaling_urls || []);
     const signalingUrlSocial = String(this.socialConfig.network.signaling_url || "").trim();
@@ -2223,8 +2829,8 @@ export class LocalNodeService {
       signalingUrls = builtInGlobalSignalingUrls;
       signalingSource = "built-in-defaults:global-preview.signaling_urls";
     } else {
-      signalingUrls = ["https://relay.silicaclaw.com"];
-      signalingSource = "default:https://relay.silicaclaw.com";
+      signalingUrls = [DEFAULT_GLOBAL_SIGNALING_URL];
+      signalingSource = `default:${DEFAULT_GLOBAL_SIGNALING_URL}`;
     }
 
     const roomSocial = String(this.socialConfig.network.room || "").trim();
@@ -2233,14 +2839,14 @@ export class LocalNodeService {
       roomSocial ||
       roomEnv ||
       (this.networkMode === "global-preview" ? builtInGlobalRoom : "") ||
-      "silicaclaw-global-preview";
+      DEFAULT_GLOBAL_ROOM;
     const roomSource = roomSocial
       ? "social.md:network.room"
       : roomEnv
           ? "env:WEBRTC_ROOM"
           : this.networkMode === "global-preview"
         ? "built-in-defaults:global-preview.room"
-          : "default:silicaclaw-global-preview";
+          : `default:${DEFAULT_GLOBAL_ROOM}`;
 
     const seedPeersSocial = dedupeStrings(this.socialConfig.network.seed_peers || []);
     const seedPeersEnv = dedupeStrings(parseListEnv(WEBRTC_SEED_PEERS));
@@ -2299,6 +2905,24 @@ export class LocalNodeService {
     return this.messageGovernance.blocked_terms.some((term) => normalized.includes(term));
   }
 
+  private hasSocialMessage(messageId: string): boolean {
+    return this.socialMessages.some((item) => item.message_id === messageId);
+  }
+
+  private getReplayableSelfSocialMessages(now = Date.now()): SocialMessageRecord[] {
+    const maxCount = Math.max(0, SOCIAL_MESSAGE_REPLAY_MAX_PER_BROADCAST);
+    if (!this.identity || maxCount === 0) {
+      return [];
+    }
+    return this.socialMessages
+      .filter((item) => (
+        item.agent_id === this.identity?.agent_id &&
+        now - item.created_at <= SOCIAL_MESSAGE_REPLAY_WINDOW_MS
+      ))
+      .sort((a, b) => a.created_at - b.created_at)
+      .slice(-maxCount);
+  }
+
   private hasRecentDuplicateMessage(agentId: string, body: string, topic: string, now = Date.now()): boolean {
     return this.socialMessages.some((item) => (
       item.agent_id === agentId &&
@@ -2608,15 +3232,15 @@ function renderBootstrapScript(payload: unknown): string {
     if (data.pillBroadcastClassName) pillBroadcast.className = data.pillBroadcastClassName;
   }
   setHtml('overviewCards', data.overviewCardsHtml || '');
-  setText('agentsCountHint', data.agentsCountHintText || '0 agents');
-  setHtml('agentsWrap', data.agentsWrapHtml || '<div class="label">No discovered agents yet.</div>');
+  setText('agentsCountHint', data.agentsCountHintText || '0 nodes');
+  setHtml('agentsWrap', data.agentsWrapHtml || '<div class="label">No discovered nodes yet.</div>');
 })();
 </script>`;
 }
 
 export async function main() {
   const app = express();
-  const port = Number(process.env.PORT || 4310);
+  const port = Number(process.env.PORT || defaults.ports.local_console);
   const staticDir = resolveLocalConsoleStaticDir();
   const staticIndexFile = resolve(staticDir, "index.html");
 
@@ -2691,6 +3315,10 @@ export async function main() {
     sendOk(res, node.getNetworkStats());
   });
 
+  app.get("/api/skills", (_req, res) => {
+    sendOk(res, node.getSkillsView());
+  });
+
   app.post(
     "/api/network/quick-connect-global-preview",
     asyncRoute(async (req, res) => {
@@ -2820,9 +3448,10 @@ export async function main() {
 
   app.post(
     "/api/openclaw/bridge/skill-install",
-    asyncRoute(async (_req, res) => {
+    asyncRoute(async (req, res) => {
       try {
-        const result = await node.installOpenClawSkill();
+        const skillName = String(req.body?.skill_name || "").trim();
+        const result = await node.installOpenClawSkill(skillName || undefined);
         sendOk(res, result, {
           message: "OpenClaw skill installed",
         });
@@ -2870,7 +3499,7 @@ export async function main() {
     const agentId = req.params.agentId;
     const profile = state.profiles[agentId];
     if (!profile) {
-      sendError(res, 404, "AGENT_NOT_FOUND", "Agent not found", { agent_id: agentId });
+      sendError(res, 404, "AGENT_NOT_FOUND", "Node not found", { agent_id: agentId });
       return;
     }
 
@@ -2906,7 +3535,7 @@ export async function main() {
       .join("");
     const agentsWrapHtml =
       discovered.length === 0
-        ? `<div class="label">No discovered agents yet.</div>`
+        ? `<div class="label">No discovered nodes yet.</div>`
         : `
             <table class="table">
               <thead><tr><th>Name</th><th>Agent ID</th><th>Status</th><th>Updated</th></tr></thead>
@@ -2942,7 +3571,7 @@ export async function main() {
       pillBroadcastText: overview.broadcast_enabled ? "broadcast: running" : "broadcast: paused",
       pillBroadcastClassName: `pill ${overview.broadcast_enabled ? "ok" : "warn"}`,
       overviewCardsHtml,
-      agentsCountHintText: `${discovered.length} agents discovered`,
+      agentsCountHintText: `${discovered.length} nodes discovered`,
       agentsWrapHtml,
       integrationStatusText: `Connected to SilicaClaw: ${integration.connected_to_silicaclaw ? "yes" : "no"} · Network mode: ${integration.network_mode || "-"} · Public discovery: ${integration.public_enabled ? "enabled" : "disabled"}`,
       integrationStatusClassName: `integration-strip ${integration.connected_to_silicaclaw && integration.public_enabled ? "ok" : "warn"}`,