evolclaw 3.1.11 → 3.2.0

package/dist/core/evolagent-registry.js

@@ -300,6 +300,9 @@ export class EvolAgentRegistry {
             }
             // swap config 后再起新 channel —— startChannel hook 需要看到新 config
             oldAgent.swapConfig(raw, merged);
+            // 热重载也刷新身份层缓存（persona / working 等 fileCache 'agent-files:<aid>' 组），
+            // 使 personal 文件改动经 reload 即时生效，不必重启。
+            oldAgent.invalidatePersonaCache();
             for (const ch of toAdd) {
                 await hooks.startChannel(oldAgent, ch);
                 addedSuccessfully.push(ch);

package/dist/core/evolagent.js

@@ -1,9 +1,9 @@
 import path from 'path';
-import fs from 'fs';
 import { logger } from '../utils/logger.js';
 import { saveAgent } from '../config-store.js';
 import { formatChannelKey, tryParseChannelKey } from './channel-loader.js';
 import { agentPersonalDir } from '../paths.js';
+import { fileCache } from './cache/file-cache.js';
 /**
  * EvolAgent —— 一个 self-agent 的运行时表示。
  *
@@ -213,40 +213,45 @@ export class EvolAgent {
         this.merged.dispatch = value;
         this.persist();
     }
+    /** 读取观察者模式开关（默认 false）。 */
+    getObservable() {
+        return this.merged.observable === true;
+    }
+    /** 设置观察者模式开关：开启后入站/出站消息各转发一份给 owners[]。 */
+    setObservable(value) {
+        if (value)
+            this.rawAgent.observable = true;
+        else
+            delete this.rawAgent.observable;
+        this.merged.observable = value;
+        this.persist();
+    }
     // ── Personal layer ────────────────────────────────────────────────────
-    _personaCache = undefined;
+    /** 本 agent 身份层文件在 fileCache 的组名（带 aid，避免 reload 单个 agent 误失效他人）。 */
+    agentFilesGroup() {
+        return `agent-files:${this.aid}`;
+    }
     /**
-     * 读取 personal/persona.md 内容（缓存，首次调用时从磁盘读）。
-     * 文件不存在返回 null。
+     * 读取 personal/persona.md 内容。走 fileCache（mtime 门控）：persona 没有任何
+     * 写入命令、由 agent 自己带外改写，与 working memory 同样改了即应生效，故每次读
+     * stat 比对、变了自动重读。文件不存在返回 null。
      */
     getPersona() {
-        if (this._personaCache !== undefined)
-            return this._personaCache;
         const personaPath = path.join(agentPersonalDir(this.aid), 'persona.md');
-        try {
-            this._personaCache = fs.readFileSync(personaPath, 'utf-8').trim() || null;
-        }
-        catch {
-            this._personaCache = null;
-        }
-        return this._personaCache;
+        return fileCache.get(personaPath, (raw) => (raw === null ? null : (raw.trim() || null)), { policy: 'mtime', group: this.agentFilesGroup() });
     }
     /**
-     * 读取 personal/memory/working.md 内容（不缓存，每次会话开始时读）。
+     * 读取 personal/memory/working.md 内容。走 fileCache（mtime 门控）：
+     * agent 在对话中改写 working memory、不触发 reload，故每次读 stat 比对、
+     * 变了自动重读，既即时反映又避免无谓重读。
      */
     getWorkingMemory() {
         const workingPath = path.join(agentPersonalDir(this.aid), 'memory', 'working.md');
-        try {
-            const content = fs.readFileSync(workingPath, 'utf-8').trim();
-            return content || null;
-        }
-        catch {
-            return null;
-        }
+        return fileCache.get(workingPath, (raw) => (raw === null ? null : (raw.trim() || null)), { policy: 'mtime', group: this.agentFilesGroup() });
     }
-    /** 清除 persona 缓存（reload 后重新读取） */
+    /** 清除本 agent 身份层缓存（reload 后重新读取）。只失效自己的文件组，不波及他人。 */
     invalidatePersonaCache() {
-        this._personaCache = undefined;
+        fileCache.invalidateGroup(this.agentFilesGroup());
     }
     // ── Context（喂给 message-processor / command-handler） ──────────────
     getContext(_channelKey, chatType, globalChatmode) {

package/dist/core/message/command-handler-agent-control.js

@@ -0,0 +1,153 @@
+import { agentCreateNonInteractive, agentDelete, agentEnable, agentDisable, agentList, agentShow, agentSet, } from '../../cli/agent.js';
+import { logger } from '../../utils/logger.js';
+import { resolvePaths } from '../../paths.js';
+import path from 'path';
+import { CreateStatusWriter, readCreateStatus } from './create-status.js';
+/** 把 cli/agent.ts 的 error 字符串映射为结构化错误码 */
+function classifyError(error) {
+    if (/already exists/i.test(error))
+        return 'CONFLICT';
+    if (/not found/i.test(error))
+        return 'NOT_FOUND';
+    if (/invalid|must be|required|缺少/i.test(error))
+        return 'INVALID_ARGS';
+    return 'INTERNAL';
+}
+/** 后台异步：实际创建 agent + 落 model/chatmode，全程写构建进度（D3）。
+ *  失败仅写日志 + create-status，不回传（受理即返回）。
+ *  agentSet key 对照 cli/agent.ts 的 setNestedValue：
+ *  model → 'models.default'（ModelsBlock.default）；chatmode → 'chatmode'（ChatmodeBlock 对象）。 */
+async function runCreateInBackground(opts) {
+    const agentDir = path.join(resolvePaths().agentsDir, opts.aid);
+    const w = new CreateStatusWriter(agentDir, opts.aid);
+    let curPhase = 'validating'; // 跟踪当前环节，供 catch 兜底时标注正确 phase
+    try {
+        // onPhase 把 agentCreateNonInteractive 内部环节（0-3、5）映射到进度文件
+        const res = await agentCreateNonInteractive({
+            aid: opts.aid, name: opts.name, baseagent: opts.baseagent,
+            project: opts.project, owner: opts.owner,
+            onPhase: (phase, state, detail) => {
+                if (state === 'begin') {
+                    curPhase = phase;
+                    w.begin(phase);
+                }
+                else if (state === 'done')
+                    w.done(phase, detail);
+                else if (state === 'warn')
+                    w.warn(phase, detail);
+                else if (state === 'failed')
+                    w.finishFailed(phase, detail ?? 'failed');
+            },
+        });
+        if (!('ok' in res) || res.ok !== true) {
+            // 硬失败：onPhase('failed') 已写终态；这里仅兜底日志（防回调未覆盖的 return 路径）
+            const err = res.error;
+            logger.warn(`[agent-control] create ${opts.aid} failed: ${err}`);
+            return;
+        }
+        // 环节 4：applying_config（model/chatmode，agentCreateNonInteractive 之外）
+        if (opts.model || opts.chatmode) {
+            curPhase = 'applying_config';
+            w.begin('applying_config');
+            let warned;
+            if (opts.model) {
+                const r = await agentSet(opts.aid, 'models.default', opts.model);
+                if (!('ok' in r) || !r.ok)
+                    warned = `model: ${r.error}`;
+            }
+            if (opts.chatmode) {
+                const r = await agentSet(opts.aid, 'chatmode', JSON.stringify(opts.chatmode));
+                if (!('ok' in r) || !r.ok)
+                    warned = `${warned ? warned + '; ' : ''}chatmode: ${r.error}`;
+            }
+            if (warned) {
+                logger.warn(`[agent-control] applying_config ${opts.aid}: ${warned}`);
+                w.warn('applying_config', warned);
+            }
+            else
+                w.done('applying_config');
+        }
+        w.finishReady();
+        logger.info(`[agent-control] create ${opts.aid} ready`);
+    }
+    catch (e) {
+        const msg = e?.message || String(e);
+        logger.warn(`[agent-control] create ${opts.aid} threw at ${curPhase}: ${msg}`);
+        w.finishFailed(curPhase, msg); // 兜底终态，标注真实失败环节
+    }
+}
+/** name=agent 的 menu.action 执行。peerId 自动填为新 agent 的 owner。
+ *  create 受理即返回（D3）；delete/enable/disable 同步等结果。
+ *  调用方负责传入已兜底的 args.project（见 command-handler 装配）。 */
+export async function execAgentAction(action, args, peerId) {
+    const a = args ?? {};
+    if (action === 'create') {
+        if (!peerId)
+            return { error: '缺少发起者 AID（无法绑定 owner）', code: 'INVALID_ARGS' };
+        if (!a.aid || !a.name || !a.baseagent) {
+            return { error: '缺少必填参数：aid / name / baseagent', code: 'INVALID_ARGS' };
+        }
+        if (!a.project || typeof a.project !== 'string') {
+            return { error: 'project 缺失且无法兜底（需 defaults.projects.rootPath/defaultPath）', code: 'INVALID_ARGS' };
+        }
+        // D3: 受理即返回，重副作用转后台
+        // 受理即返回；后台 promise fire-and-forget。runCreateInBackground 内部有 try/catch，
+        // 但 CreateStatusWriter 构造（mkdir/写盘）在 try 之前，故再加一层兜底防未处理拒绝。
+        void runCreateInBackground({
+            aid: a.aid, name: a.name, baseagent: a.baseagent,
+            project: a.project, owner: peerId,
+            model: a.model, chatmode: a.chatmode,
+        }).catch(e => logger.error(`[agent-control] runCreateInBackground unhandled ${a.aid}: ${e?.message || e}`));
+        return { data: { accepted: true, aid: a.aid } };
+    }
+    if (action === 'delete') {
+        if (!a.aid)
+            return { error: '缺少 aid', code: 'INVALID_ARGS' };
+        const res = await agentDelete(a.aid, false);
+        if (!('ok' in res) || res.ok !== true)
+            return { error: res.error, code: classifyError(res.error) };
+        return { data: { aid: res.aid, purged: res.purged } };
+    }
+    if (action === 'enable' || action === 'disable') {
+        if (!a.aid)
+            return { error: '缺少 aid', code: 'INVALID_ARGS' };
+        const res = action === 'enable' ? await agentEnable(a.aid) : await agentDisable(a.aid);
+        if (!('ok' in res) || res.ok !== true)
+            return { error: res.error, code: classifyError(res.error) };
+        return { data: { aid: res.aid, enabled: res.enabled, reloaded: res.reloaded } };
+    }
+    return { error: `不支持的 action: ${action}`, code: 'INVALID_ARGS' };
+}
+/** project 兜底：显式值 > rootPath 合成 > defaultPath > undefined */
+export function resolveProjectPath(explicit, aid, defaults) {
+    if (explicit && explicit.trim())
+        return explicit;
+    const root = defaults?.projects?.rootPath;
+    if (root)
+        return path.join(root, aid.split('.')[0]);
+    return defaults?.projects?.defaultPath;
+}
+/** name=agent 的 menu.query：查单个 agent 详情，附构建进度（D3）。 */
+export async function execAgentQuery(args) {
+    const aid = args?.aid;
+    if (!aid)
+        return { error: '缺少 aid', code: 'INVALID_ARGS' };
+    const res = await agentShow(aid);
+    if (!('ok' in res) || res.ok !== true)
+        return { error: res.error, code: classifyError(res.error) };
+    // 叠加构建进度（create 受理后、ready 前可见；ready 后文件仍在，可反映软失败 warn）
+    const agentDir = path.join(resolvePaths().agentsDir, aid);
+    const progress = readCreateStatus(agentDir);
+    return { data: progress ? { ...res, createProgress: progress } : res };
+}
+/** name=agent 的 menu.options：列出 agent（enabled 默认 / all） */
+export async function execAgentOptions(args) {
+    const scope = args?.options === 'all' ? 'all' : 'enabled';
+    const res = await agentList();
+    if (!('ok' in res) || res.ok !== true)
+        return { error: res.error, code: classifyError(res.error) };
+    const agents = scope === 'all'
+        ? res.agents
+        : res.agents.filter((x) => x.status !== 'disabled');
+    return { data: { agents, scope } };
+}

package/dist/core/message/create-status.js

@@ -0,0 +1,67 @@
+import fs from 'fs';
+import path from 'path';
+const FILE = 'create-status.json';
+export function readCreateStatus(agentDir) {
+    try {
+        const raw = fs.readFileSync(path.join(agentDir, FILE), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** 删除构建进度文件（agent 删除时清理）。非 purge 删除只移除 config.json，
+ *  故需显式清理本文件，避免目录残留陈旧进度。 */
+export function removeCreateStatus(agentDir) {
+    try {
+        fs.rmSync(path.join(agentDir, FILE), { force: true });
+    }
+    catch { /* ignore */ }
+}
+/** 构建进度写入器。每次状态变更原子落盘（写临时文件 + rename）。 */
+export class CreateStatusWriter {
+    agentDir;
+    status;
+    constructor(agentDir, aid) {
+        this.agentDir = agentDir;
+        const now = Date.now();
+        this.status = { aid, status: 'in_progress', currentPhase: null, steps: [], error: null, startedAt: now, updatedAt: now };
+        fs.mkdirSync(agentDir, { recursive: true });
+        this.flush();
+    }
+    begin(phase) {
+        this.status.currentPhase = phase;
+        this.status.steps.push({ phase, state: 'in_progress', ts: Date.now() });
+        this.flush();
+    }
+    done(phase, detail) { this.mark(phase, 'done', detail); }
+    warn(phase, detail) { this.mark(phase, 'warn', detail); }
+    finishReady() { this.status.status = 'ready'; this.status.currentPhase = null; this.flush(); }
+    finishFailed(phase, error) {
+        this.mark(phase, 'failed', error);
+        this.status.status = 'failed';
+        this.status.error = error;
+        this.status.currentPhase = null;
+        this.flush();
+    }
+    mark(phase, state, detail) {
+        const step = [...this.status.steps].reverse().find(s => s.phase === phase);
+        if (step) {
+            step.state = state;
+            if (detail)
+                step.detail = detail;
+            step.ts = Date.now();
+        }
+        else {
+            this.status.steps.push({ phase, state, detail, ts: Date.now() });
+        }
+        this.flush();
+    }
+    flush() {
+        this.status.updatedAt = Date.now();
+        const file = path.join(this.agentDir, FILE);
+        const tmp = `${file}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(this.status, null, 2));
+        fs.renameSync(tmp, file);
+    }
+}

package/dist/core/message/message-bridge.js

@@ -151,7 +151,7 @@ export class MessageBridge {
                     sameNetwork: msg.sameNetwork,
                     sameEgressIp: msg.sameEgressIp,
                     messageId: msg.messageId,
-                    mentions: msg.mentions, threadId: msg.threadId,
+                    mentions: msg.mentions, mentionAids: msg.mentionAids, threadId: msg.threadId,
                     replyContext: msg.replyContext,
                 };
                 // 5.5 写入消息记录（入方向）
@@ -218,6 +218,8 @@ export class MessageBridge {
         activity: '/activity',
         system: '/system',
         cli: '/cli',
+        agent: '/agent',
+        trigger: '/trigger',
     };
     resolveCmd(name, cmd) {
         if (cmd)
@@ -276,7 +278,7 @@ export class MessageBridge {
         const { id, name, cmd } = req;
         try {
             const resolvedCmd = this.resolveCmd(name, cmd);
-            const result = await this.cmdHandler.execMenuQuery(resolvedCmd, channel, msg.channelId, msg.peerId);
+            const result = await this.cmdHandler.execMenuQuery(resolvedCmd, channel, msg.channelId, msg.peerId, req.args);
             if ('error' in result)
                 throw { code: result.code || 'EXEC_FAILED', message: result.error };
             await this.sendMenuResponse(adapter, channel, msg.channelId, { type: 'menu.response', id, name, data: result.data }, sendReply);
@@ -292,7 +294,7 @@ export class MessageBridge {
         const { id, name, cmd } = req;
         try {
             const resolvedCmd = this.resolveCmd(name, cmd);
-            const data = await this.cmdHandler.getSubMenuItems(resolvedCmd, channel, msg.channelId, msg.peerId) ?? [];
+            const data = await this.cmdHandler.getSubMenuItems(resolvedCmd, channel, msg.channelId, msg.peerId, req.args) ?? [];
             await this.sendMenuResponse(adapter, channel, msg.channelId, { type: 'menu.response', id, name, data }, sendReply);
         }
         catch (err) {

package/dist/core/message/message-processor.js

@@ -295,16 +295,9 @@ export class MessageProcessor {
         const streamKey = session.id;
         const chatType = message.chatType || 'private';
         const identityRole = session.identity?.role || 'anonymous';
-        const agentNameForMonitor = this.agentRegistry?.resolveByChannel(channelKey)?.name ?? '<unknown>';
-        // Resolve agent context from registry (Phase 2 foundation)
-        const agentContext = this.getAgentContext(channelKey, chatType);
-        if (agentContext) {
-            logger.debug(`[MessageProcessor] Agent context resolved: ${agentContext.name} (${agentContext.baseagent})`);
-        }
-        // 按 session.agentId 选择 agent 后端
-        const agent = this.getAgent(channelKey, session.agentId);
         const monitorEnabled = this.globalSettings.idleMonitor?.enabled !== false;
-        const showIdleMonitor = policy.showIdleMonitor(chatType, identityRole);
+        // 按 session.agentId 选择 agent 后端（idle-kill 路径需要 interrupt）
+        const agent = this.getAgent(channelKey, session.agentId);
         // 计算是否抑制中间输出（工具活动 + 流式文本）
         const shouldSuppress = () => {
             return !policy.showMiddleResult(chatType, identityRole);
@@ -313,6 +306,7 @@ export class MessageProcessor {
         let monitor;
         let monitorInterval;
         let rejectFn;
+        let lastIdleSec = 0;
         const resetTimer = (eventType, toolName) => {
             monitor?.recordEvent(eventType || 'unknown', toolName);
         };
@@ -329,17 +323,9 @@ export class MessageProcessor {
                 let result = monitor.check();
                 while (result) {
                     if (result.action === 'kill') {
+                        lastIdleSec = result.idleSec;
                         logger.warn(`[MessageProcessor] Idle monitor: kill after ${result.idleSec}s idle, stream: ${streamKey}`);
                         this.eventBus.publish({ type: 'runner:idle-timeout', sessionId: streamKey, idleSec: result.idleSec });
-                        // 后台任务也需要中断（释放资源），但不发送通知
-                        if (channelInfo && !isBackground) {
-                            const msg = showIdleMonitor
-                                ? result.message
-                                : `\u26a0\ufe0f 任务超时（${result.idleSec}秒无响应），已自动中断`;
-                            channelInfo.adapter.send(buildEnvelope({ channel: channelInfo.adapter.channelName, channelId: message.channelId, agentName: agentNameForMonitor }), { kind: 'system.notice', text: msg, subtype: 'health' }).catch(e => {
-                                logger.debug(`[MessageProcessor] Failed to send kill diagnostic message:`, e);
-                            });
-                        }
                         logger.info(`[MessageProcessor] agent.interrupt invoked (idle-kill) stream=${streamKey}`);
                         agent.interrupt(streamKey).catch(e => {
                             logger.debug(`[MessageProcessor] Interrupt failed (may already be cleaned up):`, e);
@@ -348,15 +334,16 @@ export class MessageProcessor {
                         return;
                     }
                     else {
-                        // notify or warn: send diagnostic message, task continues
+                        // notify or warn: publish event, task continues
                         logger.info(`[MessageProcessor] Idle monitor: ${result.action} after ${result.idleSec}s idle, stream: ${streamKey}`);
-                        if (channelInfo && showIdleMonitor && !shouldSuppress()) {
-                            if (!isBackground) {
-                                channelInfo.adapter.send(buildEnvelope({ channel: channelInfo.adapter.channelName, channelId: message.channelId, agentName: agentNameForMonitor }), { kind: 'system.notice', text: result.message, subtype: 'health' }).catch(e => {
-                                    logger.debug(`[MessageProcessor] Failed to send idle monitor message:`, e);
-                                });
-                            }
-                        }
+                        this.eventBus.publish({
+                            type: result.action === 'notify' ? 'runner:idle-notify' : 'runner:idle-warn',
+                            sessionId: streamKey,
+                            idleSec: result.idleSec,
+                            totalEvents: result.state.totalEvents,
+                            totalToolCalls: result.state.totalToolCalls,
+                            lastToolName: result.state.lastToolName,
+                        });
                     }
                     result = monitor.check();
                 }
@@ -364,7 +351,7 @@ export class MessageProcessor {
         });
         try {
             await Promise.race([
-                this._processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress),
+                this._processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, () => lastIdleSec),
                 timeoutPromise
             ]);
         }
@@ -412,7 +399,7 @@ export class MessageProcessor {
         return message.replyContext;
     }
     /** 自动安全模式已禁用：仅保留错误计数，不再自动切换状态 */
-    async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress) {
+    async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, getLastIdleSec) {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
         const channelKey = session.metadata?.channelKey || message.channel;
         const channelInfo = this.resolveChannelInfo(channelKey);
@@ -684,6 +671,11 @@ export class MessageProcessor {
                         sameNetwork: message.sameNetwork ?? false,
                         sameEgressIp: message.sameEgressIp ?? false,
                         groupId: session.metadata?.groupId || undefined,
+                        groupName: session.metadata?.groupName || undefined,
+                        // 信封展示用：有群名则「名<ID>」，否则纯 ID。规避模板引擎无 not/else 的限制。
+                        groupLabel: session.metadata?.groupId
+                            ? (session.metadata?.groupName ? `${session.metadata.groupName}<${session.metadata.groupId}>` : session.metadata.groupId)
+                            : undefined,
                         chatType: session.chatType || null,
                         channel: currentChannelType || null,
                         venueUid: undefined,
@@ -735,6 +727,7 @@ export class MessageProcessor {
                                     sameDevice: message.sameDevice, sameNetwork: message.sameNetwork, sameEgressIp: message.sameEgressIp,
                                     content: message.content, timestamp: message.timestamp,
                                     images: message.images,
+                                    mentionAids: message.mentionAids,
                                 }];
                         renderResult = renderMessageBody(renderItems, kitCtx.vars, session.id);
                         if (renderResult.body.trim())
@@ -1100,7 +1093,7 @@ export class MessageProcessor {
             // 用户主动中断（新消息打断 或 /stop 命令）时静默，不发送中断/错误提示
             if (!isUserInterrupt) {
                 const statusPayload = procStatus === 'timeout'
-                    ? { kind: 'status.timeout' }
+                    ? { kind: 'status.timeout', metadata: { idleSec: getLastIdleSec?.() || undefined } }
                     : procStatus === 'interrupted'
                         ? { kind: 'status.interrupted', metadata: { reason: 'stream_error' } }
                         : { kind: 'status.error' };
@@ -1133,20 +1126,22 @@ export class MessageProcessor {
             if (error instanceof Error && !isUserInterrupt) {
                 logger.error(`[${message.channel}] Error stack:`, error.stack);
             }
-            // 发送用户友好的错误消息（SDK_TIMEOUT 已在 kill 级别发过提示，跳过）
+            // 发送用户友好的错误消息
             // 用户主动中断（新消息打断 或 /stop 命令）时静默，不发送错误提示
             // processEventStream 已通过 renderer 发过错误时也跳过
-            if (error instanceof Error && error.message === 'SDK_TIMEOUT') {
-                logger.info(`[MessageProcessor] SDK_TIMEOUT error, skip sending duplicate message`);
-            }
-            else if (isUserInterrupt) {
+            const isTimeout = error instanceof Error && error.message === 'SDK_TIMEOUT';
+            if (isUserInterrupt) {
                 logger.info(`[MessageProcessor] User interrupt by new_message, skip sending error message`);
             }
             else if (error?._errorAlreadySent) {
                 logger.info(`[MessageProcessor] Error already sent via renderer, skip sending duplicate message`);
             }
             else {
-                const userMessage = getErrorMessage(error, undefined);
+                // SDK_TIMEOUT：status.timeout 已发结构化状态，此处再补一条用户可见的错误文本（result.error）
+                const idleSec = getLastIdleSec?.() || 0;
+                const userMessage = isTimeout
+                    ? (idleSec > 0 ? `⚠️ 任务超时（${idleSec}秒无响应），已自动中断` : '⚠️ 任务超时，已自动中断')
+                    : getErrorMessage(error, undefined);
                 // 获取 session 用于话题回复（如果 resolveSession 已执行）
                 let sendOpts;
                 try {
@@ -1159,7 +1154,10 @@ export class MessageProcessor {
                     ...(sendOpts ?? {}),
                     metadata: { ...(sendOpts?.metadata ?? {}), taskId, chatmode },
                 };
-                await adapter.send({ ...envelope, replyContext: sendOpts }, { kind: 'result.text', text: userMessage, isFinal: true });
+                const errorPayload = isTimeout
+                    ? { kind: 'result.error', text: userMessage, reason: 'timeout' }
+                    : { kind: 'result.text', text: userMessage, isFinal: true };
+                await adapter.send({ ...envelope, replyContext: sendOpts }, errorPayload);
                 // Proactive 可观测：catch 块的基础设施错误也透传为 thought，保证按 task_id 聚合完整
             }
         }
@@ -1196,6 +1194,16 @@ export class MessageProcessor {
             session.sessionMode = 'proactive';
             await this.sessionManager.updateSession(session.id, { sessionMode: 'proactive' });
         }
+        // 群名解析：群会话首次取群显示名（group.get），缓存到 metadata，供信封渲染。
+        // 渠道私有方法 getGroupName 自带进程缓存 + 容错；取不到不阻塞（groupName 保持空，模板回退 groupId）。
+        if (message.chatType === 'group' && session.metadata?.groupId && !session.metadata.groupName) {
+            const adapter = this.resolveChannelInfo(message.channel)?.adapter;
+            const groupName = await adapter?.getGroupName?.(session.metadata.groupId).catch(() => undefined);
+            if (groupName) {
+                session.metadata.groupName = groupName;
+                await this.sessionManager.updateSession(session.id, { metadata: session.metadata });
+            }
+        }
         // 兜底纠正2：旧 session 创建时没传 peerType（建为 interactive），后续非 human 消息进来时升级为 proactive。
         // 新建场景已由 getOrCreateSession 内部 resolveDefaultSessionMode 处理，这里只兜底历史会话。
         if (message.peerType && message.peerType !== 'human' && message.peerType !== 'unknown' && session.sessionMode !== 'proactive') {

package/dist/core/message/message-queue.js

@@ -40,16 +40,22 @@ export class MessageQueue {
     }
     /**
      * 检查消息是否应该处理（去重）
+     *
+     * 去重 key = `${sessionKey}:${messageId}`，而非裸 messageId。
+     * MessageQueue 是进程级单例，被所有 evolagent 共享。AUN 群广播时同一条群消息
+     * 会投递给群里每个 evolagent，它们 messageId 相同但 session 不同，必须各处理一次。
+     * 裸 messageId 去重会让先入队的 agent 吞掉其他 agent 的消息。
      */
-    shouldProcess(message) {
+    shouldProcess(sessionKey, message) {
         if (!message.messageId)
             return true; // 无 ID 的消息不去重
-        if (this.recentMessageIds.has(message.messageId)) {
-            logger.debug(`[Queue] Duplicate message ${message.messageId}, skipping`);
+        const dedupKey = `${sessionKey}:${message.messageId}`;
+        if (this.recentMessageIds.has(dedupKey)) {
+            logger.debug(`[Queue] Duplicate message ${dedupKey}, skipping`);
             return false;
         }
-        this.recentMessageIds.add(message.messageId);
-        setTimeout(() => this.recentMessageIds.delete(message.messageId), this.DEDUP_WINDOW);
+        this.recentMessageIds.add(dedupKey);
+        setTimeout(() => this.recentMessageIds.delete(dedupKey), this.DEDUP_WINDOW);
         return true;
     }
     /**
@@ -67,7 +73,7 @@ export class MessageQueue {
     }
     async enqueue(sessionKey, message, projectPath, options) {
         // 消息去重检查
-        if (!this.shouldProcess(message)) {
+        if (!this.shouldProcess(sessionKey, message)) {
             return Promise.resolve();
         }
         // 拦截器检查：AskUserQuestion 等场景的一次性消息拦截
@@ -212,6 +218,7 @@ export class MessageQueue {
                     sameDevice: m.sameDevice, sameNetwork: m.sameNetwork, sameEgressIp: m.sameEgressIp,
                     content: m.content, timestamp: m.timestamp,
                     images: m.images && m.images.length > 0 ? m.images : undefined,
+                    mentionAids: m.mentionAids && m.mentionAids.length > 0 ? m.mentionAids : undefined,
                 });
             }
         }

package/dist/core/model/model-scope.js

@@ -16,9 +16,42 @@
  */
 import fs from 'fs';
 import path from 'path';
-import { agentRelationsDir } from '../../paths.js';
+import { agentRelationsDir, agentConfig as agentConfigPath, resolvePaths } from '../../paths.js';
 import { loadDefaults, saveDefaultsSafe, loadAgent, saveAgent } from '../../config-store.js';
 import { formatPeerKey, parsePeerKey } from '../relation/peer-key.js';
+import { fileCache } from '../cache/file-cache.js';
+// ── mtime 门控缓存（统一走 FileCache）─────────────────────────────────────
+//
+// resolveEffectiveModel 每条消息按 关系>agent>全局 解析，原本每次都
+// loadAgent()/loadDefaults()/读 preferences.json —— 一条消息最多读盘 5 次。
+//
+// model-scope 被 CLI 子进程与 daemon 共用，CLI 改文件后 daemon 无失效通知，
+// 故靠 mtime 门控：每次只 statSync 比对 mtime，未变用缓存，变了才真正重读 +
+// 重解析。跨进程天然正确（文件 mtime 变即感知），改配置即时生效不变；
+// statSync 远比 read+JSON.parse 便宜。CLI 进程的 fileCache 是独立空实例、随进程
+// 退出，等同直读最新盘值，安全。
+//
+// config/defaults 与 relation-prefs 三者统一走 daemon 单例 FileCache（消除原先
+// 第二套 makeMtimeCache），读取计数一并进监控。config/defaults 的实际读盘 + 解析
+// 仍委托原 loadAgent/loadDefaults（保留 atomicRead 崩溃恢复 + expandEnvRefs/校验），
+// 故传 noopRead 让 FileCache 只做 mtime 门控、不重复读盘（loader 忽略 raw）。
+/** FileCache 的 read 钩子占位：config/defaults 的真实读盘在 loader 里（loadAgent/
+ *  loadDefaults，含崩溃恢复），此处返回 null 避免 FileCache 再读一遍。 */
+const noopRead = () => null;
+// agent config.json：mtime 门控，per-agent 分组（config:<aid>）便于 per-agent 监控视图。
+const loadAgentCached = (self) => fileCache.get(agentConfigPath(self), () => loadAgent(self), { policy: 'mtime', group: `config:${self}`, read: noopRead });
+// defaults.json：单文件，mtime 门控。
+const loadDefaultsCached = () => fileCache.get(resolvePaths().defaultsConfig, () => loadDefaults(), { policy: 'mtime', group: 'config', read: noopRead });
+// 关系级 preferences.json —— 走统一 FileCache（mtime 门控，带外改 + 不 reload）。
+const readPrefsCached = (file) => fileCache.get(file, (raw) => (raw === null ? null : safeParsePrefs(raw)), { policy: 'mtime', group: 'relation-prefs' });
+function safeParsePrefs(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
 export class ModelScopeError extends Error {
     code;
     constructor(code, message) {
@@ -76,11 +109,11 @@ export function determineScope(sel) {
 export function activeBaseagent(self) {
     try {
         if (self) {
-            const cfg = loadAgent(self);
+            const cfg = loadAgentCached(self);
             if (cfg?.active_baseagent)
                 return cfg.active_baseagent;
         }
-        const d = loadDefaults();
+        const d = loadDefaultsCached();
         if (d?.active_baseagent)
             return d.active_baseagent;
     }
@@ -114,17 +147,17 @@ function writeJsonAtomic(file, data) {
 export function readScope(scope, sel, ba) {
     switch (scope) {
         case 'global': {
-            const block = (loadDefaults()?.baseagents || {});
+            const block = (loadDefaultsCached()?.baseagents || {});
             const c = block[ba] || {};
             return { model: c.model, effort: c[effortField(ba)] };
         }
         case 'agent': {
-            const cfg = sel.self ? loadAgent(sel.self) : null;
+            const cfg = sel.self ? loadAgentCached(sel.self) : null;
             const c = (cfg?.baseagents || {})[ba] || {};
             return { model: c.model, effort: c[effortField(ba)] };
         }
         case 'relation': {
-            const p = readJsonSafe(relationPrefsPath(sel.self, sel.peerKey));
+            const p = readPrefsCached(relationPrefsPath(sel.self, sel.peerKey));
             return { model: p?.model, effort: p?.effort };
         }
     }