@silicaclaw/cli 2026.3.19-9 → 2026.3.20-10

package/apps/local-console/dist/apps/local-console/src/server.js

@@ -13,6 +13,7 @@ const fs_1 = require("fs");
 const crypto_1 = require("crypto");
 const os_1 = require("os");
 const util_1 = require("util");
+const silicaclaw_defaults_json_1 = __importDefault(require("../../../config/silicaclaw-defaults.json"));
 const core_1 = require("@silicaclaw/core");
 const network_1 = require("@silicaclaw/network");
 const storage_1 = require("@silicaclaw/storage");
@@ -27,21 +28,36 @@ const NETWORK_MAX_PAST_DRIFT_MS = Number(process.env.NETWORK_MAX_PAST_DRIFT_MS |
 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 OPENCLAW_GATEWAY_PORT = 18_789;
+const DEFAULT_NETWORK_MODE = silicaclaw_defaults_json_1.default.network.default_mode;
+const DEFAULT_NETWORK_NAMESPACE = silicaclaw_defaults_json_1.default.network.default_namespace;
+const DEFAULT_NETWORK_PORT = silicaclaw_defaults_json_1.default.ports.network_default;
+const DEFAULT_GLOBAL_SIGNALING_URL = silicaclaw_defaults_json_1.default.network.global_preview.relay_url;
+const DEFAULT_GLOBAL_ROOM = silicaclaw_defaults_json_1.default.network.global_preview.room;
+const DEFAULT_BRIDGE_API_BASE = silicaclaw_defaults_json_1.default.bridge.api_base;
+const OPENCLAW_GATEWAY_PORT = silicaclaw_defaults_json_1.default.ports.openclaw_gateway;
 const OPENCLAW_GATEWAY_URL = `http://${OPENCLAW_GATEWAY_HOST}:${OPENCLAW_GATEWAY_PORT}/`;
+const OPENCLAW_RUNTIME_CACHE_MS = 15_000;
+const OPENCLAW_BRIDGE_STATUS_CACHE_MS = 5_000;
 const NETWORK_PEER_REMOVE_AFTER_MS = Number(process.env.NETWORK_PEER_REMOVE_AFTER_MS || 180_000);
+const DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT = Number(process.env.DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT || 1000);
 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";
 const SOCIAL_MESSAGE_TOPIC = "social.message";
 const SOCIAL_MESSAGE_OBSERVATION_TOPIC = "social.message.observation";
+const PRIVATE_MESSAGE_TOPIC = "private.message";
+const PRIVATE_MESSAGE_RECEIPT_TOPIC = "private.message.receipt";
+const PRIVATE_MESSAGE_HISTORY_LIMIT = Number(process.env.PRIVATE_MESSAGE_HISTORY_LIMIT || 1000);
+const PRIVATE_MESSAGE_RECEIPT_HISTORY_LIMIT = Number(process.env.PRIVATE_MESSAGE_RECEIPT_HISTORY_LIMIT || 2000);
+const PRIVATE_MESSAGE_QUERY_LIMIT = Number(process.env.PRIVATE_MESSAGE_QUERY_LIMIT || 100);
+const PRIVATE_MESSAGE_PERSIST_DEBOUNCE_MS = Number(process.env.PRIVATE_MESSAGE_PERSIST_DEBOUNCE_MS || 750);
 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);
@@ -53,6 +69,10 @@ 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_REPLAY_REFRESH_INTERVAL_MS = Number(process.env.SOCIAL_MESSAGE_REPLAY_REFRESH_INTERVAL_MS || 120_000);
+const PROFILE_RELAY_REFRESH_INTERVAL_MS = Number(process.env.PROFILE_RELAY_REFRESH_INTERVAL_MS || 120_000);
 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())
