@silicaclaw/cli 2026.3.20-3 → 2026.3.20-4

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## v1.0 beta - 2026-03-20
 
+### 2026.3.20-4
+
+- release build:
+  - prepared another fresh latest-channel package build without publishing
+  - regenerated the npm tarball through the verified release packing workflow
+
 ### 2026.3.20-3
 
 - release build:

package/INSTALL.md

@@ -211,9 +211,9 @@ npx clawhub publish openclaw-skills/silicaclaw-broadcast \
 npx clawhub publish openclaw-skills/silicaclaw-owner-push \
   --slug silicaclaw-owner-push \
   --name "SilicaClaw Owner Push" \
-  --version 2026.3.20-beta.1 \
+  --version 2026.3.20-beta.2 \
   --tags latest \
-  --changelog "Added clearer safety boundaries and bounded local workflow guidance for high-signal monitoring and owner push summaries."
+  --changelog "Added latest-only owner push behavior with timestamp cursor state so only the newest qualifying broadcast is pushed and older messages are skipped."
 ```
 
 ClawHub expects each skill version to be valid semver, so use the versions from each skill's `manifest.json` and `VERSION`, not the npm CLI version format.

package/README.md

@@ -283,9 +283,9 @@ npx clawhub publish openclaw-skills/silicaclaw-broadcast \
 npx clawhub publish openclaw-skills/silicaclaw-owner-push \
   --slug silicaclaw-owner-push \
   --name "SilicaClaw Owner Push" \
-  --version 2026.3.20-beta.1 \
+  --version 2026.3.20-beta.2 \
   --tags latest \
-  --changelog "Added clearer safety boundaries and bounded local workflow guidance for high-signal monitoring and owner push summaries."
+  --changelog "Added latest-only owner push behavior with timestamp cursor state so only the newest qualifying broadcast is pushed and older messages are skipped."
 ```
 
 ClawHub publishes the OpenClaw skill folders, not the npm CLI package.

package/VERSION

@@ -1 +1 @@
-v2026.3.20-3
+v2026.3.20-4

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

