ec-web 0.0.3 → 0.0.5

package/dist/server.js

@@ -66,10 +66,26 @@ const ECWEB_VERSION = readEcwebVersion();
 const MIME = {
     '.html': 'text/html; charset=utf-8',
     '.js': 'text/javascript; charset=utf-8',
+    '.mjs': 'text/javascript; charset=utf-8',
     '.css': 'text/css; charset=utf-8',
     '.json': 'application/json; charset=utf-8',
+    '.webmanifest': 'application/manifest+json; charset=utf-8',
     '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.wasm': 'application/wasm',
 };
+const HTML_CACHE_CONTROL = 'no-cache';
+const STATIC_CACHE_CONTROL = 'public, max-age=0, must-revalidate';
 function tokenStorePath() {
     const dir = resolvePaths().instanceDir;
     const current = path.join(dir, 'ecweb-tokens.json');
@@ -141,7 +157,32 @@ function injectBaseHref(html, prefix) {
         return html.replace(/<base\b[^>]*>/i, tag);
     return html.replace(/<head[^>]*>/i, (m) => `${m}\n  ${tag}`);
 }
-function serveStatic(req, res) {
+function createEtag(content) {
+    return `"${crypto.createHash('sha256').update(content).digest('hex')}"`;
+}
+function matchesIfNoneMatch(req, etag) {
+    const header = req.headers['if-none-match'];
+    const value = Array.isArray(header) ? header.join(',') : header;
+    if (!value)
+        return false;
+    // GET uses weak comparison, so a client may send the validator with W/.
+    return value.split(',').some((candidate) => {
+        const normalized = candidate.trim().replace(/^W\//, '');
+        return normalized === '*' || normalized === etag;
+    });
+}
+function respondWithValidator(req, res, body, contentType, cacheControl, extraHeaders = {}) {
+    const etag = createEtag(body);
+    const headers = { 'Content-Type': contentType, 'Cache-Control': cacheControl, ETag: etag, ...extraHeaders };
+    if (matchesIfNoneMatch(req, etag)) {
+        res.writeHead(304, headers);
+        res.end();
+        return;
+    }
+    res.writeHead(200, headers);
+    res.end(body);
+}
+export function serveStatic(req, res) {
     let urlPath = (req.url || '/').split('?')[0];
     if (urlPath === '/')
         urlPath = '/index.html';
@@ -161,12 +202,13 @@ function serveStatic(req, res) {
         if (ext === '.html') {
             const prefix = forwardedPrefix(req);
             const html = injectBaseHref(data.toString('utf-8'), prefix);
-            res.writeHead(200, { 'Content-Type': MIME[ext] });
-            res.end(html);
+            // The proxy prefix changes the representation, so shared caches must key on it.
+            respondWithValidator(req, res, html, MIME[ext], HTML_CACHE_CONTROL, { Vary: 'X-Forwarded-Prefix' });
             return;
         }
-        res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream' });
-        res.end(data);
+        // Static files have stable ETags, including fonts, images, manifests, and vendored libraries.
+        // Their fixed URLs must revalidate so deployments never leave clients on an old asset.
+        respondWithValidator(req, res, data, MIME[ext] || 'application/octet-stream', STATIC_CACHE_CONTROL);
     });
 }
 // ── Helpers ──
@@ -446,6 +488,7 @@ function handleConnection(ws, req, log) {
     const ip = clientIp(req);
     let unsubscribe = null;
     let currentView = null;
+    let subscriptionGeneration = 0;
     log(`◆ WS 连接 from ${ip}`);
     const send = (obj) => {
         if (ws.readyState === ws.OPEN)
@@ -455,6 +498,7 @@ function handleConnection(ws, req, log) {
             catch { }
     };
     const switchSubscription = async (view, params) => {
+        const generation = ++subscriptionGeneration;
         if (unsubscribe) {
             unsubscribe();
             unsubscribe = null;
@@ -468,16 +512,28 @@ function handleConnection(ws, req, log) {
         const sourceParams = { ...params, __menuAuth: daemonOwnerMenuAuth() };
         // System 视图：把 ECWeb 自身版本合并进快照（前端版本卡用）
         const decorate = (data) => (view === 'system' && data ? { ...data, ecwebVersion: ECWEB_VERSION } : data);
+        let initialSnapshot;
         try {
-            send({ type: 'snapshot', view, data: decorate(await source.snapshot(sourceParams)) });
+            initialSnapshot = await source.snapshot(sourceParams);
+            if (generation !== subscriptionGeneration)
+                return;
+            send({ type: 'snapshot', view, data: decorate(initialSnapshot) });
         }
         catch (e) {
+            if (generation !== subscriptionGeneration)
+                return;
             send({ type: 'error', message: `snapshot failed: ${e?.message || e}` });
         }
-        unsubscribe = source.subscribe(sourceParams, (data) => {
-            if (currentView === view)
+        const nextUnsubscribe = source.subscribe(sourceParams, (data) => {
+            if (generation === subscriptionGeneration && currentView === view) {
                 send({ type: 'delta', view, data: decorate(data) });
+            }
         });
+        if (generation !== subscriptionGeneration) {
+            nextUnsubscribe();
+            return;
+        }
+        unsubscribe = nextUnsubscribe;
     };
     ws.on('message', async (raw) => {
         let msg;
@@ -563,10 +619,15 @@ function handleConnection(ws, req, log) {
         ws.ping();
     }, 25000);
     ws.on('pong', () => { alive = true; });
-    ws.on('close', () => { clearInterval(heartbeat); if (unsubscribe) {
-        unsubscribe();
-        unsubscribe = null;
-    } log(`◇ WS 断开 from ${ip}`); });
+    ws.on('close', () => {
+        subscriptionGeneration += 1;
+        clearInterval(heartbeat);
+        if (unsubscribe) {
+            unsubscribe();
+            unsubscribe = null;
+        }
+        log(`◇ WS 断开 from ${ip}`);
+    });
     ws.on('error', () => { });
 }
 // ── Port binding ──

package/dist/sources/monitor.js

@@ -8,11 +8,44 @@
  *   - fine   : 2s  桶 × 60  ≈ 近 2 分钟
  *   - mid    : 10s 桶 × 60  ≈ 近 10 分钟
  *   - coarse : 60s 桶 × 60  ≈ 近 1 小时
- * 每个桶内对 CPU/内存做均值聚合，避免长周期下点数爆炸。
+ * 每个桶内对 CPU/内存做均值聚合，关联进程先按类型和名称合并，
+ * 避免长周期下点数爆炸，也不让 PID 变化拆散同一条曲线。
  */
 import fs from 'node:fs';
 import { resolvePaths } from '../paths.js';
 import { ipcQuery } from '../ipc-client.js';
+function processGroupKey(process) {
+    return `${process.kind}\u0000${process.name}`;
+}
+/** 同一类、同一可执行名的多个实例在一个采样点中汇总。 */
+export function mergeProcessesByIdentity(processes) {
+    const merged = new Map();
+    for (const process of processes) {
+        const name = String(process.name || 'process');
+        const kind = String(process.kind || 'child');
+        const key = processGroupKey({ name, kind });
+        const current = merged.get(key);
+        if (current) {
+            current.cpuPercent += Number(process.cpuPercent) || 0;
+            current.rss += Number(process.rss) || 0;
+        }
+        else {
+            merged.set(key, {
+                name,
+                kind,
+                cpuPercent: Number(process.cpuPercent) || 0,
+                rss: Number(process.rss) || 0,
+            });
+        }
+    }
+    return [...merged.values()].sort((left, right) => processGroupKey(left).localeCompare(processGroupKey(right)));
+}
+/** 将进程的单核 CPU 百分比换算为整机全部逻辑 CPU 的容量占比。 */
+export function normalizeProcessCpuPercent(cpuPercent, cpuCount) {
+    const count = Number(cpuCount);
+    const divisor = Number.isFinite(count) && count > 0 ? count : 1;
+    return (Number(cpuPercent) || 0) / divisor;
+}
 // 模块级缓冲区——所有订阅者共享同一份累积时序（单一事实源）。
 const resolutions = {
     fine: { bucketMs: 2_000, cap: 60, buf: [] },
@@ -29,10 +62,12 @@ function ingest(res, sample) {
         last.sysCpu = last.sysCpu + (sample.sysCpu - last.sysCpu) / n;
         last.procRss = last.procRss + (sample.procRss - last.procRss) / n;
         last.sysMemUsed = last.sysMemUsed + (sample.sysMemUsed - last.sysMemUsed) / n;
+        last.diskReadBps = last.diskReadBps + (sample.diskReadBps - last.diskReadBps) / n;
+        last.diskWriteBps = last.diskWriteBps + (sample.diskWriteBps - last.diskWriteBps) / n;
         last.netRxBps = last.netRxBps + (sample.netRxBps - last.netRxBps) / n;
         last.netTxBps = last.netTxBps + (sample.netTxBps - last.netTxBps) / n;
         for (const process of sample.processes) {
-            const current = last.processes.find(item => item.pid === process.pid);
+            const current = last.processes.find(item => processGroupKey(item) === processGroupKey(process));
             if (current) {
                 const processSamples = current._n + 1;
                 current.cpuPercent += (process.cpuPercent - current.cpuPercent) / processSamples;
@@ -61,10 +96,11 @@ function exportBuf(res) {
         sysCpu: round1(b.sysCpu),
         procRss: Math.round(b.procRss),
         sysMemUsed: Math.round(b.sysMemUsed),
+        diskReadBps: Math.round(b.diskReadBps),
+        diskWriteBps: Math.round(b.diskWriteBps),
         netRxBps: Math.round(b.netRxBps),
         netTxBps: Math.round(b.netTxBps),
         processes: b.processes.map(process => ({
-            pid: process.pid,
             name: process.name,
             kind: process.kind,
             cpuPercent: round1(process.cpuPercent),
@@ -73,6 +109,49 @@ function exportBuf(res) {
     }));
 }
 function round1(n) { return Math.round(n * 10) / 10; }
+const DISK_SECTOR_BYTES = 512;
+let previousDiskSample = null;
+let latestDiskRate = { readBps: 0, writeBps: 0 };
+/** 解析 Linux diskstats，只累计整盘，避免分区和虚拟映射重复计数。 */
+export function parseLinuxDiskStats(input, isPartition = name => fs.existsSync(`/sys/class/block/${name}/partition`)) {
+    let readBytes = 0;
+    let writeBytes = 0;
+    for (const line of input.split('\n')) {
+        const fields = line.trim().split(/\s+/);
+        if (fields.length < 10)
+            continue;
+        const name = fields[2];
+        if (!name || /^(loop|ram|zram|fd|sr|dm-|md|zd)/.test(name) || isPartition(name))
+            continue;
+        readBytes += (Number(fields[5]) || 0) * DISK_SECTOR_BYTES;
+        writeBytes += (Number(fields[9]) || 0) * DISK_SECTOR_BYTES;
+    }
+    return { readBytes, writeBytes };
+}
+function readDiskTotals() {
+    try {
+        return parseLinuxDiskStats(fs.readFileSync('/proc/diskstats', 'utf8'));
+    }
+    catch {
+        return { readBytes: 0, writeBytes: 0 };
+    }
+}
+function sampleDiskRate(ts) {
+    const totals = readDiskTotals();
+    if (!previousDiskSample) {
+        previousDiskSample = { ...totals, ts };
+        return latestDiskRate;
+    }
+    const elapsedMs = ts - previousDiskSample.ts;
+    if (elapsedMs < 250)
+        return latestDiskRate;
+    latestDiskRate = {
+        readBps: Math.max(0, (totals.readBytes - previousDiskSample.readBytes) * 1000 / elapsedMs),
+        writeBps: Math.max(0, (totals.writeBytes - previousDiskSample.writeBytes) * 1000 / elapsedMs),
+    };
+    previousDiskSample = { ...totals, ts };
+    return latestDiskRate;
+}
 let previousNetworkSample = null;
 let latestNetworkRate = { rxBps: 0, txBps: 0 };
 function readNetworkTotals() {
@@ -122,22 +201,26 @@ async function fetchSnapshot() {
     }
     const s = resp.snapshot;
     const ts = Number(s.ts) || Date.now();
+    const cpuCount = Number(s.cpuCount) || 1;
+    const disk = sampleDiskRate(ts);
     const network = sampleNetworkRate(ts);
     const sample = {
         ts,
-        procCpu: s.cpuPercent ?? 0,
+        procCpu: normalizeProcessCpuPercent(s.cpuPercent, cpuCount),
         sysCpu: s.system?.cpuPercent ?? 0,
         procRss: s.memory?.rss ?? 0,
         sysMemUsed: s.system?.memUsed ?? 0,
+        diskReadBps: disk.readBps,
+        diskWriteBps: disk.writeBps,
         netRxBps: network.rxBps,
         netTxBps: network.txBps,
-        processes: Array.isArray(s.processTree?.processes) ? s.processTree.processes.map((process) => ({
+        processes: mergeProcessesByIdentity(Array.isArray(s.processTree?.processes) ? s.processTree.processes.map((process) => ({
             pid: Number(process.pid),
             name: String(process.name || 'process'),
             kind: String(process.kind || 'child'),
-            cpuPercent: Number(process.cpuPercent) || 0,
+            cpuPercent: normalizeProcessCpuPercent(process.cpuPercent, cpuCount),
             rss: Number(process.rss) || 0,
-        })) : [],
+        })) : []),
     };
     ingest(resolutions.fine, sample);
     ingest(resolutions.mid, sample);

package/dist/sources/msg.js

@@ -6,11 +6,16 @@
  */
 import fs from 'fs';
 import path from 'path';
+import { ipcQuery } from '../ipc-client.js';
 import { resolvePaths } from '../paths.js';
 import { resolveParentDistModule, toFileUrl } from './parent-package.js';
 import { isTransientProtocolMessage, readAllJsonlLines, readJsonFile, } from '../fs-utils.js';
 let contextModulesPromise = null;
 const sessionAdapterPromises = new Map();
+let peerDisplayResolverPromise = null;
+const aunGroupNameCache = new Map();
+const aunGroupNameRequests = new Map();
+let agentDisplayNamesCache = null;
 function getContextModules() {
     if (!contextModulesPromise) {
         contextModulesPromise = Promise.all([
@@ -21,6 +26,145 @@ function getContextModules() {
     }
     return contextModulesPromise;
 }
+function getPeerDisplayResolver() {
+    if (!peerDisplayResolverPromise) {
+        peerDisplayResolverPromise = Promise.resolve()
+            .then(() => import(toFileUrl(resolveParentDistModule('config', 'contact-book.js'))))
+            .then(mod => typeof mod.resolvePeerDisplayLabel === 'function' ? mod.resolvePeerDisplayLabel : null)
+            .catch(() => null);
+    }
+    return peerDisplayResolverPromise;
+}
+export function resolveContactPeerName(resolver, identity, peerId, fallback) {
+    if (!resolver)
+        return fallback;
+    try {
+        return resolver(identity.selfAID, identity.channelType, peerId, identity.channel) || fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+export function aunGroupIdVariants(groupId) {
+    const id = String(groupId || '').trim();
+    if (!id)
+        return [];
+    const variants = new Set([id]);
+    const legacy = /^group\.agentid\.pub\/([^/]+)$/i.exec(id);
+    if (legacy)
+        variants.add(`${legacy[1]}.agentid.pub`);
+    const current = /^([^.]+)\.agentid\.pub$/i.exec(id);
+    if (current)
+        variants.add(`group.agentid.pub/${current[1]}`);
+    return [...variants];
+}
+export function resolveAunGroupName(names, groupId, fallback) {
+    for (const id of aunGroupIdVariants(groupId || '')) {
+        const name = names.get(id);
+        if (name)
+            return name;
+    }
+    return fallback;
+}
+async function fetchAunGroupNames(aid) {
+    const names = new Map();
+    let cursor = null;
+    let page = 0;
+    do {
+        page += 1;
+        const response = await ipcQuery(resolvePaths().socket, {
+            type: 'menu.exec',
+            payload: {
+                type: 'menu.query',
+                name: 'connect',
+                cmd: '/connect',
+                agent: aid,
+                id: `ecweb-msg-groups-${Date.now()}-${page}`,
+                args: { self: aid, view: 'groups', limit: 200, ...(cursor ? { cursor } : {}) },
+            },
+            auth: { source: 'ecweb', localDirect: true },
+        }, 10_000);
+        const data = response?.ok && !response.response?.error ? response.response?.data : null;
+        if (!data || !Array.isArray(data.items))
+            break;
+        for (const item of data.items) {
+            const groupId = String(item?.groupId || '').trim();
+            const displayName = String(item?.displayName || '').trim();
+            if (!groupId || !displayName)
+                continue;
+            for (const variant of aunGroupIdVariants(groupId))
+                names.set(variant, displayName);
+        }
+        cursor = typeof data.nextCursor === 'string' && data.nextCursor ? data.nextCursor : null;
+    } while (cursor && page < 20);
+    return names;
+}
+function getAunGroupNames(aid) {
+    const cached = aunGroupNameCache.get(aid);
+    if (cached && cached.expiresAt > Date.now())
+        return Promise.resolve(cached.names);
+    const pending = aunGroupNameRequests.get(aid);
+    if (pending)
+        return pending;
+    const request = fetchAunGroupNames(aid)
+        .then(names => {
+        aunGroupNameCache.set(aid, {
+            names,
+            expiresAt: Date.now() + (names.size ? 5 * 60_000 : 15_000),
+        });
+        return names;
+    })
+        .catch(() => new Map())
+        .finally(() => aunGroupNameRequests.delete(aid));
+    aunGroupNameRequests.set(aid, request);
+    return request;
+}
+async function hydrateAunGroupNames(chats) {
+    const aids = [...new Set(chats
+            .filter(chat => chat.channelType === 'aun' && chat.chatType === 'group')
+            .map(chat => chat.selfAID))];
+    if (!aids.length)
+        return;
+    const directories = new Map(await Promise.all(aids.map(async (aid) => [aid, await getAunGroupNames(aid)])));
+    for (const chat of chats) {
+        if (chat.channelType !== 'aun' || chat.chatType !== 'group')
+            continue;
+        const groupName = resolveAunGroupName(directories.get(chat.selfAID) || new Map(), chat.groupId, chat.groupName);
+        if (!groupName)
+            continue;
+        chat.groupName = groupName;
+        chat.peerName = groupName;
+    }
+}
+export function resolveSessionBindDisplayName(bind, resolver, aunGroupNames = new Map()) {
+    const isGroup = bind.chatType === 'group' || !!bind.groupId;
+    if (bind.channelType === 'aun' && isGroup) {
+        return resolveAunGroupName(aunGroupNames, bind.groupId || bind.channelId, bind.groupName || null);
+    }
+    if (isGroup)
+        return bind.groupName || null;
+    return resolveContactPeerName(resolver, {
+        selfAID: bind.selfAID,
+        channelType: bind.channelType,
+        channel: bind.channelKey || bind.channelType,
+        channelId: bind.channelId,
+    }, bind.peerId || bind.channelId, bind.peerName);
+}
+/** 为会话页绑定标签补齐联系人名或 AUN 群名，不改变原始 channelId。 */
+export async function hydrateSessionBindDisplayNames(binds) {
+    const items = [...binds];
+    if (!items.length)
+        return;
+    const resolver = await getPeerDisplayResolver();
+    const groupAids = [...new Set(items
+            .filter(bind => bind.channelType === 'aun' && (bind.chatType === 'group' || !!bind.groupId))
+            .map(bind => bind.selfAID)
+            .filter(Boolean))];
+    const groupDirectories = new Map(await Promise.all(groupAids.map(async (aid) => [aid, await getAunGroupNames(aid)])));
+    for (const bind of items) {
+        bind.displayName = resolveSessionBindDisplayName(bind, resolver, groupDirectories.get(bind.selfAID) || new Map());
+    }
+}
 function getSessionAdapter(baseagent) {
     if (!sessionAdapterPromises.has(baseagent)) {
         const classNames = {
@@ -67,6 +211,9 @@ function readLastJsonlObject(file) {
     const rows = readAllJsonlLines(file);
     return rows.length ? rows[rows.length - 1] : null;
 }
+export function latestMessageAt(messages) {
+    return messages.reduce((latest, message) => Math.max(latest, Number(message.ts) || 0), 0);
+}
 function loadThreadSessions(dirPath) {
     const threadsDir = path.join(dirPath, '_threads');
     const index = readJsonFile(path.join(threadsDir, 'thread-index.json')) || {};
@@ -170,6 +317,37 @@ function listConfiguredAgentAids(root) {
     }
     return aids;
 }
+function shortAid(value) {
+    return String(value || '').split('.')[0] || String(value || '');
+}
+/** Returns local Agent display names, preferring the runtime selfName. */
+export async function getAgentSelfNames() {
+    if (agentDisplayNamesCache && agentDisplayNamesCache.expiresAt > Date.now()) {
+        return agentDisplayNamesCache.names;
+    }
+    const names = new Map();
+    try {
+        const [agentsResp, statsResp] = await Promise.all([
+            ipcQuery(resolvePaths().socket, { type: 'evolagent.list' }, 4000),
+            ipcQuery(resolvePaths().socket, { type: 'aun-aid-stats' }, 4000),
+        ]);
+        const statsByAid = new Map((statsResp?.stats || []).map(item => [String(item?.aid || ''), item]));
+        for (const agent of agentsResp?.agents || []) {
+            const aid = String(agent?.aid || '').trim();
+            if (!aid)
+                continue;
+            const stats = statsByAid.get(aid);
+            const displayName = String(stats?.selfName || agent?.displayName || shortAid(aid)).trim();
+            if (displayName)
+                names.set(aid, displayName);
+        }
+    }
+    catch {
+        // daemon unavailable: leave the map empty and use the AID fallback below
+    }
+    agentDisplayNamesCache = { expiresAt: Date.now() + 5000, names };
+    return names;
+}
 function decodeDirSegment(seg) {
     return seg.replace(/%([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
 }
@@ -289,7 +467,7 @@ function chatDisplayId(active, messages) {
         groupName: null,
     };
 }
-function loadChats() {
+function loadChats(peerDisplayResolver) {
     const paths = resolvePaths();
     const sessionsDir = paths.sessionsDir;
     const configuredAids = listConfiguredAgentAids(paths.root);
@@ -308,6 +486,9 @@ function loadChats() {
             continue;
         const chatType = String(active.chatType || messages.find(m => m.chatType)?.chatType || 'private');
         const display = chatDisplayId({ ...active, chatType, channelId }, messages);
+        const peerName = chatType === 'group'
+            ? display.peerName
+            : resolveContactPeerName(peerDisplayResolver, identity, display.peerId, display.peerName);
         const threadSessions = loadThreadSessions(dirPath);
         const threadById = new Map(threadSessions.map(item => [item.threadId, item]));
         const mainSessionIds = loadMainSessionIds(dirPath, active);
@@ -316,8 +497,9 @@ function loadChats() {
                 continue;
             const thread = item.threadId ? threadById.get(item.threadId) : undefined;
             const partitionActive = item.partition === 'thread' ? thread?.active || {} : item.partition === 'main' ? active : {};
-            const lastMsgAt = item.messages.reduce((max, message) => Math.max(max, message.ts || 0), 0);
-            const updatedAt = Math.max(Number(partitionActive.updatedAt || 0), lastMsgAt);
+            // active.updatedAt also changes for session metadata maintenance (for example,
+            // a project-path migration), so it is not a conversation activity timestamp.
+            const updatedAt = latestMessageAt(item.messages);
             chats.push({
                 id: safeId(`${selfAID}\n${channelType}\n${channelId}\n${chatType}\n${item.partition}\n${item.threadId || ''}`),
                 dirPath,
@@ -327,7 +509,7 @@ function loadChats() {
                 selfAID,
                 chatType,
                 peerId: display.peerId,
-                peerName: display.peerName,
+                peerName,
                 groupId: display.groupId,
                 groupName: display.groupName,
                 partition: item.partition,
@@ -349,7 +531,7 @@ function scopeId(chat) {
 function legacyChannelScopeId(chat) {
     return safeId(`${chat.selfAID}\n${chat.channelType}\n${chat.channel}`);
 }
-function buildScopes(chats) {
+function buildScopes(chats, agentDisplayNames = new Map()) {
     const map = new Map();
     const seenChats = new Map();
     const seenChannels = new Map();
@@ -362,6 +544,7 @@ function buildScopes(chats) {
                 id,
                 aid: id,
                 selfAID: chat.selfAID,
+                displayName: agentDisplayNames.get(chat.selfAID) || shortAid(chat.selfAID),
                 totalIn: 0,
                 totalOut: 0,
                 peerCount: 0,
@@ -562,8 +745,9 @@ async function buildSessionContext(chat) {
     };
 }
 async function buildSnapshot(params) {
-    const chats = loadChats();
-    const scopes = buildScopes(chats);
+    const peerDisplayResolver = await getPeerDisplayResolver();
+    const chats = loadChats(peerDisplayResolver);
+    const scopes = buildScopes(chats, await getAgentSelfNames());
     const requestedScope = params.scope || params.aid || null;
     const scope = requestedScope && !scopes.some(s => s.id === requestedScope)
         ? (chats.find(chat => legacyChannelScopeId(chat) === requestedScope)
@@ -572,6 +756,8 @@ async function buildSnapshot(params) {
         : requestedScope;
     const peer = params.peer || null;
     const inScope = selectedChats(chats, scope);
+    if (scope)
+        await hydrateAunGroupNames(inScope);
     const peers = scope ? mergePeerInfo(inScope) : [];
     const messages = scope ? messagesFor(inScope, peer) : [];
     const currentChat = peer ? inScope.find(chat => chatKey(chat) === peer) : undefined;

package/dist/sources/relation-roles.js

@@ -661,30 +661,8 @@ export const relationRolesSource = {
             return { agents: [], conversations: [], error: String(err) };
         }
     },
-    subscribe(_params, push) {
-        let lastJson = '';
-        let stopped = false;
-        const tick = async () => {
-            if (stopped)
-                return;
-            try {
-                const snap = await buildSnapshot(_params.__menuAuth ?? {});
-                const json = JSON.stringify(snap);
-                if (json !== lastJson) {
-                    lastJson = json;
-                    push(snap);
-                }
-            }
-            catch (err) {
-                console.error('[relation-roles] polling error:', err);
-            }
-        };
-        tick();
-        const timer = setInterval(tick, 2000);
-        return () => {
-            stopped = true;
-            clearInterval(timer);
-        };
+    subscribe(_params, _push) {
+        return () => { };
     },
 };
 function requireScope(body) {