evolclaw 3.1.11 → 3.3.0

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

@@ -2,20 +2,25 @@ import path from 'path';
 import fs from 'fs';
 import os from 'os';
 import crypto from 'crypto';
-import { hasCompact } from '../../agents/claude-runner.js';
+import { hasCompact } from '../../agents/runner-types.js';
 import { IMRenderer } from './im-renderer.js';
 import { StreamIdleMonitor } from './stream-idle-monitor.js';
 import { logger } from '../../utils/logger.js';
 import { getErrorMessage, classifyError, ErrorType, ERROR_PREFIX, isInfraError, prefixErrorType, isRetryableError } from '../../utils/error-utils.js';
 import { summarizeToolInput } from '../permission.js';
 import { DEFAULT_PERMISSION_MODE } from '../../types.js';
-import { getPackageRoot, resolveRoot } from '../../paths.js';
-import { renderKitSections } from '../../agents/kit-renderer.js';
-import { renderMessageBody } from '../../agents/message-renderer.js';
-import { normalizeBaseagent } from '../../agents/baseagent-normalize.js';
+import { getPackageRoot, resolveRoot, resolvePaths } from '../../paths.js';
+import { renderKitSections } from '../../eck/kit-renderer.js';
+import { renderMessageBody } from '../../eck/message-renderer.js';
+import { consumeHints, hintsToSubMessages, composeHintFallback } from './pending-hints.js';
+import { resolveResponseDepth as computeResponseDepth } from './response-depth.js';
+import { normalizeBaseagent } from '../../agents/baseagent.js';
 import { renderActionAsText, renderCommandCardAsText } from '../interaction-router.js';
-import { formatPeerKey } from '../relation/peer-key.js';
+import { formatPeerKey } from '../relation/peer-identity.js';
 import { resolveEffectiveModel } from '../model/model-scope.js';