@@ -374,6 +374,23 @@ export declare class LocalNodeService {
         adapter_stats: any;
         adapter_transport_stats: any;
         adapter_discovery_stats: any;
+        runtime_diagnostics: {
+            memory_mib: {
+                rss: number;
+                heap_used: number;
+                heap_total: number;
+                external: number;
+            };
+            directory: {
+                profile_count: number;
+                presence_count: number;
+                index_key_count: number;
+            };
+            social: {
+                message_count: number;
+                observation_count: number;
+            };
+        };
         adapter_diagnostics_summary: {
             started: boolean;
             startup_error: string | null;
@@ -471,6 +488,22 @@ export declare class LocalNodeService {
         social_lookup_paths: string[];
         social_source_path: string | null;
     };
+    getAppUpdateStatus(): {
+        latest_version: string;
+        update_available: boolean;
+        current_version: string;
+        channel: string;
+        platform: NodeJS.Platform;
+        checked_at: number;
+        can_update: boolean;
+        check_error: string | null;
+    };
+    startAppUpdate(): {
+        started: boolean;
+        target_version: string;
+        platform: string;
+        reason?: string;
+    };
     getIntegrationSummary(): {
         connected: boolean;
         discoverable: boolean;
@@ -733,6 +766,7 @@ export declare class LocalNodeService {
     private clearNetworkReconnectTimer;
     private startNetworkAdapterWithRetry;
     private scheduleNetworkReconnect;
+    private pruneRemoteProfilesInMemory;
     private compactCacheInMemory;
     private publish;
     private persistCache;

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

@@ -37,6 +37,7 @@ const DEFAULT_BRIDGE_API_BASE = silicaclaw_defaults_json_1.default.bridge.api_ba
 const OPENCLAW_GATEWAY_PORT = silicaclaw_defaults_json_1.default.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;
@@ -101,6 +102,9 @@ 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]+/)
@@ -133,6 +137,9 @@ function compareVersionTokens(left, right) {
     }
     return 0;
 }
+function userNpmCacheDir() {
+    return (0, path_1.resolve)((0, os_1.homedir)(), ".silicaclaw", "npm-cache");
+}
 function resolveWorkspaceRoot(cwd = process.cwd()) {
     if ((0, fs_1.existsSync)((0, path_1.resolve)(cwd, "apps", "local-console", "package.json"))) {
         return cwd;
@@ -968,6 +975,7 @@ class LocalNodeService {
         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,
@@ -991,6 +999,23 @@ 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,
@@ -1102,6 +1127,87 @@ class LocalNodeService {
             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 scriptPath = (0, path_1.resolve)(this.workspaceRoot, "scripts", "silicaclaw-cli.mjs");
+        if (!(0, fs_1.existsSync)(scriptPath)) {
+            return {
+                started: false,
+                target_version: status.latest_version,
+                platform: process.platform,
+                reason: "missing_cli_script",
+            };
+        }
+        const child = (0, child_process_1.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);
@@ -2290,9 +2396,58 @@ class LocalNodeService {
         }, 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) {
@@ -2940,6 +3095,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)

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

@@ -27,6 +27,7 @@ if (!root) {
   throw new Error("Missing root element: app-root");
 }
 root.innerHTML = appTemplate;
+const APP_UPDATE_SESSION_KEY = 'silicaclaw_pending_updated_version';
 
       const i18n = createI18n(TRANSLATIONS);
       const DEFAULT_LOCALE = i18n.DEFAULT_LOCALE;
@@ -70,6 +71,9 @@ root.innerHTML = appTemplate;
         document.getElementById('sidebarToggleBtn').setAttribute('aria-label', t('labels.collapseSidebar'));
         document.querySelector('.sidebar-version').title = t('common.version');
         setText('.sidebar-version__label', t('common.version'));
+        document.getElementById('brandUpdateHint').textContent = t('labels.versionChecking');
+        document.getElementById('brandCheckUpdateBtn').textContent = t('actions.checkUpdate');
+        document.getElementById('brandUpdateBtn').textContent = t('actions.updateNow');
         document.getElementById('integrationStatusBar').textContent = t('social.barStatus', {
           connected: '-',
           mode: '-',
@@ -319,6 +323,175 @@ root.innerHTML = appTemplate;
         toast,
         writeUiCache,
       } = shell;
+      let appUpdatePollTimer = null;
+      let appUpdateCheckInFlight = false;
+
+      function setAppUpdateUi({
+        hint,
+        buttonVisible = false,
+        buttonDisabled = false,
+        buttonText = t('actions.updateNow'),
+        checkVisible = false,
+        checkDisabled = false,
+      }) {
+        const hintEl = document.getElementById('brandUpdateHint');
+        const buttonEl = document.getElementById('brandUpdateBtn');
+        const checkEl = document.getElementById('brandCheckUpdateBtn');
+        if (hintEl) {
+          hintEl.textContent = hint;
+          hintEl.classList.toggle('hidden', !hint);
+        }
+        if (checkEl) {
+          checkEl.textContent = t('actions.checkUpdate');
+          checkEl.classList.toggle('hidden', !checkVisible);
+          checkEl.disabled = checkDisabled;
+        }
+        if (buttonEl) {
+          buttonEl.textContent = buttonText;
+          buttonEl.classList.toggle('hidden', !buttonVisible);
+          buttonEl.disabled = buttonDisabled;
+        }
+      }
+
+      function platformUpdateHint(platform) {
+        if (platform === 'darwin') return t('labels.versionPlatformMac');
+        if (platform === 'linux') return t('labels.versionPlatformLinux');
+        return t('labels.versionPlatformOther');
+      }
+
+      async function refreshAppUpdateStatus({ silent = false } = {}) {
+        if (appUpdateCheckInFlight) return null;
+        appUpdateCheckInFlight = true;
+        try {
+          const result = await api('/api/app/update-status');
+          const status = result.data || {};
+          const currentVersion = String(status.current_version || '').trim();
+          const latestVersion = String(status.latest_version || '').trim();
+          const platformHint = platformUpdateHint(String(status.platform || ''));
+          if (currentVersion) {
+            document.getElementById('brandVersion').textContent = currentVersion.startsWith('v') ? currentVersion : `v${currentVersion}`;
+          }
+          if (status.update_available && status.latest_version) {
+            setAppUpdateUi({
+              hint: `${t('labels.versionUpdateReady', { version: `v${status.latest_version}` })} · ${platformHint}`,
+              buttonVisible: true,
+              buttonDisabled: false,
+              buttonText: t('actions.updateNowVersion', { version: latestVersion.startsWith('v') ? latestVersion : `v${latestVersion}` }),
+              checkVisible: true,
+              checkDisabled: false,
+            });
+          } else if (status.check_error) {
+            setAppUpdateUi({
+              hint: t('labels.versionCheckFailed'),
+              buttonVisible: false,
+              buttonDisabled: false,
+              buttonText: t('actions.updateNow'),
+              checkVisible: true,
+              checkDisabled: false,
+            });
+            if (!silent) {
+              setFeedback('networkFeedback', t('feedback.appUpdateCheckFailed'), 'warn');
+            }
+          } else {
+            setAppUpdateUi({
+              hint: `${t('labels.versionCurrent')} · ${platformHint}`,
+              buttonVisible: false,
+              buttonDisabled: false,
+              buttonText: t('actions.updateNow'),
+              checkVisible: true,
+              checkDisabled: false,
+            });
+          }
+          return status;
+        } catch (_error) {
+          setAppUpdateUi({
+            hint: t('labels.versionCheckFailed'),
+            buttonVisible: false,
+            buttonDisabled: false,
+            buttonText: t('actions.updateNow'),
+            checkVisible: true,
+            checkDisabled: false,
+          });
+          if (!silent) {
+            setFeedback('networkFeedback', t('feedback.appUpdateCheckFailed'), 'warn');
+          }
+          return null;
+        } finally {
+          appUpdateCheckInFlight = false;
+        }
+      }
+
+      function startAppUpdatePolling(targetVersion) {
+        if (appUpdatePollTimer) {
+          window.clearInterval(appUpdatePollTimer);
+        }
+        let attempts = 0;
+        appUpdatePollTimer = window.setInterval(async () => {
+          attempts += 1;
+          const status = await refreshAppUpdateStatus({ silent: true });
+          if (status && !status.update_available && String(status.current_version || '') === String(targetVersion || '')) {
+            window.clearInterval(appUpdatePollTimer);
+            appUpdatePollTimer = null;
+            if (targetVersion) {
+              window.sessionStorage.setItem(APP_UPDATE_SESSION_KEY, String(targetVersion));
+            }
+            window.location.reload();
+            return;
+          }
+          if (attempts >= 24) {
+            window.clearInterval(appUpdatePollTimer);
+            appUpdatePollTimer = null;
+            setAppUpdateUi({
+              hint: t('labels.versionCurrent'),
+              buttonVisible: false,
+              buttonDisabled: false,
+              buttonText: t('actions.updateNow'),
+              checkVisible: true,
+              checkDisabled: false,
+            });
+          }
+        }, 5000);
+      }
+
+      async function triggerAppUpdate() {
+        const buttonEl = document.getElementById('brandUpdateBtn');
+        setAppUpdateUi({
+          hint: t('labels.versionUpdating'),
+          buttonVisible: true,
+          buttonDisabled: true,
+          buttonText: t('labels.versionUpdating'),
+          checkVisible: true,
+          checkDisabled: true,
+        });
+        try {
+          const result = await api('/api/app/update', { method: 'POST' });
+          const data = result.data || {};
+          if (!data.started) {
+            setAppUpdateUi({
+              hint: t('labels.versionCurrent'),
+              buttonVisible: false,
+              buttonDisabled: false,
+              buttonText: t('actions.updateNow'),
+              checkVisible: true,
+              checkDisabled: false,
+            });
+            toast(t('feedback.appUpdateLatest'));
+            return;
+          }
+          toast(t('feedback.appUpdateStarted'));
+          startAppUpdatePolling(String(data.target_version || ''));
+        } catch (error) {
+          setAppUpdateUi({
+            hint: t('labels.versionCheckFailed'),
+            buttonVisible: true,
+            buttonDisabled: false,
+            buttonText: t('actions.updateNow'),
+            checkVisible: true,
+            checkDisabled: false,
+          });
+          setFeedback('networkFeedback', error instanceof Error ? error.message : t('feedback.appUpdateFailed'), 'error');
+        }
+      }
       setLocale(currentLocale);
       applyStaticTranslations();
 
@@ -427,6 +600,23 @@ root.innerHTML = appTemplate;
         document.getElementById('publicDiscoveryHint')?.classList.toggle('hidden', tab !== 'overview');
         if (tab === 'profile' && !profileController.isDirty() && !profileController.isSaving()) {
           refreshProfile().catch(() => {});
+        } else if (tab === 'overview') {
+          refreshOverview().catch(() => {});
+          refreshMessages().catch(() => {});
+        } else if (tab === 'agent') {
+          refreshOverview().catch(() => {});
+        } else if (tab === 'chat') {
+          refreshMessages().catch(() => {});
+        } else if (tab === 'skills') {
+          refreshSkills().catch(() => {});
+        } else if (tab === 'network') {
+          refreshNetwork().catch(() => {});
+          refreshPeers().catch(() => {});
+          refreshDiscovery().catch(() => {});
+          refreshLogs().catch(() => {});
+        } else if (tab === 'social') {
+          refreshSocial().catch(() => {});
+          refreshMessages().catch(() => {});
         }
       }
 
@@ -453,6 +643,43 @@ root.innerHTML = appTemplate;
       const renderLogs = socialController.renderLogs;
       const refreshLogs = socialController.refreshLogs;
       const refreshSkills = socialController.refreshSkills;
+      let autoRefreshInFlight = false;
+
+      async function refreshActiveView() {
+        const tasks = [refreshPublicProfilePreview()];
+        if (activeTab === 'overview') {
+          tasks.push(refreshOverview(), refreshMessages(), refreshSocial());
+        } else if (activeTab === 'agent') {
+          tasks.push(refreshOverview());
+        } else if (activeTab === 'chat') {
+          tasks.push(refreshMessages());
+        } else if (activeTab === 'skills') {
+          tasks.push(refreshSkills());
+        } else if (activeTab === 'network') {
+          tasks.push(refreshNetwork(), refreshPeers(), refreshDiscovery(), refreshLogs());
+        } else if (activeTab === 'social') {
+          tasks.push(refreshSocial(), refreshMessages());
+        } else if (activeTab === 'profile' && !profileController.isDirty() && !profileController.isSaving()) {
+          tasks.push(refreshProfile());
+        }
+        const results = await Promise.allSettled(tasks);
+        const firstError = results.find((result) => result.status === 'rejected');
+        if (firstError && firstError.status === 'rejected') {
+          setFeedback('networkFeedback', firstError.reason instanceof Error ? firstError.reason.message : t('common.unknownError'), 'error');
+        }
+      }
+
+      async function refreshAuto() {
+        if (document.hidden || autoRefreshInFlight) {
+          return;
+        }
+        autoRefreshInFlight = true;
+        try {
+          await refreshActiveView();
+        } finally {
+          autoRefreshInFlight = false;
+        }
+      }
 
       async function refreshAll() {
         const tasks = [refreshOverview(), refreshNetwork(), refreshSocial(), refreshSkills(), refreshPublicProfilePreview(), refreshMessages()];
@@ -511,6 +738,27 @@ root.innerHTML = appTemplate;
 
       applyTheme(localStorage.getItem('silicaclaw_theme_mode') || 'dark');
       hydrateCachedShell();
+      document.getElementById('brandUpdateBtn').addEventListener('click', () => {
+        triggerAppUpdate().catch(() => {});
+      });
+      document.getElementById('brandCheckUpdateBtn').addEventListener('click', () => {
+        refreshAppUpdateStatus().catch(() => {});
+      });
       refreshAll();
+      refreshAppUpdateStatus({ silent: true }).catch(() => {});
+      const updatedVersion = window.sessionStorage.getItem(APP_UPDATE_SESSION_KEY);
+      if (updatedVersion) {
+        window.sessionStorage.removeItem(APP_UPDATE_SESSION_KEY);
+        toast(t('feedback.appUpdatedTo', { version: updatedVersion.startsWith('v') ? updatedVersion : `v${updatedVersion}` }));
+      }
       exportSocialTemplate().catch(() => {});
-      setInterval(refreshAll, 4000);
+      document.addEventListener('visibilitychange', () => {
+        if (!document.hidden) {
+          refreshAuto().catch(() => {});
+          refreshAppUpdateStatus({ silent: true }).catch(() => {});
+        }
+      });
+      setInterval(refreshAuto, 4000);
+      setInterval(() => {
+        refreshAppUpdateStatus({ silent: true }).catch(() => {});
+      }, 15 * 60 * 1000);