@@ -60,25 +80,79 @@ const SOCIAL_MESSAGE_BLOCKED_TERMS = dedupeStrings(parseListEnv(process.env.SOCI
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 const OPENCLAW_SKILL_NAME = "silicaclaw-broadcast";
 function readWorkspaceVersion(workspaceRoot) {
-    const pkgFile = (0, path_1.resolve)(workspaceRoot, "package.json");
-    if ((0, fs_1.existsSync)(pkgFile)) {
-        try {
-            const pkg = JSON.parse((0, fs_1.readFileSync)(pkgFile, "utf8"));
-            if (pkg.version)
-                return String(pkg.version);
+    const candidates = [
+        workspaceRoot,
+        process.cwd(),
+        (0, path_1.resolve)(__dirname, "..", "..", ".."),
+        (0, path_1.resolve)(__dirname, "..", "..", "..", ".."),
+    ].filter((dir, index, list) => dir && list.indexOf(dir) === index);
+    for (const candidate of candidates) {
+        const pkgFile = (0, path_1.resolve)(candidate, "package.json");
+        if ((0, fs_1.existsSync)(pkgFile)) {
+            try {
+                const pkg = JSON.parse((0, fs_1.readFileSync)(pkgFile, "utf8"));
+                if (pkg.version && (pkg.name === "@silicaclaw/cli" || (0, fs_1.existsSync)((0, path_1.resolve)(candidate, "apps", "local-console")))) {
+                    return String(pkg.version);
+                }
+            }
+            catch {
+                // ignore
+            }
         }
-        catch {
-            // ignore
+        const versionFile = (0, path_1.resolve)(candidate, "VERSION");
+        if ((0, fs_1.existsSync)(versionFile)) {
+            const raw = (0, fs_1.readFileSync)(versionFile, "utf8").trim();
+            if (raw)
+                return raw;
         }
     }
-    const versionFile = (0, path_1.resolve)(workspaceRoot, "VERSION");
-    if ((0, fs_1.existsSync)(versionFile)) {
-        const raw = (0, fs_1.readFileSync)(versionFile, "utf8").trim();
-        if (raw)
-            return raw;
-    }
     return "unknown";
 }
+function normalizeVersionText(value) {
+    const text = String(value || "").trim();
+    return text.startsWith("v") ? text.slice(1) : text;
+}
+function formatBytesToMiB(value) {
+    return Math.round((value / (1024 * 1024)) * 10) / 10;
+}
+function tokenizeVersion(value) {
+    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, right) {
+    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 userNpmCacheDir() {
+    return (0, path_1.resolve)((0, os_1.homedir)(), ".silicaclaw", "npm-cache");
+}
+function userShimPath() {
+    return (0, path_1.resolve)((0, os_1.homedir)(), ".silicaclaw", "bin", "silicaclaw");
+}
 function resolveWorkspaceRoot(cwd = process.cwd()) {
     if ((0, fs_1.existsSync)((0, path_1.resolve)(cwd, "apps", "local-console", "package.json"))) {
         return cwd;
@@ -89,13 +163,43 @@ function resolveWorkspaceRoot(cwd = process.cwd()) {
     }
     return cwd;
 }
+function resolveProjectRoot(appRoot, cwd = process.cwd()) {
+    const envAppRoot = String(process.env.SILICACLAW_APP_DIR || "").trim();
+    if (envAppRoot &&
+        (0, fs_1.existsSync)((0, path_1.resolve)(envAppRoot, "apps", "local-console", "package.json")) &&
+        (0, fs_1.existsSync)((0, path_1.resolve)(envAppRoot, "package.json"))) {
+        return (0, path_1.resolve)(envAppRoot);
+    }
+    const envRoot = String(process.env.SILICACLAW_WORKSPACE_DIR || "").trim();
+    if (envRoot) {
+        return (0, path_1.resolve)(envRoot);
+    }
+    if ((0, fs_1.existsSync)((0, path_1.resolve)(appRoot, "apps", "local-console", "package.json")) &&
+        (0, fs_1.existsSync)((0, path_1.resolve)(appRoot, "package.json"))) {
+        return appRoot;
+    }
+    if (!(0, fs_1.existsSync)((0, path_1.resolve)(cwd, "apps", "local-console", "package.json"))) {
+        return (0, path_1.resolve)(cwd);
+    }
+    return appRoot;
+}
 function resolveStorageRoot(workspaceRoot, cwd = process.cwd()) {
+    const home = process.env.HOME || (0, os_1.homedir)();
+    if (home) {
+        return (0, path_1.resolve)(home, ".silicaclaw", "local-console");
+    }
     const appRoot = (0, path_1.resolve)(workspaceRoot, "apps", "local-console");
     if ((0, fs_1.existsSync)((0, path_1.resolve)(appRoot, "package.json"))) {
         return appRoot;
     }
     return cwd;
 }
+function defaultOpenClawSourceDir(rootDir) {
+    if ((0, fs_1.existsSync)((0, path_1.resolve)(rootDir, "openclaw.mjs")) || (0, fs_1.existsSync)((0, path_1.resolve)(rootDir, "package.json"))) {
+        return rootDir;
+    }
+    return (0, path_1.resolve)(rootDir, "..", "openclaw");
+}
 function resolveExecutableInPath(binName) {
     const pathValue = String(process.env.PATH || "").trim();
     if (!pathValue)
@@ -162,6 +266,54 @@ function summarizeSkillReadme(filePath) {
         return "";
     }
 }
+function readDialogueCheatsheetPreview(filePath, limit = 6) {
+    if (!filePath || !(0, fs_1.existsSync)(filePath))
+        return [];
+    try {
+        return (0, fs_1.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, maxSections = 3, maxItemsPerSection = 5) {
+    if (!filePath || !(0, fs_1.existsSync)(filePath))
+        return [];
+    try {
+        const lines = (0, fs_1.readFileSync)(filePath, "utf8").split(/\r?\n/);
+        const sections = [];
+        let current = 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) {
     const workspaceDir = (0, path_1.resolve)(workspaceRoot, ".openclaw");
     const homeDir = (0, path_1.resolve)(process.env.HOME || "", ".openclaw");
@@ -206,7 +358,7 @@ function detectOpenClawInstallation(workspaceRoot) {
 }
 function readOpenClawConfiguredGateway(workspaceRoot) {
     const configuredSourceDir = String(process.env.OPENCLAW_SOURCE_DIR || "").trim();
-    const defaultSourceDir = (0, path_1.resolve)(workspaceRoot, "..", "openclaw");
+    const defaultSourceDir = defaultOpenClawSourceDir(workspaceRoot);
     const sourceDir = configuredSourceDir || defaultSourceDir;
     const homeDir = (0, path_1.resolve)(process.env.HOME || "", ".openclaw");
     const explicitConfigPath = String(process.env.OPENCLAW_CONFIG_PATH || "").trim();
@@ -248,44 +400,56 @@ function readOpenClawConfiguredGateway(workspaceRoot) {
         gateway_url: OPENCLAW_GATEWAY_URL,
     };
 }
+function resolveOpenClawStatusCommand(workspaceRoot) {
+    const explicitBin = String(process.env.OPENCLAW_BIN || "").trim();
+    if (explicitBin) {
+        return { cmd: explicitBin, args: ["status"] };
+    }
+    const configuredSourceDir = String(process.env.OPENCLAW_SOURCE_DIR || "").trim();
+    const defaultSourceDir = defaultOpenClawSourceDir(workspaceRoot);
+    const sourceDir = configuredSourceDir || defaultSourceDir;
+    const sourceEntry = existingPathOrNull((0, path_1.resolve)(sourceDir, "openclaw.mjs"));
+    if (sourceEntry) {
+        return { cmd: process.execPath, args: [sourceEntry, "status"] };
+    }
+    const commandPath = resolveExecutableInPath("openclaw");
+    if (commandPath) {
+        return { cmd: commandPath, args: ["status"] };
+    }
+    return null;
+}
+function resolveOpenClawGatewayProbeCommand(workspaceRoot) {
+    const explicitBin = String(process.env.OPENCLAW_BIN || "").trim();
+    if (explicitBin) {
+        return { cmd: explicitBin, args: ["gateway", "probe"] };
+    }
+    const configuredSourceDir = String(process.env.OPENCLAW_SOURCE_DIR || "").trim();
+    const defaultSourceDir = defaultOpenClawSourceDir(workspaceRoot);
+    const sourceDir = configuredSourceDir || defaultSourceDir;
+    const sourceEntry = existingPathOrNull((0, path_1.resolve)(sourceDir, "openclaw.mjs"));
+    if (sourceEntry) {
+        return { cmd: process.execPath, args: [sourceEntry, "gateway", "probe"] };
+    }
+    const commandPath = resolveExecutableInPath("openclaw");
+    if (commandPath) {
+        return { cmd: commandPath, args: ["gateway", "probe"] };
+    }
+    return null;
+}
 function detectOpenClawRuntime(workspaceRoot) {
     const configuredGateway = readOpenClawConfiguredGateway(workspaceRoot);
-    const result = (0, child_process_1.spawnSync)("ps", ["-Ao", "pid=,ppid=,command="], {
+    const statusCommand = resolveOpenClawStatusCommand(workspaceRoot);
+    const statusLooksConfigured = Boolean(statusCommand ||
+        configuredGateway.config_path ||
+        detectOpenClawInstallation(workspaceRoot).detected);
+    const gatewayProbeCommand = ["lsof", "-nP", `-iTCP:${configuredGateway.gateway_port}`, "-sTCP:LISTEN"];
+    const gatewayProbe = (0, child_process_1.spawnSync)(gatewayProbeCommand[0], gatewayProbeCommand.slice(1), {
         encoding: "utf8",
+        timeout: 1200,
     });
-    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) => Boolean(item));
-    const openclawPids = new Set(processes.map((item) => item.pid));
-    const gatewayProbe = (0, child_process_1.spawnSync)("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN"], {
-        encoding: "utf8",
-    });
-    const gatewayLines = String(gatewayProbe.stdout || "")
+    const gatewayStatusStdout = String(gatewayProbe.stdout || "");
+    const gatewayStatusStderr = String(gatewayProbe.stderr || "");
+    const gatewayLines = gatewayStatusStdout
         .split("\n")
         .map((line) => line.trim())
         .filter(Boolean);
@@ -295,15 +459,10 @@ function detectOpenClawRuntime(workspaceRoot) {
         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;
@@ -315,49 +474,107 @@ function detectOpenClawRuntime(workspaceRoot) {
         };
     })
         .filter((item) => Boolean(item));
+    const gatewayProbeOk = gatewayListeners.length > 0;
+    let processes = gatewayListeners.map((item) => ({
+        pid: item.pid,
+        ppid: item.ppid,
+        command: item.command,
+    }));
+    let processResult = null;
+    if (!gatewayProbeOk) {
+        processResult = (0, child_process_1.spawnSync)("ps", ["-Ao", "pid=,ppid=,command="], {
+            encoding: "utf8",
+            timeout: 1200,
+        });
+        const stdout = String(processResult.stdout || "");
+        const lines = stdout
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean);
+        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) => Boolean(item));
+    }
     const preferredListener = gatewayListeners.find((item) => item.port === configuredGateway.gateway_port) ||
         gatewayListeners[0] ||
         null;
-    const combinedProcesses = new Map();
-    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 allProcesses = processes.slice(0, 10);
+    const gatewayReachable = gatewayProbeOk;
     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());
+        detectionNotes.push(String(gatewayStatusStderr || "openclaw gateway probe failed").trim());
+    }
+    if (processResult && processResult.status !== 0) {
+        detectionNotes.push(String(processResult.stderr || "ps failed").trim());
     }
     const gatewayPort = preferredListener?.port || configuredGateway.gateway_port;
     const gatewayUrl = `http://${OPENCLAW_GATEWAY_HOST}:${gatewayPort}/`;
     return {
-        running: allProcesses.length > 0 || gatewayReachable,
+        running: gatewayProbeOk || 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,
+        status_command: statusCommand ? [statusCommand.cmd, ...statusCommand.args].join(" ") : null,
+        status_ok: statusLooksConfigured,
+        status_summary: statusLooksConfigured
+            ? configuredGateway.config_path
+                ? `configured via ${configuredGateway.config_path}`
+                : statusCommand
+                    ? `command available: ${[statusCommand.cmd, ...statusCommand.args].join(" ")}`
+                    : "OpenClaw environment detected"
+            : null,
+        gateway_probe_command: gatewayProbeCommand.join(" "),
+        gateway_probe_ok: gatewayProbeOk,
+        gateway_probe_summary: gatewayProbeOk
+            ? gatewayStatusStdout
+                .split("\n")
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .slice(0, 4)
+                .join(" | ")
+            : null,
         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",
+        detection_mode: gatewayProbeOk
+            ? (processes.length > 0 && gatewayReachable
+                ? "gateway-probe+process+gateway"
+                : gatewayReachable
+                    ? "gateway-probe+gateway"
+                    : processes.length > 0
+                        ? "gateway-probe+process"
+                        : "gateway-probe")
+            : processes.length > 0 && gatewayReachable
+                ? "process+gateway"
+                : gatewayReachable
+                    ? "gateway"
+                    : processes.length > 0
+                        ? "process"
+                        : "not_running",
     };
 }
 function detectOpenClawSkillInstallation() {
@@ -384,7 +601,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 = (0, path_1.resolve)(params.workspaceRoot, "..", "openclaw");
+    const defaultSourceDir = defaultOpenClawSourceDir(params.workspaceRoot);
     const openclawSourceDir = configuredSourceDir || defaultSourceDir;
     const openclawSourceEntry = existingPathOrNull((0, path_1.resolve)(openclawSourceDir, "openclaw.mjs"));
     const openclawCommandResolvable = Boolean(explicitOpenClawBin || resolveExecutableInPath("openclaw") || openclawSourceEntry);
@@ -450,11 +667,18 @@ function hasMeaningfulJson(filePath) {
         return false;
     }
 }
-function migrateLegacyDataIfNeeded(workspaceRoot, storageRoot) {
-    const legacyDataDir = (0, path_1.resolve)(workspaceRoot, "data");
+function migrateLegacyDataIfNeeded(appRoot, projectRoot, storageRoot) {
+    const homeDir = process.env.HOME || (0, os_1.homedir)();
+    const legacyNpxAppRoots = collectLegacyNpxAppRoots(homeDir);
     const targetDataDir = (0, path_1.resolve)(storageRoot, "data");
-    if (legacyDataDir === targetDataDir)
-        return;
+    const legacyDataDirs = [
+        (0, path_1.resolve)(appRoot, "data"),
+        (0, path_1.resolve)(appRoot, "apps", "local-console", "data"),
+        (0, path_1.resolve)(projectRoot, "data"),
+        (0, path_1.resolve)(projectRoot, "apps", "local-console", "data"),
+        (0, path_1.resolve)(process.cwd(), "data"),
+        ...legacyNpxAppRoots.map((root) => (0, path_1.resolve)(root, "apps", "local-console", "data")),
+    ].filter((dir, index, list) => list.indexOf(dir) === index && dir !== targetDataDir);
     const files = [
         "identity.json",
         "profile.json",
@@ -464,17 +688,70 @@ function migrateLegacyDataIfNeeded(workspaceRoot, storageRoot) {
         "social-message-observations.json",
     ];
     for (const file of files) {
-        const src = (0, path_1.resolve)(legacyDataDir, file);
         const dst = (0, path_1.resolve)(targetDataDir, file);
-        if (!(0, fs_1.existsSync)(src))
+        if (hasMeaningfulJson(dst))
             continue;
+        for (const legacyDataDir of legacyDataDirs) {
+            const src = (0, path_1.resolve)(legacyDataDir, file);
+            if (!(0, fs_1.existsSync)(src))
+                continue;
+            if (!hasMeaningfulJson(src))
+                continue;
+            (0, fs_1.mkdirSync)(targetDataDir, { recursive: true });
+            (0, fs_1.copyFileSync)(src, dst);
+            break;
+        }
+    }
+    const targetDotDir = (0, path_1.resolve)(storageRoot, ".silicaclaw");
+    const legacyDotDirs = [
+        (0, path_1.resolve)(appRoot, ".silicaclaw"),
+        (0, path_1.resolve)(appRoot, "apps", "local-console", ".silicaclaw"),
+        (0, path_1.resolve)(projectRoot, ".silicaclaw"),
+        (0, path_1.resolve)(projectRoot, "apps", "local-console", ".silicaclaw"),
+        (0, path_1.resolve)(process.cwd(), ".silicaclaw"),
+        ...legacyNpxAppRoots.map((root) => (0, path_1.resolve)(root, "apps", "local-console", ".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 = (0, path_1.resolve)(targetDotDir, file);
         if (hasMeaningfulJson(dst))
             continue;
-        if (!hasMeaningfulJson(src))
+        for (const legacyDotDir of legacyDotDirs) {
+            const src = (0, path_1.resolve)(legacyDotDir, file);
+            if (!(0, fs_1.existsSync)(src))
+                continue;
+            if (!hasMeaningfulJson(src))
+                continue;
+            (0, fs_1.mkdirSync)(targetDotDir, { recursive: true });
+            (0, fs_1.copyFileSync)(src, dst);
+            break;
+        }
+    }
+}
+function collectLegacyNpxAppRoots(homeDir) {
+    const cacheRoots = [
+        (0, path_1.resolve)(homeDir, ".silicaclaw", "npm-cache", "_npx"),
+        (0, path_1.resolve)(homeDir, ".npm", "_npx"),
+    ];
+    const roots = [];
+    for (const cacheRoot of cacheRoots) {
+        if (!(0, fs_1.existsSync)(cacheRoot))
+            continue;
+        let entries = [];
+        try {
+            entries = (0, fs_1.readdirSync)(cacheRoot);
+        }
+        catch {
             continue;
-        (0, fs_1.mkdirSync)(targetDataDir, { recursive: true });
-        (0, fs_1.copyFileSync)(src, dst);
+        }
+        for (const entry of entries) {
+            const candidate = (0, path_1.resolve)(cacheRoot, entry, "node_modules", "@silicaclaw", "cli");
+            if (!(0, fs_1.existsSync)((0, path_1.resolve)(candidate, "apps", "local-console")))
+                continue;
+            roots.push(candidate);
+        }
     }
+    return Array.from(new Set(roots));
 }
 function parseListEnv(raw) {
     return raw
@@ -487,6 +764,7 @@ function dedupeStrings(values) {
 }
 class LocalNodeService {
     workspaceRoot;
+    projectRoot;
     storageRoot;
     identityRepo;
     profileRepo;
@@ -495,20 +773,39 @@ class LocalNodeService {
     socialMessageGovernanceRepo;
     socialMessageRepo;
     socialMessageObservationRepo;
+    privateMessageRepo;
+    privateMessageReceiptRepo;
+    privateEncryptionKeyRepo;
     socialRuntimeRepo;
     identity = null;
     profile = null;
     directory = (0, core_1.createEmptyDirectoryState)();
     socialMessages = [];
     socialMessageObservations = [];
+    privateMessages = [];
+    privateMessageReceipts = [];
+    privateEncryptionKeyPair = null;
+    privatePeerRoutes = {};
+    privateMessageBodyCache = new Map();
     messageGovernance;
+    privateMessagesPersistDirty = false;
+    privateMessageReceiptsPersistDirty = false;
+    privateMessagesPersistTimer = null;
+    privateMessageReceiptsPersistTimer = null;
     receivedCount = 0;
     broadcastCount = 0;
     lastMessageAt = 0;
     lastBroadcastAt = 0;
+    lastProfileBroadcastAt = 0;
+    lastProfileBroadcastSignature = "";
+    lastReplayBroadcastAt = 0;
+    lastReplayBroadcastSignature = "";
     lastBroadcastErrorAt = 0;
     lastBroadcastError = null;
     broadcastFailureCount = 0;
+    consecutiveBroadcastFailures = 0;
+    lastBroadcastRecoveryAttemptAt = 0;
+    broadcastRecoveryInFlight = false;
     broadcaster = null;
     subscriptionsBound = false;
     broadcastEnabled = true;
@@ -524,7 +821,7 @@ class LocalNodeService {
     };
     network;
     adapterMode;
-    networkMode = "global-preview";
+    networkMode = DEFAULT_NETWORK_MODE;
     networkNamespace;
     networkPort;
     socialConfig;
@@ -537,16 +834,23 @@ class LocalNodeService {
     resolvedIdentitySource = "silicaclaw-existing";
     resolvedOpenClawIdentityPath = null;
     webrtcSignalingUrls = [];
-    webrtcRoom = "silicaclaw-global-preview";
+    webrtcRoom = DEFAULT_GLOBAL_ROOM;
     webrtcSeedPeers = [];
     webrtcBootstrapHints = [];
     webrtcBootstrapSources = [];
+    networkStarted = false;
+    networkStartupError = null;
+    networkReconnectTimer = null;
+    networkReconnectDelayMs = 5_000;
     appVersion = "unknown";
+    openclawRuntimeCache = null;
+    openclawBridgeStatusCache = null;
     constructor(options) {
         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 storage_1.IdentityRepo(this.storageRoot);
         this.profileRepo = new storage_1.ProfileRepo(this.storageRoot);
         this.cacheRepo = new storage_1.CacheRepo(this.storageRoot);
@@ -554,18 +858,21 @@ class LocalNodeService {
         this.socialMessageGovernanceRepo = new storage_1.SocialMessageGovernanceRepo(this.storageRoot);
         this.socialMessageRepo = new storage_1.SocialMessageRepo(this.storageRoot);
         this.socialMessageObservationRepo = new storage_1.SocialMessageObservationRepo(this.storageRoot);
+        this.privateMessageRepo = new storage_1.PrivateMessageRepo(this.storageRoot);
+        this.privateMessageReceiptRepo = new storage_1.PrivateMessageReceiptRepo(this.storageRoot);
+        this.privateEncryptionKeyRepo = new storage_1.PrivateEncryptionKeyRepo(this.storageRoot);
         this.socialRuntimeRepo = new storage_1.SocialRuntimeRepo(this.storageRoot);
         this.messageGovernance = this.defaultMessageGovernance();
-        let loadedSocial = (0, core_1.loadSocialConfig)(this.workspaceRoot);
+        let loadedSocial = (0, core_1.loadSocialConfig)(this.projectRoot);
         if (!loadedSocial.meta.found) {
-            (0, core_1.ensureDefaultSocialMd)(this.workspaceRoot, {
+            (0, core_1.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 = (0, core_1.loadSocialConfig)(this.workspaceRoot);
+            loadedSocial = (0, core_1.loadSocialConfig)(this.projectRoot);
             this.initState.social_auto_created = true;
         }
         this.socialConfig = loadedSocial.config;
@@ -573,35 +880,46 @@ class LocalNodeService {
         this.socialFound = loadedSocial.meta.found;
         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;
         this.adapterMode = resolved.mode;
         this.networkPort = resolved.port;
     }
+    getCachedOpenClawRuntime() {
+        const now = Date.now();
+        if (this.openclawRuntimeCache && this.openclawRuntimeCache.expiresAt > now) {
+            return this.openclawRuntimeCache.value;
+        }
+        const value = detectOpenClawRuntime(this.projectRoot);
+        this.openclawRuntimeCache = {
+            value,
+            expiresAt: now + OPENCLAW_RUNTIME_CACHE_MS,
+        };
+        return value;
+    }
+    invalidateOpenClawCaches() {
+        this.openclawRuntimeCache = null;
+        this.openclawBridgeStatusCache = null;
+    }
     async start() {
         await this.hydrateFromDisk();
         this.bindNetworkSubscriptions();
-        await this.network.start();
-        await this.log("info", `Local node started (${this.adapterMode}, mode=${this.networkMode}, signaling=${this.webrtcSignalingUrls[0] || "-"}, room=${this.webrtcRoom})`);
-        if (this.profile?.public_enabled && this.broadcastEnabled) {
-            try {
-                await this.broadcastNow("adapter_start");
-            }
-            catch (error) {
-                await this.log("warn", `Initial broadcast failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        this.startBroadcastLoop();
+        await this.startNetworkAdapterWithRetry("adapter_start");
     }
     async stop() {
+        this.clearNetworkReconnectTimer();
         if (this.broadcaster) {
             clearInterval(this.broadcaster);
             this.broadcaster = null;
         }
-        await this.network.stop();
+        await this.flushPrivatePersistence();
+        if (this.networkStarted) {
+            await this.network.stop();
+        }
+        this.networkStarted = false;
     }
     ensureLocalDirectoryBaseline() {
         if (this.profile) {
@@ -614,10 +932,11 @@ class LocalNodeService {
         }
     }
     getOverview() {
-        this.ensureLocalDirectoryBaseline();
-        this.compactCacheInMemory();
-        const profiles = Object.values(this.directory.profiles);
-        const onlineCount = profiles.filter((profile) => (0, core_1.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;
+        const openclawInstallation = detectOpenClawInstallation(this.projectRoot);
+        const openclawRuntime = this.getCachedOpenClawRuntime();
+        const openclawSkillInstallation = detectOpenClawSkillInstallation();
         return {
             app_version: this.appVersion,
             agent_id: this.identity?.agent_id ?? "",
@@ -627,12 +946,21 @@ 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(),
+            openclaw: {
+                detected: openclawInstallation.detected,
+                running: openclawRuntime.running,
+                detection_mode: openclawRuntime.detection_mode,
+                gateway_url: openclawRuntime.gateway_url,
+                gateway_probe_ok: openclawRuntime.gateway_probe_ok,
+                status_ok: openclawRuntime.status_ok,
+                skill_installed: openclawSkillInstallation.installed,
+            },
             social: {
                 found: this.socialFound,
                 enabled: this.socialConfig.enabled,
@@ -650,7 +978,9 @@ 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 {
             status: "running",
@@ -677,29 +1007,33 @@ 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,
+                    started: this.networkStarted,
+                    startup_error: this.networkStartupError,
+                    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,
@@ -713,23 +1047,25 @@ 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,
+                    started: this.networkStarted,
+                    startup_error: this.networkStartupError,
+                    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: {
@@ -756,15 +1092,18 @@ class LocalNodeService {
             demo_mode: this.adapterMode === "real-preview"
                 ? "lan-preview"
                 : this.adapterMode === "webrtc-preview" || this.adapterMode === "relay-preview"
-                    ? "internet-preview"
+                    ? "global-preview"
                     : "local-process",
             mode_explainer: this.getModeExplainer(),
         };
     }
     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 = diagnostics?.peers?.items ?? [];
         const online = peers.filter((peer) => peer.status === "online").length;
+        const memory = process.memoryUsage();
         return {
             adapter: this.adapterMode,
             mode: this.networkMode,
@@ -788,33 +1127,53 @@ 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
+            runtime_diagnostics: {
+                memory_mib: {
+                    rss: formatBytesToMiB(memory.rss),
+                    heap_used: formatBytesToMiB(memory.heapUsed),
+                    heap_total: formatBytesToMiB(memory.heapTotal),
+                    external: formatBytesToMiB(memory.external),
+                },
+                directory: {
+                    profile_count: Object.keys(this.directory.profiles).length,
+                    presence_count: Object.keys(this.directory.presence).length,
+                    index_key_count: Object.keys(this.directory.index).length,
+                },
+                social: {
+                    message_count: this.socialMessages.length,
+                    observation_count: this.socialMessageObservations.length,
+                },
+            },
+            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,
+                    started: this.networkStarted,
+                    startup_error: this.networkStartupError,
+                    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,
@@ -837,11 +1196,13 @@ 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,
+                started: this.networkStarted,
+                startup_error: this.networkStartupError,
+                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,
@@ -885,14 +1246,100 @@ class LocalNodeService {
     getRuntimePaths() {
         return {
             workspace_root: this.workspaceRoot,
+            project_root: this.projectRoot,
             storage_root: this.storageRoot,
             data_dir: (0, path_1.resolve)(this.storageRoot, "data"),
             social_runtime_path: (0, path_1.resolve)(this.storageRoot, ".silicaclaw", "social.runtime.json"),
             local_console_public_dir: (0, path_1.resolve)(this.workspaceRoot, "apps", "local-console", "public"),
-            social_lookup_paths: (0, core_1.getSocialConfigSearchPaths)(this.workspaceRoot),
+            social_lookup_paths: (0, core_1.getSocialConfigSearchPaths)(this.projectRoot),
             social_source_path: this.socialSourcePath,
         };
     }
+    getAppUpdateStatus() {
+        const currentVersion = normalizeVersionText(this.appVersion) || "unknown";
+        const fallback = {
+            current_version: currentVersion,
+            latest_version: currentVersion,
+            update_available: false,
+            channel: "latest",
+            platform: process.platform,
+            checked_at: Date.now(),
+            can_update: true,
+            check_error: null,
+        };
+        try {
+            const result = (0, child_process_1.spawnSync)("npm", ["view", "@silicaclaw/cli", "dist-tags", "--json"], {
+                cwd: this.projectRoot,
+                encoding: "utf8",
+                env: {
+                    ...process.env,
+                    SILICACLAW_WORKSPACE_DIR: this.projectRoot,
+                    SILICACLAW_APP_DIR: this.workspaceRoot,
+                    npm_config_cache: process.env.npm_config_cache || userNpmCacheDir(),
+                },
+            });
+            if ((result.status ?? 1) !== 0) {
+                return {
+                    ...fallback,
+                    check_error: String(result.stderr || result.stdout || "npm view failed").trim() || "npm view failed",
+                };
+            }
+            const tags = JSON.parse(String(result.stdout || "{}").trim() || "{}");
+            const latestVersion = normalizeVersionText(tags.latest || currentVersion) || currentVersion;
+            return {
+                ...fallback,
+                latest_version: latestVersion,
+                update_available: compareVersionTokens(latestVersion, currentVersion) > 0,
+            };
+        }
+        catch (error) {
+            return {
+                ...fallback,
+                check_error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    startAppUpdate() {
+        const status = this.getAppUpdateStatus();
+        if (!status.update_available || !status.latest_version) {
+            return {
+                started: false,
+                target_version: status.latest_version || status.current_version,
+                platform: process.platform,
+                reason: status.check_error || "already_current",
+            };
+        }
+        const shimPath = userShimPath();
+        const scriptPath = (0, path_1.resolve)(this.workspaceRoot, "scripts", "silicaclaw-cli.mjs");
+        const useShim = (0, fs_1.existsSync)(shimPath);
+        if (!useShim && !(0, fs_1.existsSync)(scriptPath)) {
+            return {
+                started: false,
+                target_version: status.latest_version,
+                platform: process.platform,
+                reason: "missing_cli_script",
+            };
+        }
+        const command = useShim ? shimPath : process.execPath;
+        const args = useShim ? ["update"] : [scriptPath, "update"];
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd: this.projectRoot,
+            detached: true,
+            stdio: "ignore",
+            env: {
+                ...process.env,
+                SILICACLAW_WORKSPACE_DIR: this.projectRoot,
+                SILICACLAW_APP_DIR: this.workspaceRoot,
+                npm_config_cache: process.env.npm_config_cache || userNpmCacheDir(),
+            },
+        });
+        child.unref();
+        return {
+            started: true,
+            target_version: status.latest_version,
+            platform: process.platform,
+        };
+    }
     getIntegrationSummary() {
         const status = this.getIntegrationStatus();
         const runtimeGenerated = Boolean(this.socialRuntime && this.socialRuntime.last_loaded_at > 0);
@@ -925,9 +1372,10 @@ class LocalNodeService {
     }
     getIntegrationStatus() {
         const runtimeGenerated = Boolean(this.socialRuntime && this.socialRuntime.last_loaded_at > 0);
-        const connected = this.socialFound && runtimeGenerated && !this.socialParseError;
-        const configured = connected && this.socialConfig.enabled;
-        const running = configured && this.broadcastEnabled;
+        const runtimeReady = this.socialFound && runtimeGenerated && !this.socialParseError;
+        const connected = runtimeReady && this.networkStarted;
+        const configured = runtimeReady && this.socialConfig.enabled;
+        const running = configured && this.broadcastEnabled && this.networkStarted;
         const publicEnabled = Boolean(this.profile?.public_enabled);
         const discoveryEnabled = this.socialConfig.discovery.discoverable &&
             this.socialConfig.discovery.allow_profile_broadcast &&
@@ -946,9 +1394,13 @@ class LocalNodeService {
             ? "running"
             : !configured
                 ? "not configured"
-                : !this.broadcastEnabled
-                    ? "broadcast paused"
-                    : "not running";
+                : this.networkReconnectTimer
+                    ? "reconnecting to relay"
+                    : this.networkStartupError
+                        ? this.networkStartupError
+                        : !this.broadcastEnabled
+                            ? "broadcast paused"
+                            : "not running";
         const discoverableReason = discoverable
             ? "discoverable"
             : !running
@@ -987,20 +1439,32 @@ class LocalNodeService {
         };
     }
     async setNetworkModeRuntime(mode) {
-        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.",
         };
     }
     async quickConnectGlobalPreview(options) {
@@ -1013,7 +1477,7 @@ 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;
@@ -1035,7 +1499,7 @@ class LocalNodeService {
             namespace: this.networkNamespace,
             port: this.networkPort,
         };
-        const loaded = (0, core_1.loadSocialConfig)(this.workspaceRoot);
+        const loaded = (0, core_1.loadSocialConfig)(this.projectRoot);
         this.socialConfig = loaded.config;
         this.socialSourcePath = loaded.meta.source_path;
         this.socialFound = loaded.meta.found;
@@ -1054,11 +1518,15 @@ class LocalNodeService {
                 before.adapter !== after.adapter ||
                 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 = (0, core_1.ensureDefaultSocialMd)(this.workspaceRoot, {
+        const result = (0, core_1.ensureDefaultSocialMd)(this.projectRoot, {
             display_name: this.getDefaultDisplayName(),
             bio: "Local AI agent connected to SilicaClaw",
             tags: ["openclaw", "local-first"],
@@ -1082,10 +1550,11 @@ class LocalNodeService {
     search(keyword) {
         this.ensureLocalDirectoryBaseline();
         this.compactCacheInMemory();
-        return (0, core_1.searchDirectory)(this.directory, keyword, { presenceTTLms: PRESENCE_TTL_MS }).map((profile) => {
+        const directMatches = (0, core_1.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() {
         if (!this.profile) {
@@ -1127,6 +1596,7 @@ class LocalNodeService {
                 return {
                     ...message,
                     display_name: profile?.display_name || message.display_name || "Unnamed",
+                    avatar_url: profile?.avatar_url || "",
                     is_self: message.agent_id === this.identity?.agent_id,
                     online: (0, core_1.isAgentOnline)(lastSeenAt, Date.now(), PRESENCE_TTL_MS),
                     last_seen_at: lastSeenAt || null,
@@ -1145,18 +1615,123 @@ class LocalNodeService {
             },
         };
     }
+    getPrivateMessagingState() {
+        return {
+            enabled: Boolean(this.identity && this.privateEncryptionKeyPair),
+            agent_id: this.identity?.agent_id || "",
+            encryption_public_key: this.privateEncryptionKeyPair?.public_key || "",
+            conversation_count: this.getPrivateConversations().length,
+            message_count: this.privateMessages.length,
+        };
+    }
+    getPrivateConversations() {
+        const conversations = new Map();
+        for (const message of this.privateMessages) {
+            if (message.from_agent_id === message.to_agent_id) {
+                continue;
+            }
+            const peerAgentId = message.from_agent_id === this.identity?.agent_id ? message.to_agent_id : message.from_agent_id;
+            if (!peerAgentId || peerAgentId === this.identity?.agent_id) {
+                continue;
+            }
+            const peerProfile = this.directory.profiles[peerAgentId];
+            const current = conversations.get(message.conversation_id);
+            const nextLast = Math.max(current?.last_message_at || 0, message.created_at || 0) || null;
+            conversations.set(message.conversation_id, {
+                conversation_id: message.conversation_id,
+                peer_agent_id: peerAgentId,
+                peer_display_name: peerProfile?.display_name || peerAgentId,
+                peer_avatar_url: peerProfile?.avatar_url || "",
+                peer_public_key: peerProfile?.private_encryption_public_key || "",
+                last_message_at: nextLast,
+                unread_count: current?.unread_count || 0,
+            });
+        }
+        return Array.from(conversations.values()).sort((a, b) => (b.last_message_at || 0) - (a.last_message_at || 0));
+    }
+    getPrivateMessages(conversationId, limit = PRIVATE_MESSAGE_QUERY_LIMIT) {
+        const normalizedConversationId = String(conversationId || "").trim();
+        const resolvedLimit = Math.max(1, Math.min(PRIVATE_MESSAGE_QUERY_LIMIT, Number(limit) || PRIVATE_MESSAGE_QUERY_LIMIT));
+        const receiptsByMessageId = new Map(this.privateMessageReceipts.map((receipt) => [receipt.message_id, receipt.status]));
+        return this.privateMessages
+            .filter((message) => {
+            if (message.from_agent_id === message.to_agent_id) {
+                return false;
+            }
+            const peerAgentId = message.from_agent_id === this.identity?.agent_id ? message.to_agent_id : message.from_agent_id;
+            if (!peerAgentId || peerAgentId === this.identity?.agent_id) {
+                return false;
+            }
+            return !normalizedConversationId || message.conversation_id === normalizedConversationId;
+        })
+            .sort((a, b) => a.created_at - b.created_at)
+            .slice(-resolvedLimit)
+            .map((message) => ({
+            message_id: message.message_id,
+            conversation_id: message.conversation_id,
+            from_agent_id: message.from_agent_id,
+            to_agent_id: message.to_agent_id,
+            body: this.decryptPrivateMessageBody(message),
+            created_at: message.created_at,
+            is_self: message.from_agent_id === this.identity?.agent_id,
+            delivery_status: receiptsByMessageId.get(message.message_id) || "sent",
+        }));
+    }
+    async sendPrivateMessage(input) {
+        if (!this.identity || !this.privateEncryptionKeyPair) {
+            return { sent: false, reason: "missing_identity_or_private_key" };
+        }
+        const toAgentId = String(input.to_agent_id || "").trim();
+        const recipientKey = String(input.recipient_encryption_public_key || "").trim();
+        const body = String(input.body || "").trim();
+        if (toAgentId === this.identity.agent_id) {
+            return { sent: false, reason: "self_private_message_not_allowed" };
+        }
+        const toPeerId = this.privatePeerRoutes[toAgentId] || "";
+        if (!toAgentId || !toPeerId || !recipientKey || !body) {
+            return { sent: false, reason: "invalid_private_message_input" };
+        }
+        if (typeof this.network.sendDirect !== "function") {
+            return { sent: false, reason: "direct_delivery_not_supported" };
+        }
+        const encrypted = (0, core_1.encryptPrivatePayload)({
+            plaintext: body,
+            recipient_public_key: recipientKey,
+            sender_keypair: this.privateEncryptionKeyPair,
+        });
+        const message = (0, core_1.signPrivateMessage)({
+            identity: this.identity,
+            message_id: (0, crypto_1.createHash)("sha256").update(`${this.identity.agent_id}:${toAgentId}:${Date.now()}:${body}:${Math.random()}`, "utf8").digest("hex"),
+            conversation_id: this.buildPrivateConversationId(this.identity.agent_id, toAgentId),
+            to_agent_id: toAgentId,
+            sender_encryption_public_key: encrypted.sender_encryption_public_key,
+            recipient_encryption_public_key: recipientKey,
+            ciphertext: encrypted.ciphertext,
+            nonce: encrypted.nonce,
+            created_at: Date.now(),
+        });
+        this.ingestPrivateMessage(message);
+        await this.persistPrivateMessages();
+        await this.network.sendDirect(toPeerId, PRIVATE_MESSAGE_TOPIC, message);
+        const view = this.getPrivateMessages(message.conversation_id).find((item) => item.message_id === message.message_id);
+        return { sent: true, reason: "sent", message: view };
+    }
     getOpenClawBridgeStatus() {
+        const now = Date.now();
+        if (this.openclawBridgeStatusCache && this.openclawBridgeStatusCache.expiresAt > now) {
+            return this.openclawBridgeStatusCache.value;
+        }
         const integration = this.getIntegrationStatus();
-        const openclawInstallation = detectOpenClawInstallation(this.workspaceRoot);
-        const openclawRuntime = detectOpenClawRuntime(this.workspaceRoot);
+        const openclawInstallation = detectOpenClawInstallation(this.projectRoot);
+        const openclawRuntime = this.getCachedOpenClawRuntime();
         const skillInstallation = detectOpenClawSkillInstallation();
         const ownerDelivery = detectOwnerDeliveryStatus({
-            workspaceRoot: this.workspaceRoot,
+            workspaceRoot: this.projectRoot,
             connectedToSilicaclaw: integration.connected_to_silicaclaw,
             openclawRunning: openclawRuntime.running,
             skillInstalled: skillInstallation.installed,
         });
-        return {
+        const value = {
             enabled: this.socialConfig.enabled,
             connected_to_silicaclaw: integration.connected_to_silicaclaw,
             public_enabled: integration.public_enabled,
@@ -1212,15 +1787,25 @@ class LocalNodeService {
                 install_skill: "/api/openclaw/bridge/skill-install",
             },
         };
+        this.openclawBridgeStatusCache = {
+            value,
+            expiresAt: now + OPENCLAW_BRIDGE_STATUS_CACHE_MS,
+        };
+        return value;
     }
-    async installOpenClawSkill() {
+    async installOpenClawSkill(skillName) {
         const scriptPath = (0, path_1.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 || "{}"));
+        this.invalidateOpenClawCaches();
         return {
             ...parsed,
             bridge: this.getOpenClawBridgeStatus(),
@@ -1239,11 +1824,11 @@ class LocalNodeService {
         const homeDir = (0, path_1.resolve)(process.env.HOME || "", ".openclaw");
         const workspaceSkillDir = (0, path_1.resolve)(homeDir, "workspace", "skills");
         const legacySkillDir = (0, path_1.resolve)(homeDir, "skills");
-        const openclawSourceDir = (0, path_1.resolve)(this.workspaceRoot, "..", "openclaw");
-        const openclawRuntime = detectOpenClawRuntime(this.workspaceRoot);
+        const openclawSourceDir = defaultOpenClawSourceDir(this.projectRoot);
+        const openclawRuntime = this.getCachedOpenClawRuntime();
         return {
-            bridge_api_base: "http://localhost:4310",
-            openclaw_detected: detectOpenClawInstallation(this.workspaceRoot).detected,
+            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,
@@ -1252,7 +1837,7 @@ class LocalNodeService {
             openclaw_workspace_skill_dir: workspaceSkillDir,
             openclaw_legacy_skill_dir: legacySkillDir,
             silicaclaw_env_template_path: (0, path_1.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,
@@ -1270,6 +1855,7 @@ 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.",
@@ -1288,6 +1874,12 @@ class LocalNodeService {
             const skillPath = (0, path_1.resolve)(dir.path, "SKILL.md");
             const versionPath = (0, path_1.resolve)(dir.path, "VERSION");
             const manifest = readJsonFileSafe(manifestPath);
+            const references = (manifest?.references && typeof manifest.references === "object")
+                ? manifest.references
+                : null;
+            const ownerDialogueCheatsheetPath = references?.owner_dialogue_cheatsheet_zh
+                ? (0, path_1.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))
@@ -1307,6 +1899,9 @@ class LocalNodeService {
                 skill_path: (0, fs_1.existsSync)(skillPath) ? skillPath : null,
                 capabilities,
                 transport: manifest?.transport || null,
+                owner_dialogue_cheatsheet_path: ownerDialogueCheatsheetPath && (0, fs_1.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,
@@ -1320,6 +1915,12 @@ class LocalNodeService {
             const skillPath = (0, path_1.resolve)(dir.path, "SKILL.md");
             const versionPath = (0, path_1.resolve)(dir.path, "VERSION");
             const manifest = readJsonFileSafe(manifestPath);
+            const references = (manifest?.references && typeof manifest.references === "object")
+                ? manifest.references
+                : null;
+            const ownerDialogueCheatsheetPath = references?.owner_dialogue_cheatsheet_zh
+                ? (0, path_1.resolve)(dir.path, String(references.owner_dialogue_cheatsheet_zh))
+                : null;
             return {
                 key: `${dir.install_mode}:${dir.name}`,
                 name: String(manifest?.name || dir.name),
@@ -1331,9 +1932,37 @@ class LocalNodeService {
                 manifest_path: (0, fs_1.existsSync)(manifestPath) ? manifestPath : null,
                 skill_path: (0, fs_1.existsSync)(skillPath) ? skillPath : null,
                 capabilities: Array.isArray(manifest?.capabilities) ? manifest.capabilities.map((item) => String(item)) : [],
+                owner_dialogue_cheatsheet_path: ownerDialogueCheatsheetPath && (0, fs_1.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,
@@ -1344,13 +1973,14 @@ class LocalNodeService {
                 legacy_install_root: legacyInstallRoot,
             },
             summary: {
-                bundled_count: bundledSkills.length,
-                installed_count: installedSkills.length,
-                installed_bundled_count: bundledSkills.filter((item) => item.installed_in_openclaw).length,
+                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: bundledSkills,
-            installed_skills: installedSkills,
+            bundled_skills: bundledSkillsWithUpdateState,
+            installed_skills: installedSkillsWithUpdateState,
         };
     }
     getRuntimeMessageGovernance() {
@@ -1568,12 +2198,15 @@ class LocalNodeService {
             profile: this.profile,
         };
         const presenceRecord = (0, core_1.signPresence)(this.identity, Date.now());
-        const indexRecords = (0, core_1.buildIndexRecords)(this.profile);
+        const shouldPublishProfile = this.shouldPublishProfileRecord(profileRecord, reason, presenceRecord.timestamp);
+        const replayMessages = this.getReplayableSelfSocialMessages(reason);
         try {
-            await this.publish("profile", profileRecord);
+            if (shouldPublishProfile) {
+                await this.publish("profile", profileRecord);
+            }
             await this.publish("presence", presenceRecord);
-            for (const record of indexRecords) {
-                await this.publish("index", record);
+            for (const message of replayMessages) {
+                await this.publish(SOCIAL_MESSAGE_TOPIC, message);
             }
         }
         catch (error) {
@@ -1581,23 +2214,67 @@ class LocalNodeService {
             this.lastBroadcastErrorAt = Date.now();
             this.lastBroadcastError = message;
             this.broadcastFailureCount += 1;
+            this.consecutiveBroadcastFailures += 1;
             await this.log("error", `Broadcast failed (reason=${reason}): ${message}`);
+            await this.maybeRecoverFromBroadcastFailure(reason, message);
             return { sent: false, reason: "publish_failed", error: message };
         }
         this.lastBroadcastAt = Date.now();
         this.broadcastCount += 1;
         this.lastBroadcastError = null;
         this.lastBroadcastErrorAt = 0;
+        this.consecutiveBroadcastFailures = 0;
         this.directory = (0, core_1.ingestProfileRecord)(this.directory, profileRecord);
         this.directory = (0, core_1.ingestPresenceRecord)(this.directory, presenceRecord);
-        for (const record of indexRecords) {
-            this.directory = (0, core_1.ingestIndexRecord)(this.directory, record);
-        }
         this.compactCacheInMemory();
         await this.persistCache();
-        await this.log("info", `Broadcast sent (${indexRecords.length} index refs, reason=${reason})`);
+        await this.log("info", `Broadcast sent (${shouldPublishProfile ? "profile + " : ""}presence, replayed_messages=${replayMessages.length}, reason=${reason})`);
         return { sent: true, reason };
     }
+    shouldPublishProfileRecord(profileRecord, reason, now = Date.now()) {
+        if (reason !== "interval") {
+            this.lastProfileBroadcastSignature = profileRecord.profile.signature;
+            this.lastProfileBroadcastAt = now;
+            return true;
+        }
+        const signature = profileRecord.profile.signature;
+        const changedSinceLastPublish = signature !== this.lastProfileBroadcastSignature;
+        const refreshDue = now - this.lastProfileBroadcastAt >= PROFILE_RELAY_REFRESH_INTERVAL_MS;
+        if (!changedSinceLastPublish && !refreshDue) {
+            return false;
+        }
+        this.lastProfileBroadcastSignature = signature;
+        this.lastProfileBroadcastAt = now;
+        return true;
+    }
+    async maybeRecoverFromBroadcastFailure(reason, errorMessage) {
+        const recoveryThreshold = 3;
+        const recoveryCooldownMs = 60_000;
+        if (this.broadcastRecoveryInFlight) {
+            return;
+        }
+        if (this.consecutiveBroadcastFailures < recoveryThreshold) {
+            return;
+        }
+        if (Date.now() - this.lastBroadcastRecoveryAttemptAt < recoveryCooldownMs) {
+            return;
+        }
+        if (this.adapterMode !== "relay-preview" && this.adapterMode !== "webrtc-preview" && this.adapterMode !== "real-preview") {
+            return;
+        }
+        this.broadcastRecoveryInFlight = true;
+        this.lastBroadcastRecoveryAttemptAt = Date.now();
+        try {
+            await this.log("warn", `Broadcast recovery triggered after ${this.consecutiveBroadcastFailures} consecutive failures (${reason}): ${errorMessage}`);
+            await this.restartNetworkAdapter("broadcast_failure_recovery");
+        }
+        catch (recoveryError) {
+            await this.log("error", `Broadcast recovery failed: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`);
+        }
+        finally {
+            this.broadcastRecoveryInFlight = false;
+        }
+    }
     async hydrateFromDisk() {
         this.initState = {
             identity_auto_created: false,
@@ -1613,7 +2290,7 @@ class LocalNodeService {
             socialConfig: this.socialConfig,
             existingIdentity,
             generatedIdentity: (0, core_1.createIdentity)(),
-            rootDir: this.workspaceRoot,
+            rootDir: this.projectRoot,
         });
         this.identity = resolvedIdentity.identity;
         this.resolvedIdentitySource = resolvedIdentity.source;
@@ -1626,26 +2303,33 @@ class LocalNodeService {
             await this.log("info", `Bound existing OpenClaw identity: ${resolvedIdentity.openclaw_source_path}`);
         }
         await this.identityRepo.set(this.identity);
+        this.privateEncryptionKeyPair = (await this.privateEncryptionKeyRepo.get()) || (0, core_1.createPrivateEncryptionKeyPair)();
+        await this.privateEncryptionKeyRepo.set(this.privateEncryptionKeyPair);
         const existingProfile = await this.profileRepo.get();
         const profileInput = (0, core_1.resolveProfileInputWithSocial)({
             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 = (0, core_1.signProfile)(profileInput, this.identity);
+        this.profile = (0, core_1.signProfile)({
+            ...profileInput,
+            private_encryption_public_key: this.privateEncryptionKeyPair?.public_key || profileInput.private_encryption_public_key || "",
+        }, this.identity);
         if (!existingProfile || existingProfile.agent_id !== this.identity.agent_id) {
             this.initState.profile_auto_created = true;
             await this.log("info", "profile.json missing/invalid, initialized from social/default profile");
         }
         await this.profileRepo.set(this.profile);
-        this.directory = (0, core_1.dedupeIndex)(await this.cacheRepo.get());
+        this.directory = (0, core_1.createEmptyDirectoryState)();
         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.privateMessages = this.normalizePrivateMessages(await this.privateMessageRepo.get());
+        this.privateMessageReceipts = this.normalizePrivateMessageReceipts(await this.privateMessageReceiptRepo.get());
         this.directory = (0, core_1.ingestProfileRecord)(this.directory, { type: "profile", profile: this.profile });
         this.compactCacheInMemory();
         await this.persistCache();
@@ -1660,9 +2344,12 @@ class LocalNodeService {
             socialConfig: this.socialConfig,
             agentId: this.identity.agent_id,
             existingProfile: this.profile,
-            rootDir: this.workspaceRoot,
+            rootDir: this.projectRoot,
         });
-        const nextProfile = (0, core_1.signProfile)(nextProfileInput, this.identity);
+        const nextProfile = (0, core_1.signProfile)({
+            ...nextProfileInput,
+            private_encryption_public_key: this.privateEncryptionKeyPair?.public_key || nextProfileInput.private_encryption_public_key || "",
+        }, this.identity);
         this.profile = nextProfile;
         await this.profileRepo.set(nextProfile);
         this.directory = (0, core_1.ingestProfileRecord)(this.directory, { type: "profile", profile: nextProfile });
@@ -1720,7 +2407,7 @@ class LocalNodeService {
         this.socialRuntime = runtime;
         await this.socialRuntimeRepo.set(runtime);
     }
-    async onMessage(topic, data) {
+    async onMessage(topic, data, meta) {
         this.receivedCount += 1;
         this.receivedByTopic[topic] = (this.receivedByTopic[topic] ?? 0) + 1;
         this.lastMessageAt = Date.now();
@@ -1735,6 +2422,9 @@ class LocalNodeService {
                     return;
                 }
             }
+            if (meta?.peerId && record.profile.agent_id) {
+                this.privatePeerRoutes[record.profile.agent_id] = meta.peerId;
+            }
             this.directory = (0, core_1.ingestProfileRecord)(this.directory, record);
             this.compactCacheInMemory();
             await this.persistCache();
@@ -1751,6 +2441,9 @@ class LocalNodeService {
                     return;
                 }
             }
+            if (meta?.peerId && record.agent_id) {
+                this.privatePeerRoutes[record.agent_id] = meta.peerId;
+            }
             this.directory = (0, core_1.ingestPresenceRecord)(this.directory, record);
             this.compactCacheInMemory();
             await this.persistCache();
@@ -1765,6 +2458,13 @@ class LocalNodeService {
                 await this.log("warn", `Rejected social message with invalid signature (${record.message_id.slice(0, 10)})`);
                 return;
             }
+            if (meta?.peerId && record.agent_id) {
+                this.privatePeerRoutes[record.agent_id] = meta.peerId;
+            }
+            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}`);
@@ -1796,11 +2496,35 @@ class LocalNodeService {
         this.directory = (0, core_1.dedupeIndex)(this.directory);
         await this.persistCache();
     }
+    async onDirectMessage(topic, data, meta) {
+        if (topic === PRIVATE_MESSAGE_TOPIC) {
+            const record = this.normalizeIncomingPrivateMessage(data);
+            if (!record || !(0, core_1.verifyPrivateMessage)(record)) {
+                return;
+            }
+            if (record.to_agent_id !== this.identity?.agent_id || this.hasPrivateMessage(record.message_id)) {
+                return;
+            }
+            this.ingestPrivateMessage(record);
+            await this.persistPrivateMessages();
+            await this.sendPrivateMessageReceipt(record, meta?.peerId);
+            return;
+        }
+        const receipt = this.normalizeIncomingPrivateMessageReceipt(data);
+        if (!receipt || !(0, core_1.verifyPrivateMessageReceipt)(receipt)) {
+            return;
+        }
+        if (receipt.to_agent_id !== this.identity?.agent_id) {
+            return;
+        }
+        this.ingestPrivateMessageReceipt(receipt);
+        await this.persistPrivateMessageReceipts();
+    }
     startBroadcastLoop() {
         if (this.broadcaster) {
             clearInterval(this.broadcaster);
         }
-        if (!this.broadcastEnabled) {
+        if (!this.broadcastEnabled || !this.networkStarted) {
             return;
         }
         this.broadcaster = setInterval(async () => {
@@ -1816,21 +2540,29 @@ class LocalNodeService {
         if (this.subscriptionsBound) {
             return;
         }
-        this.network.subscribe("profile", (data) => {
-            this.onMessage("profile", data);
+        this.network.subscribe("profile", (data, meta) => {
+            this.onMessage("profile", data, meta);
         });
-        this.network.subscribe("presence", (data) => {
-            this.onMessage("presence", data);
+        this.network.subscribe("presence", (data, meta) => {
+            this.onMessage("presence", data, meta);
         });
-        this.network.subscribe("index", (data) => {
-            this.onMessage("index", data);
+        this.network.subscribe("index", (data, meta) => {
+            this.onMessage("index", data, meta);
         });
-        this.network.subscribe(SOCIAL_MESSAGE_TOPIC, (data) => {
-            this.onMessage(SOCIAL_MESSAGE_TOPIC, data);
+        this.network.subscribe(SOCIAL_MESSAGE_TOPIC, (data, meta) => {
+            this.onMessage(SOCIAL_MESSAGE_TOPIC, data, meta);
         });
-        this.network.subscribe(SOCIAL_MESSAGE_OBSERVATION_TOPIC, (data) => {
-            this.onMessage(SOCIAL_MESSAGE_OBSERVATION_TOPIC, data);
+        this.network.subscribe(SOCIAL_MESSAGE_OBSERVATION_TOPIC, (data, meta) => {
+            this.onMessage(SOCIAL_MESSAGE_OBSERVATION_TOPIC, data, meta);
         });
+        if (typeof this.network.subscribeDirect === "function") {
+            this.network.subscribeDirect(PRIVATE_MESSAGE_TOPIC, (data, meta) => {
+                this.onDirectMessage(PRIVATE_MESSAGE_TOPIC, data, meta);
+            });
+            this.network.subscribeDirect(PRIVATE_MESSAGE_RECEIPT_TOPIC, (data, meta) => {
+                this.onDirectMessage(PRIVATE_MESSAGE_RECEIPT_TOPIC, data, meta);
+            });
+        }
         this.subscriptionsBound = true;
     }
     buildNetworkAdapter() {
@@ -1912,6 +2644,7 @@ class LocalNodeService {
         };
     }
     async restartNetworkAdapter(reason) {
+        this.clearNetworkReconnectTimer();
         const previous = this.network;
         try {
             await previous.stop();
@@ -1923,16 +2656,104 @@ class LocalNodeService {
         this.network = next.adapter;
         this.adapterMode = next.mode;
         this.networkPort = next.port;
-        await this.network.start();
+        this.subscriptionsBound = false;
         this.bindNetworkSubscriptions();
-        this.startBroadcastLoop();
-        if (this.broadcastEnabled && this.profile?.public_enabled) {
-            await this.broadcastNow("adapter_restart");
+        await this.startNetworkAdapterWithRetry(reason);
+    }
+    clearNetworkReconnectTimer() {
+        if (this.networkReconnectTimer) {
+            clearTimeout(this.networkReconnectTimer);
+            this.networkReconnectTimer = null;
+        }
+    }
+    async startNetworkAdapterWithRetry(reason) {
+        this.clearNetworkReconnectTimer();
+        try {
+            await this.network.start();
+            this.networkStarted = true;
+            this.networkStartupError = null;
+            this.networkReconnectDelayMs = 5_000;
+            await this.log("info", `Local node started (${this.adapterMode}, mode=${this.networkMode}, signaling=${this.webrtcSignalingUrls[0] || "-"}, room=${this.webrtcRoom})`);
+            this.startBroadcastLoop();
+            if (this.broadcastEnabled && this.profile?.public_enabled) {
+                try {
+                    await this.broadcastNow(reason);
+                }
+                catch (error) {
+                    await this.log("warn", `Initial broadcast failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        catch (error) {
+            this.networkStarted = false;
+            this.networkStartupError = error instanceof Error ? error.message : String(error);
+            await this.log("warn", `Network start failed (${this.adapterMode}, mode=${this.networkMode}): ${this.networkStartupError}`);
+            this.scheduleNetworkReconnect();
         }
     }
+    scheduleNetworkReconnect() {
+        if (this.networkReconnectTimer) {
+            return;
+        }
+        const delayMs = this.networkReconnectDelayMs;
+        this.networkReconnectTimer = setTimeout(() => {
+            this.networkReconnectTimer = null;
+            void this.startNetworkAdapterWithRetry("adapter_reconnect");
+        }, delayMs);
+        this.networkReconnectDelayMs = Math.min(30_000, Math.max(5_000, Math.floor(delayMs * 1.5)));
+    }
+    pruneRemoteProfilesInMemory(now = Date.now()) {
+        if (!Number.isFinite(DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT) || DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT <= 0) {
+            return 0;
+        }
+        const selfAgentId = this.profile?.agent_id || this.identity?.agent_id || "";
+        const remoteProfiles = Object.values(this.directory.profiles).filter((profile) => profile.agent_id !== selfAgentId);
+        if (remoteProfiles.length <= DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT) {
+            return 0;
+        }
+        const onlineRemoteProfiles = remoteProfiles.filter((profile) => (0, core_1.isAgentOnline)(this.directory.presence[profile.agent_id], now, PRESENCE_TTL_MS));
+        const offlineRemoteProfiles = remoteProfiles
+            .filter((profile) => !(0, core_1.isAgentOnline)(this.directory.presence[profile.agent_id], now, PRESENCE_TTL_MS))
+            .sort((a, b) => (b.updated_at || 0) - (a.updated_at || 0));
+        const keepOfflineCount = Math.max(0, DIRECTORY_REMOTE_PROFILE_SOFT_LIMIT - onlineRemoteProfiles.length);
+        const keptRemoteProfiles = [
+            ...onlineRemoteProfiles,
+            ...offlineRemoteProfiles.slice(0, keepOfflineCount),
+        ];
+        const keptRemoteIds = new Set(keptRemoteProfiles.map((profile) => profile.agent_id));
+        const removedIds = remoteProfiles
+            .map((profile) => profile.agent_id)
+            .filter((agentId) => !keptRemoteIds.has(agentId));
+        if (removedIds.length === 0) {
+            return 0;
+        }
+        const next = (0, core_1.createEmptyDirectoryState)();
+        const selfProfile = selfAgentId ? this.directory.profiles[selfAgentId] : null;
+        if (selfProfile) {
+            next.profiles[selfAgentId] = selfProfile;
+            const selfPresence = this.directory.presence[selfAgentId];
+            if (typeof selfPresence === "number" && Number.isFinite(selfPresence)) {
+                next.presence[selfAgentId] = selfPresence;
+            }
+            const rebuilt = (0, core_1.rebuildIndexForProfile)(next, selfProfile);
+            next.index = rebuilt.index;
+        }
+        for (const profile of keptRemoteProfiles) {
+            next.profiles[profile.agent_id] = profile;
+            const seenAt = this.directory.presence[profile.agent_id];
+            if (typeof seenAt === "number" && Number.isFinite(seenAt)) {
+                next.presence[profile.agent_id] = seenAt;
+            }
+            const rebuilt = (0, core_1.rebuildIndexForProfile)(next, profile);
+            next.index = rebuilt.index;
+        }
+        this.directory = (0, core_1.dedupeIndex)(next);
+        return removedIds.length;
+    }
     compactCacheInMemory() {
         const cleaned = (0, core_1.cleanupExpiredPresence)(this.directory, Date.now(), PRESENCE_TTL_MS);
         this.directory = (0, core_1.dedupeIndex)(cleaned.state);
+        this.pruneRemoteProfilesInMemory();
         return cleaned.removed;
     }
     async publish(topic, data) {
@@ -1940,7 +2761,22 @@ class LocalNodeService {
         this.publishedByTopic[topic] = (this.publishedByTopic[topic] ?? 0) + 1;
     }
     async persistCache() {
-        await this.cacheRepo.set(this.directory);
+        const persisted = (0, core_1.createEmptyDirectoryState)();
+        if (this.profile) {
+            const selfProfileRecord = {
+                type: "profile",
+                profile: this.profile,
+            };
+            this.directory = (0, core_1.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 = (0, core_1.rebuildIndexForProfile)(persisted, this.profile);
+            persisted.index = indexed.index;
+        }
+        await this.cacheRepo.set(persisted);
     }
     async persistSocialMessages() {
         await this.socialMessageRepo.set(this.socialMessages);
@@ -1948,6 +2784,52 @@ class LocalNodeService {
     async persistSocialMessageObservations() {
         await this.socialMessageObservationRepo.set(this.socialMessageObservations);
     }
+    async persistPrivateMessages() {
+        this.privateMessagesPersistDirty = true;
+        if (this.privateMessagesPersistTimer) {
+            return;
+        }
+        this.privateMessagesPersistTimer = setTimeout(() => {
+            this.flushPrivateMessagesPersist().catch(() => { });
+        }, PRIVATE_MESSAGE_PERSIST_DEBOUNCE_MS);
+    }
+    async persistPrivateMessageReceipts() {
+        this.privateMessageReceiptsPersistDirty = true;
+        if (this.privateMessageReceiptsPersistTimer) {
+            return;
+        }
+        this.privateMessageReceiptsPersistTimer = setTimeout(() => {
+            this.flushPrivateMessageReceiptsPersist().catch(() => { });
+        }, PRIVATE_MESSAGE_PERSIST_DEBOUNCE_MS);
+    }
+    async flushPrivatePersistence() {
+        await Promise.all([
+            this.flushPrivateMessagesPersist(),
+            this.flushPrivateMessageReceiptsPersist(),
+        ]);
+    }
+    async flushPrivateMessagesPersist() {
+        if (this.privateMessagesPersistTimer) {
+            clearTimeout(this.privateMessagesPersistTimer);
+            this.privateMessagesPersistTimer = null;
+        }
+        if (!this.privateMessagesPersistDirty) {
+            return;
+        }
+        this.privateMessagesPersistDirty = false;
+        await this.privateMessageRepo.set(this.privateMessages);
+    }
+    async flushPrivateMessageReceiptsPersist() {
+        if (this.privateMessageReceiptsPersistTimer) {
+            clearTimeout(this.privateMessageReceiptsPersistTimer);
+            this.privateMessageReceiptsPersistTimer = null;
+        }
+        if (!this.privateMessageReceiptsPersistDirty) {
+            return;
+        }
+        this.privateMessageReceiptsPersistDirty = false;
+        await this.privateMessageReceiptRepo.set(this.privateMessageReceipts);
+    }
     async log(level, message) {
         await this.logRepo.append({
             level,
@@ -1961,6 +2843,18 @@ class LocalNodeService {
         }
         return this.network.getDiagnostics();
     }
+    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,
+        };
+    }
     toPublicProfileSummary(profile, options) {
         const lastSeenAt = options?.last_seen_at ?? this.directory.presence[profile.agent_id] ?? 0;
         const online = (0, core_1.isAgentOnline)(lastSeenAt, Date.now(), PRESENCE_TTL_MS);
@@ -1982,6 +2876,7 @@ class LocalNodeService {
             (0, core_1.verifyProfile)(profile, selfPublicKey));
         return (0, core_1.buildPublicProfileSummary)({
             profile,
+            is_self: isSelf,
             online,
             last_seen_at: lastSeenAt || null,
             network_mode: isSelf ? this.networkMode : "unknown",
@@ -1996,6 +2891,63 @@ class LocalNodeService {
             presence_ttl_ms: PRESENCE_TTL_MS,
         });
     }
+    mergeMessageOnlyAgentSummaries(summaries, keyword) {
+        const normalizedKeyword = String(keyword || "").trim().toLowerCase();
+        const knownAgentIds = new Set(summaries.map((item) => item.agent_id));
+        const messageOnly = [];
+        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((0, core_1.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: "",
+                },
+                is_self: message.agent_id === this.identity?.agent_id,
+                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);
+        });
+    }
     fingerprintPublicKey(publicKey) {
         const digest = (0, crypto_1.createHash)("sha256").update(publicKey, "utf8").digest("hex");
         return `${digest.slice(0, 12)}:${digest.slice(-8)}`;
@@ -2003,6 +2955,22 @@ class LocalNodeService {
     getOnboardingSummary() {
         const summary = this.getIntegrationSummary();
         const publicEnabled = Boolean(this.profile?.public_enabled);
+        const nextSteps = [];
+        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 ||
                 this.initState.identity_auto_created ||
@@ -2012,10 +2980,7 @@ 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,
         };
     }
     getDefaultDisplayName() {
@@ -2038,7 +3003,7 @@ 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.",
         };
@@ -2066,12 +3031,12 @@ class LocalNodeService {
         const resolvedMode = 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);
-        const builtInGlobalSignalingUrls = ["https://relay.silicaclaw.com"];
-        const builtInGlobalRoom = "silicaclaw-global-preview";
+        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 = [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();
         const signalingUrlsEnv = dedupeStrings(parseListEnv(WEBRTC_SIGNALING_URLS));
@@ -2099,22 +3064,22 @@ class LocalNodeService {
             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();
         const roomEnv = String(WEBRTC_ROOM || "").trim();
         const room = 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));
         const seedPeers = seedPeersSocial.length > 0 ? seedPeersSocial : seedPeersEnv;
@@ -2145,6 +3110,32 @@ class LocalNodeService {
             .join("\n")
             .trim();
     }
+    buildPrivateConversationId(leftAgentId, rightAgentId) {
+        return [String(leftAgentId || "").trim(), String(rightAgentId || "").trim()].sort().join(":");
+    }
+    decryptPrivateMessageBody(message) {
+        const cached = this.privateMessageBodyCache.get(message.message_id);
+        if (typeof cached === "string") {
+            return cached;
+        }
+        if (!this.privateEncryptionKeyPair) {
+            return "[encrypted]";
+        }
+        const decrypted = (0, core_1.decryptPrivatePayload)({
+            ciphertext: message.ciphertext,
+            nonce: message.nonce,
+            sender_encryption_public_key: message.sender_encryption_public_key,
+            recipient_private_key: this.privateEncryptionKeyPair.private_key,
+        }) || "[encrypted]";
+        this.privateMessageBodyCache.set(message.message_id, decrypted);
+        if (this.privateMessageBodyCache.size > PRIVATE_MESSAGE_HISTORY_LIMIT * 2) {
+            const firstKey = this.privateMessageBodyCache.keys().next().value;
+            if (firstKey) {
+                this.privateMessageBodyCache.delete(firstKey);
+            }
+        }
+        return decrypted;
+    }
     normalizeWindowTimestamps(timestamps, windowMs, now = Date.now()) {
         return timestamps.filter((timestamp) => now - timestamp <= windowMs);
     }
@@ -2162,6 +3153,34 @@ class LocalNodeService {
         const normalized = String(body || "").toLowerCase();
         return this.messageGovernance.blocked_terms.some((term) => normalized.includes(term));
     }
+    hasSocialMessage(messageId) {
+        return this.socialMessages.some((item) => item.message_id === messageId);
+    }
+    getReplayableSelfSocialMessages(reason = "manual", now = Date.now()) {
+        const maxCount = Math.max(0, SOCIAL_MESSAGE_REPLAY_MAX_PER_BROADCAST);
+        if (!this.identity || maxCount === 0) {
+            return [];
+        }
+        const replayable = 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);
+        if (!replayable.length) {
+            this.lastReplayBroadcastSignature = "";
+            return [];
+        }
+        const signature = replayable.map((item) => item.message_id).join(",");
+        const isIntervalReplay = reason === "interval";
+        const changedSinceLastReplay = signature !== this.lastReplayBroadcastSignature;
+        const refreshDue = now - this.lastReplayBroadcastAt >= SOCIAL_MESSAGE_REPLAY_REFRESH_INTERVAL_MS;
+        if (isIntervalReplay && !changedSinceLastReplay && !refreshDue) {
+            return [];
+        }
+        this.lastReplayBroadcastSignature = signature;
+        this.lastReplayBroadcastAt = now;
+        return replayable;
+    }
     hasRecentDuplicateMessage(agentId, body, topic, now = Date.now()) {
         return this.socialMessages.some((item) => (item.agent_id === agentId &&
             item.topic === topic &&
@@ -2224,6 +3243,167 @@ class LocalNodeService {
         await this.publish(SOCIAL_MESSAGE_OBSERVATION_TOPIC, observation);
         await this.persistSocialMessageObservations();
     }
+    async sendPrivateMessageReceipt(message, replyPeerId) {
+        if (!this.identity || typeof this.network.sendDirect !== "function" || !replyPeerId) {
+            return;
+        }
+        const receipt = (0, core_1.signPrivateMessageReceipt)({
+            identity: this.identity,
+            receipt_id: (0, crypto_1.createHash)("sha256").update(`${message.message_id}:${this.identity.agent_id}:${Date.now()}`, "utf8").digest("hex"),
+            message_id: message.message_id,
+            conversation_id: message.conversation_id,
+            to_agent_id: message.from_agent_id,
+            status: "received",
+            created_at: Date.now(),
+        });
+        this.ingestPrivateMessageReceipt(receipt);
+        await this.network.sendDirect(replyPeerId, PRIVATE_MESSAGE_RECEIPT_TOPIC, receipt);
+        await this.persistPrivateMessageReceipts();
+    }
+    normalizeIncomingPrivateMessage(value) {
+        if (typeof value !== "object" || value === null) {
+            return null;
+        }
+        const record = value;
+        const createdAt = Number(record.created_at || 0);
+        const fromAgentId = String(record.from_agent_id || "").trim();
+        const toAgentId = String(record.to_agent_id || "").trim();
+        const conversationId = String(record.conversation_id || "").trim();
+        if (record.type !== PRIVATE_MESSAGE_TOPIC ||
+            !String(record.message_id || "").trim() ||
+            !conversationId ||
+            !fromAgentId ||
+            !toAgentId ||
+            !String(record.sender_public_key || "").trim() ||
+            !String(record.sender_encryption_public_key || "").trim() ||
+            !String(record.recipient_encryption_public_key || "").trim() ||
+            !String(record.ciphertext || "").trim() ||
+            !String(record.nonce || "").trim() ||
+            String(record.cipher_scheme || "") !== "nacl-box-v1" ||
+            !String(record.signature || "").trim() ||
+            !Number.isFinite(createdAt)) {
+            return null;
+        }
+        if (fromAgentId === toAgentId) {
+            return null;
+        }
+        if (conversationId !== this.buildPrivateConversationId(fromAgentId, toAgentId)) {
+            return null;
+        }
+        return {
+            type: PRIVATE_MESSAGE_TOPIC,
+            message_id: String(record.message_id).trim(),
+            conversation_id: conversationId,
+            from_agent_id: fromAgentId,
+            to_agent_id: toAgentId,
+            sender_public_key: String(record.sender_public_key).trim(),
+            sender_encryption_public_key: String(record.sender_encryption_public_key).trim(),
+            recipient_encryption_public_key: String(record.recipient_encryption_public_key).trim(),
+            cipher_scheme: "nacl-box-v1",
+            ciphertext: String(record.ciphertext).trim(),
+            nonce: String(record.nonce).trim(),
+            created_at: createdAt,
+            signature: String(record.signature).trim(),
+        };
+    }
+    normalizePrivateMessages(items) {
+        if (!Array.isArray(items)) {
+            return [];
+        }
+        const deduped = new Set();
+        return items
+            .map((item) => this.normalizeIncomingPrivateMessage(item))
+            .filter((item) => Boolean(item))
+            .sort((a, b) => a.created_at - b.created_at)
+            .filter((item) => {
+            if (deduped.has(item.message_id)) {
+                return false;
+            }
+            deduped.add(item.message_id);
+            return true;
+        })
+            .slice(-PRIVATE_MESSAGE_HISTORY_LIMIT);
+    }
+    normalizeIncomingPrivateMessageReceipt(value) {
+        if (typeof value !== "object" || value === null) {
+            return null;
+        }
+        const record = value;
+        const createdAt = Number(record.created_at || 0);
+        const status = String(record.status || "").trim();
+        if (record.type !== PRIVATE_MESSAGE_RECEIPT_TOPIC ||
+            !String(record.receipt_id || "").trim() ||
+            !String(record.message_id || "").trim() ||
+            !String(record.conversation_id || "").trim() ||
+            !String(record.from_agent_id || "").trim() ||
+            !String(record.to_agent_id || "").trim() ||
+            !String(record.sender_public_key || "").trim() ||
+            (status !== "received" && status !== "read") ||
+            !String(record.signature || "").trim() ||
+            !Number.isFinite(createdAt)) {
+            return null;
+        }
+        return {
+            type: PRIVATE_MESSAGE_RECEIPT_TOPIC,
+            receipt_id: String(record.receipt_id).trim(),
+            message_id: String(record.message_id).trim(),
+            conversation_id: String(record.conversation_id).trim(),
+            from_agent_id: String(record.from_agent_id).trim(),
+            to_agent_id: String(record.to_agent_id).trim(),
+            sender_public_key: String(record.sender_public_key).trim(),
+            status: status,
+            created_at: createdAt,
+            signature: String(record.signature).trim(),
+        };
+    }
+    normalizePrivateMessageReceipts(items) {
+        if (!Array.isArray(items)) {
+            return [];
+        }
+        const deduped = new Set();
+        return items
+            .map((item) => this.normalizeIncomingPrivateMessageReceipt(item))
+            .filter((item) => Boolean(item))
+            .sort((a, b) => a.created_at - b.created_at)
+            .filter((item) => {
+            if (deduped.has(item.receipt_id)) {
+                return false;
+            }
+            deduped.add(item.receipt_id);
+            return true;
+        })
+            .slice(-PRIVATE_MESSAGE_RECEIPT_HISTORY_LIMIT);
+    }
+    hasPrivateMessage(messageId) {
+        return this.privateMessages.some((item) => item.message_id === messageId);
+    }
+    ingestPrivateMessage(message) {
+        const existing = this.privateMessages.findIndex((item) => item.message_id === message.message_id);
+        if (existing >= 0) {
+            this.privateMessages[existing] = message;
+        }
+        else {
+            this.privateMessages.push(message);
+        }
+        this.privateMessages = this.normalizePrivateMessages(this.privateMessages);
+        const validIds = new Set(this.privateMessages.map((item) => item.message_id));
+        this.privateMessageBodyCache.delete(message.message_id);
+        for (const key of Array.from(this.privateMessageBodyCache.keys())) {
+            if (!validIds.has(key)) {
+                this.privateMessageBodyCache.delete(key);
+            }
+        }
+    }
+    ingestPrivateMessageReceipt(receipt) {
+        const existing = this.privateMessageReceipts.findIndex((item) => item.receipt_id === receipt.receipt_id);
+        if (existing >= 0) {
+            this.privateMessageReceipts[existing] = receipt;
+        }
+        else {
+            this.privateMessageReceipts.push(receipt);
+        }
+        this.privateMessageReceipts = this.normalizePrivateMessageReceipts(this.privateMessageReceipts);
+    }
     normalizeIncomingSocialMessage(value) {
         if (typeof value !== "object" || value === null) {
             return null;
@@ -2441,18 +3621,17 @@ function renderBootstrapScript(payload) {
     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>`;
 }
 async function main() {
     const app = (0, express_1.default)();
-    const port = Number(process.env.PORT || 4310);
+    const port = Number(process.env.PORT || silicaclaw_defaults_json_1.default.ports.local_console);
     const staticDir = resolveLocalConsoleStaticDir();
     const staticIndexFile = (0, path_1.resolve)(staticDir, "index.html");
     const node = new LocalNodeService();
-    await node.start();
     app.use((0, cors_1.default)({ origin: true }));
     app.use(express_1.default.json());
     app.get("/api/identity", (_req, res) => {
@@ -2471,6 +3650,36 @@ async function main() {
     app.get("/api/runtime/paths", (_req, res) => {
         sendOk(res, node.getRuntimePaths());
     });
+    app.get("/api/app/update-status", (_req, res) => {
+        sendOk(res, node.getAppUpdateStatus());
+    });
+    app.post("/api/app/update", asyncRoute(async (_req, res) => {
+        const status = node.getAppUpdateStatus();
+        if (!status.update_available || !status.latest_version) {
+            sendOk(res, {
+                started: false,
+                current_version: status.current_version,
+                latest_version: status.latest_version,
+                platform: status.platform,
+                reason: status.check_error || "already_current",
+            }, { message: "Already on the latest version" });
+            return;
+        }
+        sendOk(res, {
+            started: true,
+            current_version: status.current_version,
+            target_version: status.latest_version,
+            platform: status.platform,
+        }, { message: `Updating to ${status.latest_version}` });
+        setTimeout(() => {
+            try {
+                node.startAppUpdate();
+            }
+            catch {
+                // best effort after response has been sent
+            }
+        }, 150);
+    }));
     app.put("/api/profile", asyncRoute(async (req, res) => {
         const body = req.body;
         const tags = Array.isArray(body.tags)
@@ -2569,6 +3778,27 @@ async function main() {
         const agentId = String(req.query.agent_id ?? "").trim();
         sendOk(res, node.getSocialMessages(limit, { agent_id: agentId || null }));
     });
+    app.get("/api/private/state", (_req, res) => {
+        sendOk(res, node.getPrivateMessagingState());
+    });
+    app.get("/api/private/conversations", (_req, res) => {
+        sendOk(res, node.getPrivateConversations());
+    });
+    app.get("/api/private/messages", (req, res) => {
+        const conversationId = String(req.query.conversation_id ?? "").trim();
+        const limit = Number(req.query.limit ?? PRIVATE_MESSAGE_QUERY_LIMIT);
+        sendOk(res, node.getPrivateMessages(conversationId, limit));
+    });
+    app.post("/api/private/messages/send", asyncRoute(async (req, res) => {
+        const result = await node.sendPrivateMessage({
+            to_agent_id: String(req.body?.to_agent_id || ""),
+            recipient_encryption_public_key: String(req.body?.recipient_encryption_public_key || ""),
+            body: String(req.body?.body || ""),
+        });
+        sendOk(res, result, {
+            message: result.sent ? "Private message sent" : `Private message skipped: ${result.reason}`,
+        });
+    }));
     app.get("/api/openclaw/bridge", (_req, res) => {
         sendOk(res, node.getOpenClawBridgeStatus());
     });
@@ -2591,9 +3821,10 @@ async function main() {
             message: result.sent ? "OpenClaw bridge message published" : `OpenClaw bridge message skipped: ${result.reason}`,
         });
     }));
-    app.post("/api/openclaw/bridge/skill-install", asyncRoute(async (_req, res) => {
+    app.post("/api/openclaw/bridge/skill-install", 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",
             });
@@ -2622,7 +3853,7 @@ 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;
         }
         const lastSeenAt = state.presence[agentId] ?? 0;
@@ -2652,7 +3883,7 @@ async function main() {
             .map(([k, v]) => `<div class="card"><div class="label">${escapeHtml(String(k))}</div><div class="value">${escapeHtml(String(v))}</div></div>`)
             .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>
@@ -2686,7 +3917,7 @@ 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"}`,
@@ -2707,6 +3938,7 @@ async function main() {
         // eslint-disable-next-line no-console
         console.log(`SilicaClaw local-console running: http://localhost:${port}`);
     });
+    await node.start();
     process.on("SIGINT", async () => {
         await node.stop();
         process.exit(0);