@silicaclaw/cli 2026.3.20-3 → 2026.3.20-5

package/apps/local-console/public/app/translations.js

@@ -56,6 +56,9 @@ export const TRANSLATIONS = {
           },
           actions: {
             broadcastNow: 'Announce Agent Now',
+            checkUpdate: 'Check',
+            updateNow: 'Update',
+            updateNowVersion: 'Update {version}',
             editProfile: 'Edit Profile',
             openNetwork: 'Network',
             openAgent: 'Directory',
@@ -135,6 +138,17 @@ export const TRANSLATIONS = {
             publishStatus: 'Publish Status',
             publicProfilePreview: 'Public Profile Preview',
             goPublic: 'Go public',
+            versionChecking: 'Checking for updates...',
+            versionCurrent: 'Up to date',
+            versionUpdateReady: 'Update {version} ready',
+            versionUpdating: 'Updating...',
+            versionCheckFailed: 'Could not check updates',
+            versionPlatformMac: 'macOS service will restart automatically',
+            versionPlatformLinux: 'Linux service will restart automatically',
+            versionPlatformOther: 'Local service will refresh after the update',
+            relayQueuesHealthy: 'Relay queues are healthy.',
+            relayQueuesWatch: 'Relay queues need attention.',
+            relayQueuesHigh: 'Relay queues are building up.',
             networkEyebrow: 'Network',
             connectionSummary: 'Connection',
             quickActions: 'Broadcast',
@@ -205,6 +219,9 @@ export const TRANSLATIONS = {
             duplicateWindowSeconds: 'Duplicate Window (seconds)',
             blockedAgentIds: 'Blocked agent IDs (agent_id, comma separated)',
             blockedTerms: 'Blocked Terms (comma separated)',
+            queueHealthy: 'Healthy',
+            queueWatch: 'Watch',
+            queueHigh: 'High',
           },
           hints: {
             publicDiscoverySwitch: 'Use Profile -> Public Enabled as the single public visibility switch.',
@@ -533,6 +550,11 @@ export const TRANSLATIONS = {
             templateCopied: 'Template copied to clipboard.',
             preparingDownload: 'Preparing download...',
             runtimeUpdated: 'Mode updated.',
+            appUpdateStarted: 'Update started. SilicaClaw will refresh shortly.',
+            appUpdatedTo: 'Updated to {version}.',
+            appUpdateLatest: 'Already on the latest version.',
+            appUpdateCheckFailed: 'Could not check for updates.',
+            appUpdateFailed: 'Could not start the update.',
             copyPreviewFailed: 'Copy preview failed',
             logsRefreshed: 'Logs refreshed',
             crossPreviewEnabled: 'Cross-network preview enabled',
@@ -642,6 +664,9 @@ export const TRANSLATIONS = {
           },
           actions: {
             broadcastNow: '立即公告代理',
+            checkUpdate: '检查',
+            updateNow: '立即更新',
+            updateNowVersion: '更新到 {version}',
             editProfile: '编辑资料',
             openNetwork: '打开网络页',
             openAgent: '打开代理目录',
@@ -708,6 +733,17 @@ export const TRANSLATIONS = {
             discoveredAgents: '公开代理目录',
             onlyShowOnline: '只显示在线',
             nodeSnapshot: '本机代理快照',
+            versionChecking: '正在检查更新...',
+            versionCurrent: '已是最新版本',
+            versionUpdateReady: '可更新到 {version}',
+            versionUpdating: '正在更新...',
+            versionCheckFailed: '暂时无法检查更新',
+            versionPlatformMac: 'macOS 服务会自动重启',
+            versionPlatformLinux: 'Linux 服务会自动重启',
+            versionPlatformOther: '更新后本地服务会自动刷新',
+            relayQueuesHealthy: 'Relay 队列正常。',
+            relayQueuesWatch: 'Relay 队列需要关注。',
+            relayQueuesHigh: 'Relay 队列正在堆积。',
             profileEyebrow: '资料',
             publicProfile: '公开资料',
             publicProfileEditor: '公开资料编辑器',
@@ -791,6 +827,9 @@ export const TRANSLATIONS = {
             duplicateWindowSeconds: '重复消息窗口（秒）',
             blockedAgentIds: '已屏蔽代理 ID（agent_id，逗号分隔）',
             blockedTerms: '已屏蔽词（逗号分隔）',
+            queueHealthy: '正常',
+            queueWatch: '注意',
+            queueHigh: '偏高',
           },
           hints: {
             publicDiscoverySwitch: '使用资料 -> Public Enabled 作为唯一的公开可见性开关。',
@@ -1119,6 +1158,11 @@ export const TRANSLATIONS = {
             templateCopied: '模板已复制到剪贴板。',
             preparingDownload: '正在准备下载...',
             runtimeUpdated: '模式已更新。',
+            appUpdateStarted: '更新已开始，SilicaClaw 很快会自动刷新。',
+            appUpdatedTo: '已更新到 {version}。',
+            appUpdateLatest: '当前已经是最新版本。',
+            appUpdateCheckFailed: '暂时无法检查更新。',
+            appUpdateFailed: '无法开始更新。',
             copyPreviewFailed: '复制预览失败',
             logsRefreshed: '日志已刷新',
             crossPreviewEnabled: '跨网络预览已启用',

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

@@ -1,6 +1,6 @@
 import express, { NextFunction, Request, Response } from "express";
 import cors from "cors";
-import { execFile, spawnSync } from "child_process";
+import { execFile, spawn, spawnSync } from "child_process";
 import { resolve } from "path";
 import { accessSync, constants, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "fs";
 import { createHash } from "crypto";
@@ -17,7 +17,6 @@ import {
   PublicProfileSummary,
   SignedProfileRecord,
   buildPublicProfileSummary,
-  buildIndexRecords,
   cleanupExpiredPresence,
   createDefaultProfileInput,
   createEmptyDirectoryState,
@@ -90,6 +89,7 @@ const DEFAULT_BRIDGE_API_BASE = defaults.bridge.api_base;
 const OPENCLAW_GATEWAY_PORT = defaults.ports.openclaw_gateway;
 const OPENCLAW_GATEWAY_URL = `http://${OPENCLAW_GATEWAY_HOST}:${OPENCLAW_GATEWAY_PORT}/`;
 const NETWORK_PEER_REMOVE_AFTER_MS = Number(process.env.NETWORK_PEER_REMOVE_AFTER_MS || 180_000);
+const 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;
@@ -115,6 +115,12 @@ const SOCIAL_MESSAGE_MAX_AGE_MS = Number(process.env.SOCIAL_MESSAGE_MAX_AGE_MS |
 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 || ""))
 );
@@ -157,6 +163,10 @@ function normalizeVersionText(value: unknown): string {
   return text.startsWith("v") ? text.slice(1) : text;
 }
 
+function formatBytesToMiB(value: number): number {
+  return Math.round((value / (1024 * 1024)) * 10) / 10;
+}
+
 function tokenizeVersion(value: unknown): Array<number | string> {
   return normalizeVersionText(value)
     .split(/[^0-9A-Za-z]+/)
@@ -186,6 +196,10 @@ function compareVersionTokens(left: unknown, right: unknown): number {
   return 0;
 }
 
+function userNpmCacheDir(): string {
+  return resolve(homedir(), ".silicaclaw", "npm-cache");
+}
+
 function resolveWorkspaceRoot(cwd = process.cwd()): string {
   if (existsSync(resolve(cwd, "apps", "local-console", "package.json"))) {
     return cwd;
@@ -913,6 +927,10 @@ export class LocalNodeService {
   private broadcastCount = 0;
   private lastMessageAt = 0;
   private lastBroadcastAt = 0;
+  private lastProfileBroadcastAt = 0;
+  private lastProfileBroadcastSignature = "";
+  private lastReplayBroadcastAt = 0;
+  private lastReplayBroadcastSignature = "";
   private lastBroadcastErrorAt = 0;
   private lastBroadcastError: string | null = null;
   private broadcastFailureCount = 0;
@@ -1201,6 +1219,7 @@ export class LocalNodeService {
     const relayCapable = this.adapterMode === "webrtc-preview" || this.adapterMode === "relay-preview";
     const peers: Array<{ status?: string }> = diagnostics?.peers?.items ?? [];
     const online = peers.filter((peer: { status?: string }) => peer.status === "online").length;
+    const memory = process.memoryUsage();
 
     return {
       adapter: this.adapterMode,
@@ -1225,6 +1244,23 @@ export class LocalNodeService {
       adapter_stats: diagnostics?.stats ?? null,
       adapter_transport_stats: diagnostics?.transport_stats ?? null,
       adapter_discovery_stats: diagnostics?.discovery_stats ?? null,
+      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
         ? {
             started: this.networkStarted,
@@ -1341,6 +1377,88 @@ export class LocalNodeService {
     };
   }
 
+  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 as string | null,
+    };
+    try {
+      const result = 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() || "{}") as { latest?: string };
+      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(): { started: boolean; target_version: string; platform: string; reason?: string } {
+    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 scriptPath = resolve(this.workspaceRoot, "scripts", "silicaclaw-cli.mjs");
+    if (!existsSync(scriptPath)) {
+      return {
+        started: false,
+        target_version: status.latest_version,
+        platform: process.platform,
+        reason: "missing_cli_script",
+      };
+    }
+    const child = spawn(process.execPath, [scriptPath, "update"], {
+      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);
@@ -2171,15 +2289,14 @@ export class LocalNodeService {
       profile: this.profile,
     };
     const presenceRecord = signPresence(this.identity, Date.now());
-    const indexRecords = buildIndexRecords(this.profile);
-    const replayMessages = this.getReplayableSelfSocialMessages();
+    const shouldPublishProfile = this.shouldPublishProfileRecord(profileRecord, reason, presenceRecord.timestamp);
+    const replayMessages = this.getReplayableSelfSocialMessages(reason);
 
     try {
-      await this.publish("profile", profileRecord);
-      await this.publish("presence", presenceRecord);
-      for (const record of indexRecords) {
-        await this.publish("index", record);
+      if (shouldPublishProfile) {
+        await this.publish("profile", profileRecord);
       }
+      await this.publish("presence", presenceRecord);
       for (const message of replayMessages) {
         await this.publish(SOCIAL_MESSAGE_TOPIC, message);
       }
@@ -2202,19 +2319,37 @@ export class LocalNodeService {
 
     this.directory = ingestProfileRecord(this.directory, profileRecord);
     this.directory = ingestPresenceRecord(this.directory, presenceRecord);
-    for (const record of indexRecords) {
-      this.directory = ingestIndexRecord(this.directory, record);
-    }
     this.compactCacheInMemory();
     await this.persistCache();
 
     await this.log(
       "info",
-      `Broadcast sent (${indexRecords.length} index refs, replayed_messages=${replayMessages.length}, reason=${reason})`
+      `Broadcast sent (${shouldPublishProfile ? "profile + " : ""}presence, replayed_messages=${replayMessages.length}, reason=${reason})`
     );
     return { sent: true, reason };
   }
 
+  private shouldPublishProfileRecord(
+    profileRecord: SignedProfileRecord,
+    reason: string,
+    now = Date.now()
+  ): boolean {
+    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;
+  }
+
   private async maybeRecoverFromBroadcastFailure(reason: string, errorMessage: string): Promise<void> {
     const recoveryThreshold = 3;
     const recoveryCooldownMs = 60_000;
@@ -2670,9 +2805,66 @@ export class LocalNodeService {
     this.networkReconnectDelayMs = Math.min(30_000, Math.max(5_000, Math.floor(delayMs * 1.5)));
   }
 
+  private pruneRemoteProfilesInMemory(now = Date.now()): number {
+    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) =>
+      isAgentOnline(this.directory.presence[profile.agent_id], now, PRESENCE_TTL_MS)
+    );
+    const offlineRemoteProfiles = remoteProfiles
+      .filter((profile) => !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 = 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 = 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 = rebuildIndexForProfile(next, profile);
+      next.index = rebuilt.index;
+    }
+
+    this.directory = dedupeIndex(next);
+    return removedIds.length;
+  }
+
   private compactCacheInMemory(): number {
     const cleaned = cleanupExpiredPresence(this.directory, Date.now(), PRESENCE_TTL_MS);
     this.directory = dedupeIndex(cleaned.state);
+    this.pruneRemoteProfilesInMemory();
     return cleaned.removed;
   }
 
@@ -3047,18 +3239,32 @@ export class LocalNodeService {
     return this.socialMessages.some((item) => item.message_id === messageId);
   }
 
-  private getReplayableSelfSocialMessages(now = Date.now()): SocialMessageRecord[] {
+  private getReplayableSelfSocialMessages(reason = "manual", now = Date.now()): SocialMessageRecord[] {
     const maxCount = Math.max(0, SOCIAL_MESSAGE_REPLAY_MAX_PER_BROADCAST);
     if (!this.identity || maxCount === 0) {
       return [];
     }
-    return this.socialMessages
+    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;
   }
 
   private hasRecentDuplicateMessage(agentId: string, body: string, topic: string, now = Date.now()): boolean {
@@ -3411,6 +3617,48 @@ export async function main() {
     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) => {

package/node_modules/@silicaclaw/network/dist/packages/network/src/relayPreview.d.ts

@@ -22,6 +22,10 @@ type RelayPeer = {
     last_seen_at: number;
     messages_seen: number;
     reconnect_attempts: number;
+    meta?: {
+        signal_queue_size?: number;
+        relay_queue_size?: number;
+    };
 };
 type RelayDiagnostics = {
     adapter: "relay-preview";

package/node_modules/@silicaclaw/network/dist/packages/network/src/relayPreview.js

@@ -109,7 +109,6 @@ class RelayPreviewAdapter {
         try {
             await this.joinRoom("start");
             this.started = true;
-            await this.refreshPeers();
             await this.pollOnce();
             this.scheduleNextPoll(this.pollIntervalMs);
             this.recordDiscovery("signaling_connected", { endpoint: this.activeEndpoint });
@@ -258,8 +257,10 @@ class RelayPreviewAdapter {
         const payload = await this.get(`/peers?room=${encodeURIComponent(this.room)}`);
         this.lastPeerRefreshAt = Date.now();
         this.stats.peers_refresh_succeeded += 1;
-        const peerIds = Array.isArray(payload?.peers) ? payload.peers : [];
-        this.updatePeersFromList(peerIds);
+        const peerItems = Array.isArray(payload?.peer_details) && payload.peer_details.length
+            ? payload.peer_details
+            : Array.isArray(payload?.peers) ? payload.peers : [];
+        this.updatePeersFromList(peerItems);
     }
     onEnvelope(envelope) {
         this.stats.received_total += 1;
@@ -340,9 +341,13 @@ class RelayPreviewAdapter {
     }
     async joinRoom(reason) {
         this.stats.join_attempted += 1;
-        await this.post("/join", { room: this.room, peer_id: this.peerId });
+        const payload = await this.post("/join", { room: this.room, peer_id: this.peerId });
         this.lastJoinAt = Date.now();
         this.stats.join_succeeded += 1;
+        if (Array.isArray(payload?.peers)) {
+            this.updatePeersFromList(payload.peers);
+            this.lastPeerRefreshAt = this.lastJoinAt;
+        }
         this.recordDiscovery("join_ok", { endpoint: this.activeEndpoint, detail: reason });
     }
     async maybeRefreshJoin(reason) {
@@ -407,13 +412,38 @@ class RelayPreviewAdapter {
         throw new Error(errors.join(" | "));
     }
     updatePeersFromList(values) {
-        const peerIds = values.map((value) => String(value || "").trim()).filter(Boolean);
+        const parsedPeers = [];
+        for (const value of values) {
+            if (typeof value === "string") {
+                const peerId = String(value || "").trim();
+                if (peerId) {
+                    parsedPeers.push({ peer_id: peerId });
+                }
+                continue;
+            }
+            if (value && typeof value === "object") {
+                const raw = value;
+                const peerId = String(raw.peer_id || "").trim();
+                if (!peerId) {
+                    continue;
+                }
+                parsedPeers.push({
+                    peer_id: peerId,
+                    meta: {
+                        signal_queue_size: Number(raw.signal_queue_size ?? 0),
+                        relay_queue_size: Number(raw.relay_queue_size ?? 0),
+                    },
+                });
+            }
+        }
+        const peerIds = parsedPeers.map((peer) => peer.peer_id);
         if (!peerIds.includes(this.peerId)) {
             void this.joinRoom("self_missing_from_peers").catch(() => { });
         }
         const now = Date.now();
         const next = new Map();
-        for (const peerId of peerIds) {
+        for (const peerInfo of parsedPeers) {
+            const peerId = peerInfo.peer_id;
             if (peerId === this.peerId)
                 continue;
             const existing = this.peers.get(peerId);
@@ -427,6 +457,7 @@ class RelayPreviewAdapter {
                 last_seen_at: now,
                 messages_seen: existing?.messages_seen ?? 0,
                 reconnect_attempts: existing?.reconnect_attempts ?? 0,
+                meta: peerInfo.meta || existing?.meta,
             });
         }
         for (const peerId of this.peers.keys()) {

package/node_modules/@silicaclaw/network/src/relayPreview.ts

@@ -34,6 +34,10 @@ type RelayPeer = {
   last_seen_at: number;
   messages_seen: number;
   reconnect_attempts: number;
+  meta?: {
+    signal_queue_size?: number;
+    relay_queue_size?: number;
+  };
 };
 
 type RelayDiagnostics = {
@@ -227,7 +231,6 @@ export class RelayPreviewAdapter implements NetworkAdapter {
     try {
       await this.joinRoom("start");
       this.started = true;
-      await this.refreshPeers();
       await this.pollOnce();
       this.scheduleNextPoll(this.pollIntervalMs);
       this.recordDiscovery("signaling_connected", { endpoint: this.activeEndpoint });
@@ -375,8 +378,10 @@ export class RelayPreviewAdapter implements NetworkAdapter {
     const payload = await this.get(`/peers?room=${encodeURIComponent(this.room)}`);
     this.lastPeerRefreshAt = Date.now();
     this.stats.peers_refresh_succeeded += 1;
-    const peerIds = Array.isArray(payload?.peers) ? payload.peers : [];
-    this.updatePeersFromList(peerIds);
+    const peerItems = Array.isArray(payload?.peer_details) && payload.peer_details.length
+      ? payload.peer_details
+      : Array.isArray(payload?.peers) ? payload.peers : [];
+    this.updatePeersFromList(peerItems);
   }
 
   private onEnvelope(envelope: unknown): void {
@@ -457,9 +462,13 @@ export class RelayPreviewAdapter implements NetworkAdapter {
 
   private async joinRoom(reason: string): Promise<void> {
     this.stats.join_attempted += 1;
-    await this.post("/join", { room: this.room, peer_id: this.peerId });
+    const payload = await this.post("/join", { room: this.room, peer_id: this.peerId });
     this.lastJoinAt = Date.now();
     this.stats.join_succeeded += 1;
+    if (Array.isArray(payload?.peers)) {
+      this.updatePeersFromList(payload.peers);
+      this.lastPeerRefreshAt = this.lastJoinAt;
+    }
     this.recordDiscovery("join_ok", { endpoint: this.activeEndpoint, detail: reason });
   }
 
@@ -528,13 +537,38 @@ export class RelayPreviewAdapter implements NetworkAdapter {
   }
 
   private updatePeersFromList(values: unknown[]): void {
-    const peerIds = values.map((value) => String(value || "").trim()).filter(Boolean);
+    const parsedPeers: Array<{ peer_id: string; meta?: RelayPeer["meta"] }> = [];
+    for (const value of values) {
+      if (typeof value === "string") {
+        const peerId = String(value || "").trim();
+        if (peerId) {
+          parsedPeers.push({ peer_id: peerId });
+        }
+        continue;
+      }
+      if (value && typeof value === "object") {
+        const raw = value as Record<string, unknown>;
+        const peerId = String(raw.peer_id || "").trim();
+        if (!peerId) {
+          continue;
+        }
+        parsedPeers.push({
+          peer_id: peerId,
+          meta: {
+            signal_queue_size: Number(raw.signal_queue_size ?? 0),
+            relay_queue_size: Number(raw.relay_queue_size ?? 0),
+          },
+        });
+      }
+    }
+    const peerIds = parsedPeers.map((peer) => peer.peer_id);
     if (!peerIds.includes(this.peerId)) {
       void this.joinRoom("self_missing_from_peers").catch(() => {});
     }
     const now = Date.now();
     const next = new Map<string, RelayPeer>();
-    for (const peerId of peerIds) {
+    for (const peerInfo of parsedPeers) {
+      const peerId = peerInfo.peer_id;
       if (peerId === this.peerId) continue;
       const existing = this.peers.get(peerId);
       if (!existing) {
@@ -547,6 +581,7 @@ export class RelayPreviewAdapter implements NetworkAdapter {
         last_seen_at: now,
         messages_seen: existing?.messages_seen ?? 0,
         reconnect_attempts: existing?.reconnect_attempts ?? 0,
+        meta: peerInfo.meta || existing?.meta,
       });
     }
     for (const peerId of this.peers.keys()) {