+import { insertUsageEvent, insertContextBreakdown, insertModelCalls } from '../stats/writer.js';
+import { normalizeUsage } from '../stats/normalizer.js';
+import { getBudgetStatus } from '../stats/budget.js';
 /** OS 信息在进程生命周期内是常量，模块加载时算一次。例: "Windows 11 Pro (win32 10.0.26200)" */
 const OS_INFO = (() => {
     let label = '';
@@ -192,6 +197,34 @@ export class MessageProcessor {
         const globalCm = agent.config?.chatmode ?? this.globalSettings.chatmode;
         return agent.getContext(channelName, chatType, globalCm);
     }
+    /**
+     * 观察者插话（v0.3）：消费当前 (对端, thread) 的待用提示，转成 owner-hint SubMessage。
+     * 一次性语义：consumeHints 回放算有效集后清该 thread（其它 thread 残留则保留，否则删文件）。
+     * 仅 aun 渠道（pending-hints 落在 sessions/aun/<self>/<对端>/）。
+     */
+    consumeOwnerHints(session, message) {
+        const channelType = session.channelType || message.channelType || session.channel;
+        if (channelType !== 'aun')
+            return [];
+        const selfAID = session.selfAID || message.selfAID;
+        if (!selfAID)
+            return [];
+        // 会话定位键：私聊=对端 AID，群聊=groupId（均为 session.channelId）。
+        const peerChannelId = session.channelId;
+        if (!peerChannelId)
+            return [];
+        try {
+            const hints = consumeHints(resolvePaths().sessionsDir, 'aun', peerChannelId, selfAID, session.threadId);
+            if (hints.length === 0)
+                return [];
+            logger.info(`[MessageProcessor] consumed ${hints.length} owner-hint(s) for ${peerChannelId} thread=${session.threadId || 'main'}`);
+            return hintsToSubMessages(hints);
+        }
+        catch (e) {
+            logger.warn(`[MessageProcessor] consumeOwnerHints failed: ${e instanceof Error ? e.message : String(e)}`);
+            return [];
+        }
+    }
     /**
      * 注册渠道适配器
      */
@@ -262,6 +295,8 @@ export class MessageProcessor {
         // 先解析会话，再优先用 session.metadata.channelKey 精确定位实例级 adapter
         // message.channel 现在存实例名（channelName），可直接用于精确路由
         const { session, absoluteProjectPath } = await this.resolveSession(message);
+        // 群聊响应深度决策（resolveSession 之后、_processMessageInternal 之前）
+        const responseDepth = await this.resolveResponseDepth(message, session);
         // thread(feishu) pending strategy: inject replyContext so first reply creates the thread
         if (message.triggerMeta?.pendingThread && message.triggerMeta?.rootMessageId) {
             const triggerId = message.triggerMeta.triggerId;
@@ -295,16 +330,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 +341,7 @@ export class MessageProcessor {
         let monitor;
         let monitorInterval;
         let rejectFn;
+        let lastIdleSec = 0;
         const resetTimer = (eventType, toolName) => {
             monitor?.recordEvent(eventType || 'unknown', toolName);
         };
@@ -329,17 +358,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 +369,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 +386,7 @@ export class MessageProcessor {
         });
         try {
             await Promise.race([
-                this._processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress),
+                this._processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, () => lastIdleSec, responseDepth),
                 timeoutPromise
             ]);
         }
@@ -412,7 +434,7 @@ export class MessageProcessor {
         return message.replyContext;
     }
     /** 自动安全模式已禁用：仅保留错误计数，不再自动切换状态 */
-    async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress) {
+    async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, getLastIdleSec, responseDepth) {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
         const channelKey = session.metadata?.channelKey || message.channel;
         const channelInfo = this.resolveChannelInfo(channelKey);
@@ -436,7 +458,7 @@ export class MessageProcessor {
         const taskId = `task-${crypto.randomUUID().replace(/-/g, '').slice(0, 10)}`;
         const chatmode = session.sessionMode ?? 'interactive';
         // 诊断日志：记录 inbound message_id 和生成的 task_id 的对应关系
-        logger.info(`[MessageProcessor] Task created: inboundMsgId=${message.messageId ?? 'none'} taskId=${taskId} sessionId=${session.id} chatmode=${chatmode}`);
+        logger.info(`[MessageProcessor] Task created: inboundMsgId=${message.messageId ?? 'none'} taskId=${taskId} sessionId=${session.id} chatmode=${chatmode}${responseDepth && responseDepth !== 'standard' ? ` depth=${responseDepth}` : ''}`);
         // 构建带 taskId/chatmode 的 ReplyContext（本次任务所有出站消息共用）
         const taskReplyContext = () => {
             const base = this.getReplyContext(message);
@@ -474,6 +496,17 @@ export class MessageProcessor {
                 agentName: agentNameForStats,
                 timestamp: Date.now()
             });
+            // ── 硬上限检查：超限直接返回提示，不调模型 ──
+            {
+                const budgetAgentAid = session.selfAID || message.selfAID || '';
+                const budgetPeerKey = formatPeerKey(message.channel, message.channelId);
+                const budgetStatus = getBudgetStatus(resolveRoot(), budgetAgentAid, budgetPeerKey);
+                if (budgetStatus.hard_blocked) {
+                    logger.warn(`[MessageProcessor] Budget hard limit reached: agent=${budgetAgentAid} peer=${budgetPeerKey} pct=${budgetStatus.pct_used.toFixed(1)}%`);
+                    adapter.send(envelope, { kind: 'status.completed', metadata: { durationMs: 0 } }).catch(() => { });
+                    return;
+                }
+            }
             const imageInfo = message.images && message.images.length > 0 ? ` [${message.images.length} image(s)]` : '';
             const modeInfo = isBackground ? ' [\u540e\u53f0]' : '';
             const e2eeInfo = message.replyContext?.metadata?.encrypted != null ? ` encrypt=${message.replyContext.metadata.encrypted}` : '';
@@ -559,6 +592,9 @@ export class MessageProcessor {
                 agentName: agentNameForStats,
                 taskId,
                 chatmode: isProactive ? 'proactive' : 'interactive',
+                flushPending: async () => {
+                    await renderer.flush(false);
+                },
                 interceptNextMessage: this.messageQueue
                     ? (sessionKey, handler) => this.messageQueue.interceptNext(sessionKey, handler)
                     : undefined,
@@ -595,7 +631,8 @@ export class MessageProcessor {
                 const currentChannelType = options?.channelType || message.channel;
                 // 提取 self 信息
                 const adapterAny = channelInfo.adapter;
-                const selfAid = typeof adapterAny._selfAid === 'function' ? adapterAny._selfAid() : undefined;
+                const adapterSelfAid = typeof adapterAny._selfAid === 'function' ? adapterAny._selfAid() : undefined;
+                const selfAid = adapterSelfAid || message.selfAID || session.selfAID || undefined;
                 const selfName = typeof adapterAny._selfName === 'function' ? adapterAny._selfName() : undefined;
                 const peerName = message.peerName || session.metadata?.peerName;
                 // 通道能力
@@ -619,6 +656,7 @@ export class MessageProcessor {
                 const peerKey = (currentChannelType && peerIdRaw)
                     ? formatPeerKey(currentChannelType, peerIdRaw)
                     : undefined;
+                const normalizedBaseagent = normalizeBaseagent(agent.name);
                 // 按 关系级 > agent级 > 全局 解析本次调用的模型/强度，作为 per-call 入参传入 runQuery。
                 // 不缓存、不绑会话——改关系级/agent级后该范围所有会话的下条消息即时生效；
                 // 多对端并发各自独立解析、各自传参，无共享状态可被污染。
@@ -638,7 +676,7 @@ export class MessageProcessor {
                 let evolclawModelOverride;
                 if (!skipEvolclawModel) {
                     try {
-                        const resolved = resolveEffectiveModel({ self: selfAid || undefined, peerKey });
+                        const resolved = resolveEffectiveModel({ self: selfAid || undefined, peerKey }, normalizedBaseagent.canonical);
                         if (resolved.model) {
                             evolclawModelOverride = { model: resolved.model, effort: resolved.effort };
                             effectiveModel = resolved.model;
@@ -649,7 +687,20 @@ export class MessageProcessor {
                     }
                     modelOverride = evolclawModelOverride;
                 }
-                const normalizedBaseagent = normalizeBaseagent(agent.name);
+                // ④ 群聊 responseDepth → effort 动态映射
+                // 仅当群聊且 evolclaw 作用域未显式指定 effort 时生效（显式配置优先）
+                if (message.chatType === 'group' && responseDepth && !(modelOverride?.effort)) {
+                    const depthEffortMap = {
+                        lightweight: 'low',
+                        standard: 'medium',
+                        deep: 'high',
+                    };
+                    const mappedEffort = depthEffortMap[responseDepth];
+                    if (mappedEffort) {
+                        modelOverride = { ...(modelOverride || {}), effort: mappedEffort };
+                        logger.info(`[MessageProcessor] Group depth→effort: ${responseDepth} → ${mappedEffort} session=${session.id}`);
+                    }
+                }
                 agentModel = (typeof agent.getModel === 'function') ? agent.getModel() : undefined;
                 // Kit renderer: 组装上下文
                 const pkgRoot = getPackageRoot();
@@ -684,11 +735,18 @@ 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,
                         // 群分发模式 / 客户端类型 / 权限模式
-                        dispatch: session.metadata?.dispatchMode || undefined,
+                        // 优先本地 session 覆盖（/dispatch 命令），fallback 到服务器 dispatch_mode
+                        dispatch: session.metadata?.dispatchMode || message.dispatchMode || undefined,
+                        responseDepth: responseDepth || undefined,
                         clientType: message.clientType || undefined,
                         permissionMode: session.metadata?.permissionMode || 'auto',
                         capabilities: capParts.length > 0 ? capParts.join('、') : undefined,
@@ -714,6 +772,8 @@ export class MessageProcessor {
                         modelFallbackActive: (fbState.fallbackActive || skipEvolclawModel) ? true : undefined,
                         modelFallbackModel: (fbState.fallbackActive || skipEvolclawModel) ? (agentModel || undefined) : undefined,
                         agentSessionId: session.agentSessionId || undefined,
+                        // 渲染模式：各类型当前激活的 modeName（从内存 config 读，渲染层据此选 manifest section）。
+                        renderModes: this.agentRegistry?.resolveByChannel(channelKey)?.config?.render ?? undefined,
                     },
                     sessionId: session.id,
                 };
@@ -721,30 +781,65 @@ export class MessageProcessor {
                 if (kitContext)
                     contextParts.push(kitContext);
                 effectiveSystemPrompt = [options?.systemPromptAppend, ...contextParts].filter(Boolean).join('\n') || undefined;
+                // ── Stats: context_breakdown 旁路采集（各段估算 token 数，字符数/4 近似） ──
+                try {
+                    const estTokens = (s) => s ? Math.ceil(s.length / 4) : 0;
+                    const cbModel = effectiveModel || agentModel || 'unknown';
+                    const cbMaxTokens = 200000; // 保守默认，后续可从 model-catalog 取
+                    const systemPromptTokens = estTokens(options?.systemPromptAppend);
+                    const personaTokens = estTokens(persona);
+                    const workingTokens = estTokens(working);
+                    const kitTokens = estTokens(kitContext);
+                    const totalEst = estTokens(effectiveSystemPrompt);
+                    insertContextBreakdown(resolveRoot(), {
+                        ts: Date.now(),
+                        agent_aid: selfAid || session.selfAID || '',
+                        session_id: session.id,
+                        turn_count: 0, // 按 ts 排序得轮次
+                        model: cbModel,
+                        max_tokens: cbMaxTokens,
+                        system_prompt: systemPromptTokens + personaTokens + workingTokens,
+                        system_tools: 0, // 工具 schema 不在此层，留 0（后续 runner 层补）
+                        mcp_tools: 0,
+                        custom_agents: 0,
+                        memory_files: kitTokens, // ECK 渲染的所有段（含 memory/skills/rules）
+                        skills: 0,
+                        messages: 0, // messages 段在 runner 层才知道
+                        free_space: Math.max(0, cbMaxTokens - totalEst),
+                        total_estimated: totalEst,
+                    });
+                }
+                catch { /* non-fatal */ }
                 // 消息渲染层：用 message manifest 逐条渲染（时间 + 群聊发送者），组装成最终正文。
                 // 单条消息构造单元素 items；批量合并的消息 message.items 已由队列填充。
                 let renderResult;
                 const hasContent = message.content.trim() || (message.items && message.items.length > 0);
                 if (hasContent) {
+                    const peerItems = message.items && message.items.length > 0
+                        ? message.items
+                        : [{
+                                peerId: message.peerId, peerName: peerName || undefined,
+                                peerType: message.peerType,
+                                sameDevice: message.sameDevice, sameNetwork: message.sameNetwork, sameEgressIp: message.sameEgressIp,
+                                content: message.content, timestamp: message.timestamp,
+                                images: message.images,
+                                mentionAids: message.mentionAids,
+                            }];
+                    // 观察者插话（v0.3）：消费 (对端, thread) 的待用提示，包成 owner-hint item 排在对端消息前。
+                    // 一次性语义：consumeOwnerHints 读取并删除（见 pending-hints.ts）。在 try 外消费，
+                    // 这样即便 renderMessageBody 抛错走 raw 兜底，也把提示原文拼进去——绝不静默丢提示。
+                    const hintItems = this.consumeOwnerHints(session, message);
+                    const renderItems = hintItems.length > 0 ? [...hintItems, ...peerItems] : peerItems;
                     try {
-                        const renderItems = message.items && message.items.length > 0
-                            ? message.items
-                            : [{
-                                    peerId: message.peerId, peerName: peerName || undefined,
-                                    peerType: message.peerType,
-                                    sameDevice: message.sameDevice, sameNetwork: message.sameNetwork, sameEgressIp: message.sameEgressIp,
-                                    content: message.content, timestamp: message.timestamp,
-                                    images: message.images,
-                                }];
                         renderResult = renderMessageBody(renderItems, kitCtx.vars, session.id);
                         if (renderResult.body.trim())
                             effectivePrompt = wrapPrompt(renderResult.body);
                         else
-                            effectivePrompt = wrapPrompt(message.content);
+                            effectivePrompt = wrapPrompt(composeHintFallback(hintItems, message.content));
                     }
                     catch (e) {
                         logger.warn(`[MessageProcessor] renderMessageBody failed, using raw content: ${e instanceof Error ? e.message : String(e)}`);
-                        effectivePrompt = wrapPrompt(message.content);
+                        effectivePrompt = wrapPrompt(composeHintFallback(hintItems, message.content));
                     }
                 }
                 // 可重试错误（403/429/5xx）指数退避重试，最多 3 次
@@ -995,7 +1090,7 @@ export class MessageProcessor {
                     adapter.send(envelope, { kind: 'status.error', metadata: { errorType: rawSubtype } }).catch(() => { });
                 }
                 if (message.triggerMeta) {
-                    this.eventBus.publish({ type: 'trigger:failed', triggerId: message.triggerMeta.triggerId, messageId: messageId, error: errorSummary });
+                    this.eventBus.publish({ type: 'trigger:failed', triggerId: message.triggerMeta.triggerId, name: message.triggerMeta.triggerName ?? '', messageId: messageId, error: errorSummary, targetChannel: message.channel, targetChannelId: message.channelId, fireTime: message.triggerMeta.fireTime ?? 0, phase: 'execute' });
                 }
                 this.eventBus.publish({
                     type: 'task:error',
@@ -1026,20 +1121,131 @@ export class MessageProcessor {
             else {
                 // 真正的成功
                 const durationMs = Date.now() - startTime;
+                // ── Stats: 写入 usage_events（在 status.completed 之前，以便带上 cost） ──
+                let statsCostUsd = 0;
+                let statsCostCny = 0;
+                let statsCacheHitRate = 0;
+                if (streamResult.tokenUsage) {
+                    try {
+                        const statsAgentAid = session.selfAID || message.selfAID || '';
+                        const statsPeerKey = formatPeerKey(message.channel, message.channelId);
+                        const statsModel = streamResult.contextUsage?.model || 'unknown';
+                        const ctxPct = streamResult.contextUsage?.percentage;
+                        const event = normalizeUsage(streamResult.tokenUsage, {
+                            ts: Date.now(),
+                            agent_aid: statsAgentAid,
+                            peer_key: statsPeerKey,
+                            peer_type: session.chatType || undefined,
+                            session_id: session.id,
+                            model: statsModel,
+                            turns: streamResult.numTurns,
+                            duration_ms: durationMs,
+                            context_window_pct: ctxPct,
+                        });
+                        insertUsageEvent(resolveRoot(), event);
+                        // 逐次大模型调用明细落库（model_calls 表）
+                        if (streamResult.modelCalls?.length) {
+                            const mcRows = streamResult.modelCalls.map(mc => ({
+                                ts: event.ts,
+                                task_id: taskId,
+                                session_id: session.id,
+                                agent_session_id: session.agentSessionId ?? undefined,
+                                agent_aid: statsAgentAid,
+                                peer_key: statsPeerKey,
+                                call_index: mc.call_index,
+                                model: mc.model || statsModel,
+                                request_id: mc.request_id,
+                                message_id: mc.message_id,
+                                input_tokens: mc.tokenUsage.input_tokens ?? 0,
+                                output_tokens: mc.tokenUsage.output_tokens ?? 0,
+                                cache_creation_tokens: mc.tokenUsage.cache_creation_input_tokens ?? 0,
+                                cache_read_tokens: mc.tokenUsage.cache_read_input_tokens ?? 0,
+                                degraded: mc.degraded ? 1 : 0,
+                            }));
+                            insertModelCalls(resolveRoot(), mcRows);
+                        }
+                        // 计算费用（用于合入 status.completed）
+                        const { calcCost } = await import('../stats/billing.js');
+                        const cost = calcCost(resolveRoot(), { ...event, ts: event.ts, model: event.model, billing_fn: event.billing_fn });
+                        statsCostUsd = cost.usd ?? 0;
+                        statsCostCny = cost.cny ?? 0;
+                        const totalIn = event.input_tokens + event.cache_read_tokens;
+                        statsCacheHitRate = totalIn > 0 ? Math.round((event.cache_read_tokens / totalIn) * 100) / 100 : 0;
+                    }
+                    catch (e) {
+                        logger.debug(`[MessageProcessor] Stats write failed (non-fatal): ${e}`);
+                    }
+                }
+                // 会话累计 + model spec（用于 status.completed 统计细目）
+                let sessionStats;
+                let modelSpec;
+                try {
+                    const { openReadonlyDb, getDbPath } = await import('../stats/db.js');
+                    const { resolveModelSpec } = await import('../stats/billing.js');
+                    const statsModel = streamResult.contextUsage?.model || 'unknown';
+                    modelSpec = resolveModelSpec(resolveRoot(), statsModel);
+                    const rdb = openReadonlyDb(getDbPath(resolveRoot()));
+                    if (rdb) {
+                        try {
+                            const row = rdb.prepare(`SELECT COALESCE(SUM(input_tokens),0) AS input_tokens, COALESCE(SUM(output_tokens),0) AS output_tokens,
+                        COALESCE(SUM(cache_read_tokens),0) AS cache_read_tokens, COALESCE(SUM(cache_creation_tokens),0) AS cache_creation_tokens,
+                        COUNT(*) AS call_count FROM usage_events WHERE session_id = ?`).get(session.id);
+                            if (row) {
+                                // 逐行算费用太贵，用近似：最后一轮的 cost 乘以次数不准，所以这里用累加 token 近似
+                                sessionStats = {
+                                    input_tokens: row.input_tokens,
+                                    output_tokens: row.output_tokens,
+                                    cache_read_tokens: row.cache_read_tokens,
+                                    cache_creation_tokens: row.cache_creation_tokens,
+                                    cost_usd: 0, cost_cny: 0,
+                                    call_count: row.call_count,
+                                };
+                                // 快速费用估算：用会话所有行逐行算
+                                const rows = rdb.prepare(`SELECT * FROM usage_events WHERE session_id = ?`).all(session.id);
+                                const { calcCost: cc } = await import('../stats/billing.js');
+                                for (const r of rows) {
+                                    const c = cc(resolveRoot(), r);
+                                    sessionStats.cost_usd += c.usd ?? 0;
+                                    sessionStats.cost_cny += c.cny ?? 0;
+                                }
+                            }
+                        }
+                        finally {
+                            rdb.close();
+                        }
+                    }
+                }
+                catch { /* non-fatal */ }
                 if (message.source !== 'trigger') {
                     if (interruptReason) {
                         adapter.send(envelope, { kind: 'status.interrupted', metadata: { reason: interruptReason } }).catch(() => { });
                     }
                     else {
-                        adapter.send(envelope, { kind: 'status.completed', metadata: { durationMs, ttftMs: streamResult.ttftMs, numTurns: streamResult.numTurns, tokenUsage: streamResult.tokenUsage, contextUsage: streamResult.contextUsage } }).catch(() => { });
+                        adapter.send(envelope, { kind: 'status.completed', metadata: {
+                                durationMs,
+                                ttftMs: streamResult.ttftMs,
+                                numTurns: streamResult.numTurns,
+                                tokenUsage: streamResult.tokenUsage,
+                                contextUsage: streamResult.contextUsage,
+                                lastModelCall: streamResult.lastModelCall,
+                                cost_usd: statsCostUsd,
+                                cost_cny: statsCostCny,
+                                cache_hit_rate: statsCacheHitRate,
+                                model_spec: modelSpec,
+                                session_total: sessionStats,
+                                queue: {
+                                    pending: this.messageQueue?.getQueueLength(session.id) ?? 0,
+                                    processing: this.messageQueue?.isProcessing(session.id) ? 1 : 0,
+                                },
+                            } }).catch(() => { });
                     }
                 }
                 if (message.triggerMeta) {
                     if (interruptReason) {
-                        this.eventBus.publish({ type: 'trigger:skipped', triggerId: message.triggerMeta.triggerId, reason: 'interrupted' });
+                        this.eventBus.publish({ type: 'trigger:skipped', triggerId: message.triggerMeta.triggerId, name: message.triggerMeta.triggerName ?? '', reason: 'interrupted', targetChannel: message.channel, targetChannelId: message.channelId });
                     }
                     else {
-                        this.eventBus.publish({ type: 'trigger:completed', triggerId: message.triggerMeta.triggerId, messageId: messageId, durationMs });
+                        this.eventBus.publish({ type: 'trigger:completed', triggerId: message.triggerMeta.triggerId, name: message.triggerMeta.triggerName ?? '', messageId: messageId, durationMs, targetChannel: message.channel, targetChannelId: message.channelId, fireTime: message.triggerMeta.fireTime ?? 0 });
                     }
                 }
                 await this.sessionManager.recordSuccess(session.id);
@@ -1100,7 +1306,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 +1339,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 +1367,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 聚合完整
             }
         }
@@ -1168,11 +1379,24 @@ export class MessageProcessor {
      * 解析会话和项目路径
      */
     async resolveSession(message) {
-        // 话题会话创建时写入 replyContext（threadId 路由）；主会话不写（避免群聊覆盖）
-        const metadata = (message.threadId && message.replyContext)
-            ? { replyContext: message.replyContext }
+        // 话题会话创建时写入创建者和 replyContext（threadId 路由）；主会话不写（避免群聊覆盖）
+        const metadata = message.threadId
+            ? {
+                ...(message.replyContext ? { replyContext: message.replyContext } : {}),
+                ...(message.peerId ? { peerId: message.peerId } : {}),
+                ...(message.peerName ? { peerName: message.peerName } : {}),
+            }
             : undefined;
         const projectPath = this.agentRegistry?.resolveByChannel(message.channel)?.projectPath || process.cwd();
+        if (message.chatType === 'group' && message.threadId && message.source !== 'trigger' && message.source !== 'owner-inject') {
+            const existing = await this.sessionManager.getThreadSession(message.channel, message.channelId, message.threadId);
+            if (!existing) {
+                const role = this.sessionManager.resolveIdentity(message.channel, message.peerId).role;
+                if (role !== 'owner' && role !== 'admin') {
+                    throw new Error('群聊中无权限创建话题');
+                }
+            }
+        }
         // current strategy: resume bound session, make it active so output is not suppressed
         if (message.triggerMeta?.boundSessionId) {
             const bound = await this.sessionManager.getSessionById(message.triggerMeta.boundSessionId);
@@ -1189,13 +1413,31 @@ export class MessageProcessor {
                 logger.warn(`[MessageProcessor] Bound session ${message.triggerMeta.boundSessionId} not found, falling back to latest`);
             }
         }
-        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, projectPath, message.threadId, metadata, undefined, message.peerId, message.chatType, undefined, message.selfAID, message.channelType, message.peerType);
+        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, projectPath, message.threadId, metadata, message.topicName, message.peerId, message.chatType, undefined, message.selfAID, message.channelType, message.peerType);
         // 兜底纠正1：群聊强制 proactive
         if (message.chatType === 'group' && session.sessionMode !== 'proactive') {
             logger.info(`[MessageProcessor] group proactive upgrade: sessionId=${session.id} ${session.sessionMode} -> proactive`);
             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 });
+            }
+        }
+        // 群聊分发模式同步：aun.ts 从服务器信封解析的 dispatchMode 注入到 message，
+        // 此处写入 session.metadata，确保 ECK 上下文的 venue fragment 正确渲染 dispatch 变量。
+        // 仅当 message.dispatchMode 有值且与 session 记录不一致时更新。
+        if (message.chatType === 'group' && message.dispatchMode && session.metadata?.dispatchMode !== message.dispatchMode) {
+            logger.info(`[MessageProcessor] dispatchMode sync: sessionId=${session.id} ${session.metadata?.dispatchMode ?? 'none'} -> ${message.dispatchMode}`);
+            session.metadata = { ...(session.metadata || {}), dispatchMode: message.dispatchMode };
+            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') {
@@ -1216,6 +1458,32 @@ export class MessageProcessor {
             : path.resolve(process.cwd(), session.projectPath);
         return { session, absoluteProjectPath };
     }
+    /**
+     * 群聊响应深度决策。根据 dispatch 模式、消息特征、话题轮次综合判断。
+     * 返回 per-message 的瞬时深度枚举，不持久化到 session.metadata。
+     * 同时更新 session.metadata 中的 topicRounds/lastTopicHash（话题追踪状态）。
+     */
+    async resolveResponseDepth(message, session) {
+        const result = computeResponseDepth({
+            chatType: message.chatType,
+            content: message.content,
+            selfAid: session.selfAID || message.selfAID,
+            mentionAids: message.mentionAids,
+            dispatch: session.metadata?.dispatchMode || message.dispatchMode,
+            topicRounds: session.metadata?.topicRounds ?? 0,
+            lastTopicHash: session.metadata?.lastTopicHash,
+        });
+        // 持久化话题追踪状态（仅群聊时有意义）
+        if (message.chatType === 'group') {
+            session.metadata = {
+                ...(session.metadata || {}),
+                topicRounds: result.topicRounds,
+                lastTopicHash: result.topicHash,
+            };
+            await this.sessionManager.updateSession(session.id, { metadata: session.metadata });
+        }
+        return result.depth;
+    }
     /**
      * 处理标准事件流（AgentEvent）
      *
@@ -1392,7 +1660,7 @@ export class MessageProcessor {
                             logger.info(`[MessageProcessor] Auto-filled session name: ${event.sessionTitle}`);
                         }
                         // 记录完成状态 + 最后一轮回复文本（后续 complete 覆盖前序）
-                        completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, ttftMs: event.ttftMs, tokenUsage: event.tokenUsage, contextUsage: event.contextUsage };
+                        completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, ttftMs: event.ttftMs, tokenUsage: event.tokenUsage, contextUsage: event.contextUsage, lastModelCall: event.lastModelCall, modelCalls: event.modelCalls };
                         // thought jsonl 写入已下沉到 aun.ts:sendThought 成功后，
                         // 由那里按 LLM 输出的每个 text item 单独写一条，此处不再写。
                         // 失败且无前置错误输出：显示 errors 摘要
@@ -1448,7 +1716,7 @@ export class MessageProcessor {
                     logger.info(`[MessageProcessor] Auto-filled session name: ${event.sessionTitle}`);
                 }
                 // 记录完成状态
-                completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, ttftMs: event.ttftMs, tokenUsage: event.tokenUsage, contextUsage: event.contextUsage };
+                completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, ttftMs: event.ttftMs, tokenUsage: event.tokenUsage, contextUsage: event.contextUsage, lastModelCall: event.lastModelCall };
                 if (event.subtype === 'success') {
                     this.messageCache.addEvent(session.id, {
                         type: 'completed',