evolclaw 3.2.0 → 3.4.0

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

@@ -2,20 +2,24 @@ 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, autoCompactWindowForModel, isClaudeContextUsageModel } 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 { getErrorMessage, classifyError, ErrorType, ERROR_PREFIX, isInfraError, prefixErrorType, isRetryableError, isContextTooLongText } 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 { 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 = '';
@@ -61,6 +65,11 @@ function getContextCompactFailedHint(agent) {
 function canCompactAgent(agent) {
     return hasCompact(agent) && agent.capabilities?.compact !== false;
 }
+function autoCompactTokensFromMaxTokens(maxTokens) {
+    if (!maxTokens || maxTokens <= 0)
+        return undefined;
+    return maxTokens >= 1000000 ? maxTokens - 100000 : maxTokens;
+}
 /**
  * 构造 OutboundEnvelope —— 出站三件套的信封部分。
  *
@@ -182,6 +191,12 @@ export class MessageProcessor {
     setAgentRegistry(registry) {
         this.agentRegistry = registry;
     }
+    /** 更新 EvolAgent.lastActivity —— 每次发出 status.* 事件（含 progress）时调用 */
+    touchAgentActivity(channelKey) {
+        const owning = this.agentRegistry?.resolveByChannel(channelKey);
+        if (owning)
+            owning.lastActivity = Date.now();
+    }
     getAgentContext(channelName, chatType) {
         if (!this.agentRegistry)
             return null;
@@ -192,6 +207,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 [];
+        }
+    }
     /**
      * 注册渠道适配器
      */
@@ -203,6 +246,25 @@ export class MessageProcessor {
             this.channelTypeMap.set(type, adapter.channelName);
         }
     }
+    /**
+     * 注销渠道适配器（热重载断开渠道时调用，避免遗留死实例）。
+     * channelTypeMap 若指向被删实例，重定向到同类型的另一存活实例（无则删除映射）。
+     */
+    unregisterChannel(channelName) {
+        const info = this.channels.get(channelName);
+        this.channels.delete(channelName);
+        const type = info?.options?.channelType || channelName;
+        if (this.channelTypeMap.get(type) === channelName) {
+            this.channelTypeMap.delete(type);
+            // 重定向到同类型的另一存活实例（保持按类型名路由可用）
+            for (const [name, ci] of this.channels) {
+                if ((ci.options?.channelType || name) === type) {
+                    this.channelTypeMap.set(type, name);
+                    break;
+                }
+            }
+        }
+    }
     /**
      * 获取渠道适配器（支持实例名和 channelType）
      */
@@ -461,6 +523,18 @@ 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)}%`);
+                    this.touchAgentActivity(channelKey);
+                    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}` : '';
@@ -476,8 +550,10 @@ export class MessageProcessor {
             this.eventBus.publish({ type: 'task:started', sessionId: session.id, agentName: agentNameForStats, encrypt: taskEncrypt, chatmode: session.sessionMode || 'interactive' });
             // 触发器消息不发 processing status（无需通知用户）
             if (message.source !== 'trigger') {
+                this.touchAgentActivity(channelKey);
                 adapter.send(envelope, { kind: 'status.started' }).catch(() => { });
             }
+            await this.runPendingAutoCompactAtTaskStart(session, agent, absoluteProjectPath, adapter, envelope);
             logger.message({
                 msgId: messageId,
                 sessionId: session.id,
@@ -519,6 +595,8 @@ export class MessageProcessor {
                         opts.title = '\u2705 \u6700\u7ec8\u56de\u590d:';
                     }
                     opts.metadata = { ...(opts.metadata ?? {}), taskId, chatmode };
+                    if (payload.kind.startsWith('status.'))
+                        this.touchAgentActivity(channelKey);
                     const enrichedEnvelope = { ...envelope, replyContext: opts };
                     await adapter.send(enrichedEnvelope, payload);
                 },
@@ -546,6 +624,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,
@@ -582,7 +663,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;
                 // 通道能力
@@ -606,6 +688,7 @@ export class MessageProcessor {
                 const peerKey = (currentChannelType && peerIdRaw)
                     ? formatPeerKey(currentChannelType, peerIdRaw)
                     : undefined;
+                const normalizedBaseagent = normalizeBaseagent(agent.name);
                 // 按 关系级 > agent级 > 全局 解析本次调用的模型/强度，作为 per-call 入参传入 runQuery。
                 // 不缓存、不绑会话——改关系级/agent级后该范围所有会话的下条消息即时生效；
                 // 多对端并发各自独立解析、各自传参，无共享状态可被污染。
@@ -625,7 +708,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;
@@ -636,7 +719,6 @@ export class MessageProcessor {
                     }
                     modelOverride = evolclawModelOverride;
                 }
-                const normalizedBaseagent = normalizeBaseagent(agent.name);
                 agentModel = (typeof agent.getModel === 'function') ? agent.getModel() : undefined;
                 // Kit renderer: 组装上下文
                 const pkgRoot = getPackageRoot();
@@ -680,7 +762,8 @@ export class MessageProcessor {
                         channel: currentChannelType || null,
                         venueUid: undefined,
                         // 群分发模式 / 客户端类型 / 权限模式
-                        dispatch: session.metadata?.dispatchMode || undefined,
+                        // 优先本地 session 覆盖（/dispatch 命令），fallback 到服务器 dispatch_mode 缓存
+                        dispatch: (session.metadata?.dispatchModeOverride ?? session.metadata?.dispatchMode ?? message.dispatchMode) || undefined,
                         clientType: message.clientType || undefined,
                         permissionMode: session.metadata?.permissionMode || 'auto',
                         capabilities: capParts.length > 0 ? capParts.join('、') : undefined,
@@ -706,6 +789,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,
                 };
@@ -713,35 +798,73 @@ 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,
-                                    mentionAids: message.mentionAids,
-                                }];
                         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 次
                 const MAX_RETRIES = 3;
+                // Runner 开始执行前：将 Pin 升级为 CheckMark（表示"正在处理"）
+                if (message.messageId && message.source !== 'trigger') {
+                    adapter.promoteAck?.(message.messageId).catch(() => { });
+                }
                 for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
                     let streamRegistered = false;
                     try {
@@ -810,12 +933,12 @@ export class MessageProcessor {
             }
             // prompt_too_long：SDK 以 complete 事件（非异常）返回，需在此处触发 compact
             // 检测条件：terminalReason 明确为 prompt_too_long，或文本/errors 包含相关错误文本
-            const contextTooLongPattern = /prompt is too long|input is too long|上下文过长/i;
-            const errorsText = streamResult.errors?.join(' ') || '';
-            const isPromptTooLong = streamResult.isError && session.agentSessionId && canCompactAgent(agent) && (streamResult.terminalReason === 'prompt_too_long' ||
-                contextTooLongPattern.test(streamResult.lastReplyText) ||
-                contextTooLongPattern.test(errorsText) ||
-                contextTooLongPattern.test(streamResult.fullText));
+            const streamHitContextLimit = (sr) => sr.terminalReason === 'prompt_too_long' ||
+                isContextTooLongText(sr.lastReplyText) ||
+                isContextTooLongText(sr.errors?.join(' ') || '') ||
+                isContextTooLongText(sr.fullText);
+            const isPromptTooLong = streamResult.isError && !!session.agentSessionId && canCompactAgent(agent)
+                && streamHitContextLimit(streamResult);
             if (isPromptTooLong) {
                 renderer.addNotice('上下文过长，正在压缩会话...', 'warn', 'compact-trigger', true);
                 await renderer.flush();
@@ -826,11 +949,7 @@ export class MessageProcessor {
                     agent.registerStream(streamKey, retryStream);
                     streamResult = await this.processEventStream(retryStream, session, agent, renderer, resetTimer, shouldSuppress);
                     // 重试后仍然 prompt_too_long：清理 renderer 中可能混入的错误文本，显示友好提示
-                    const retryErrorsText = streamResult.errors?.join(' ') || '';
-                    const retryStillTooLong = streamResult.isError && (streamResult.terminalReason === 'prompt_too_long' ||
-                        contextTooLongPattern.test(streamResult.lastReplyText) ||
-                        contextTooLongPattern.test(retryErrorsText) ||
-                        contextTooLongPattern.test(streamResult.fullText));
+                    const retryStillTooLong = streamResult.isError && streamHitContextLimit(streamResult);
                     if (retryStillTooLong) {
                         renderer.addNotice(getContextTooLongHint(agent), 'warn', 'context-too-long', true);
                     }
@@ -839,10 +958,7 @@ export class MessageProcessor {
                     throw new Error('CONTEXT_COMPACT_FAILED');
                 }
             }
-            else if (streamResult.isError && !isPromptTooLong && (streamResult.terminalReason === 'prompt_too_long' ||
-                contextTooLongPattern.test(streamResult.lastReplyText) ||
-                contextTooLongPattern.test(errorsText) ||
-                contextTooLongPattern.test(streamResult.fullText))) {
+            else if (streamResult.isError && streamHitContextLimit(streamResult)) {
                 // 上下文过长但无法 auto-compact（无 session ID 或 agent 不支持），显示友好提示
                 renderer.addNotice(getContextTooLongHint(agent), 'warn', 'context-too-long', true);
             }
@@ -971,12 +1087,6 @@ export class MessageProcessor {
                 // Flush 剩余内容（文件标记已在 flush 时自动移除）
                 await renderer.flush(true);
             }
-            // 更新 EvolAgent.lastActivity
-            if (this.agentRegistry) {
-                const owningAgent = this.agentRegistry.resolveByChannel(channelKey);
-                if (owningAgent)
-                    owningAgent.lastActivity = Date.now();
-            }
             // 注意：不在此处清除 interruptedSessions，由下一条消息的 prompt 包装逻辑消费
             const interruptReason = this.interruptedSessions.get(session.id);
             if (streamResult.isError) {
@@ -984,55 +1094,193 @@ export class MessageProcessor {
                 const errorSummary = streamResult.errors?.join('; ') || '任务执行失败';
                 const rawSubtype = streamResult.subtype || 'agent_error';
                 const errorType = prefixErrorType(ERROR_PREFIX.AGENT, rawSubtype);
-                if (message.source !== 'trigger') {
+                // 用户主动打断（新消息/​/stop/​撤回）会让 SDK 流在工具调用中途被掐断，
+                // 末尾 result message 形状异常并被标记为 error（含 SDK 内部 ede_diagnostic 串）。
+                // 这不是真正的失败，不应把诊断串暴露给用户，也不计入错误统计。
+                const isUserInterrupt = interruptReason === 'new_message' || interruptReason === 'stop' || interruptReason === 'recalled';
+                if (message.source !== 'trigger' && !isUserInterrupt) {
+                    await adapter.send(envelope, { kind: 'result.error', text: errorSummary, reason: rawSubtype }).catch(() => { });
                     adapter.send(envelope, { kind: 'status.error', metadata: { errorType: rawSubtype } }).catch(() => { });
+                    this.touchAgentActivity(channelKey);
                 }
-                if (message.triggerMeta) {
-                    this.eventBus.publish({ type: 'trigger:failed', triggerId: message.triggerMeta.triggerId, messageId: messageId, error: errorSummary });
+                if (isUserInterrupt) {
+                    // 用户打断：打断本身已由 message-queue 发过 task:interrupted 事件，
+                    // 这里不再补发 task:error（否则同一次打断被记两遍且错误归类为 error）。
+                    // 仅记 info 日志收尾。注意：task:interrupted 已填充 interruptedSessions，
+                    // stats 侧已据此收尾任务生命周期，无需在此重复发事件。
+                    logger.info(`[${message.channel}] Stream result error suppressed (user interrupt: ${interruptReason}): ${errorSummary}`);
+                    logger.message({
+                        msgId: messageId,
+                        sessionId: session.id,
+                        dir: 'inbound',
+                        status: 'interrupted',
+                        error: errorSummary,
+                        terminalReason: streamResult.terminalReason
+                    });
                 }
-                this.eventBus.publish({
-                    type: 'task:error',
-                    sessionId: session.id,
-                    error: errorSummary,
-                    errorType,
-                    agentName: agentNameForStats,
-                    terminalReason: streamResult.terminalReason
-                });
-                // 系统级 subtype 仍累计错误计数，供 /status 诊断使用
-                if (isInfraError(rawSubtype, streamResult.terminalReason)) {
-                    const chatType = message.chatType || 'private';
-                    const identityRole = session.identity?.role || 'anonymous';
-                    const { policy } = channelInfo;
-                    if (policy.accumulateErrors(chatType, identityRole)) {
-                        await this.sessionManager.recordError(session.id, errorType, errorSummary);
+                else {
+                    if (message.triggerMeta) {
+                        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',
+                        sessionId: session.id,
+                        error: errorSummary,
+                        errorType,
+                        agentName: agentNameForStats,
+                        terminalReason: streamResult.terminalReason
+                    });
+                    // 系统级 subtype 仍累计错误计数，供 /status 诊断使用
+                    if (isInfraError(rawSubtype, streamResult.terminalReason)) {
+                        const chatType = message.chatType || 'private';
+                        const identityRole = session.identity?.role || 'anonymous';
+                        const { policy } = channelInfo;
+                        if (policy.accumulateErrors(chatType, identityRole)) {
+                            await this.sessionManager.recordError(session.id, errorType, errorSummary);
+                        }
                     }
+                    logger.message({
+                        msgId: messageId,
+                        sessionId: session.id,
+                        dir: 'inbound',
+                        status: 'failed',
+                        error: errorSummary,
+                        terminalReason: streamResult.terminalReason
+                    });
                 }
-                logger.message({
-                    msgId: messageId,
-                    sessionId: session.id,
-                    dir: 'inbound',
-                    status: 'failed',
-                    error: errorSummary,
-                    terminalReason: streamResult.terminalReason
-                });
             }
             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,
+                                context_tokens: mc.contextUsage?.totalTokens,
+                                max_tokens: mc.contextUsage?.maxTokens,
+                                auto_compact_tokens: mc.contextUsage?.autoCompactTokens,
+                                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') {
+                    this.touchAgentActivity(channelKey);
                     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);
@@ -1098,6 +1346,7 @@ export class MessageProcessor {
                         ? { kind: 'status.interrupted', metadata: { reason: 'stream_error' } }
                         : { kind: 'status.error' };
                 adapter.send(envelope, statusPayload).catch(() => { });
+                this.touchAgentActivity(channelKey);
             }
             // 用户主动中断时降级日志；其余仍按 error 记录
             if (isUserInterrupt) {
@@ -1108,19 +1357,25 @@ export class MessageProcessor {
             }
             const errorMsg = error instanceof Error ? error.message : String(error);
             const errorType = prefixErrorType(ERROR_PREFIX.INFRA, errType);
-            this.eventBus.publish({
-                type: 'task:error',
-                sessionId: session.id,
-                error: errorMsg,
-                errorType,
-                agentName: agentNameForStats,
-            });
+            // 用户主动打断：流被掐断抛出的异常不是真正的失败。打断发生时 source
+            // （message-queue / slash-handler）已发过 task:interrupted（它填充了
+            // interruptedSessions，isUserInterrupt 才会为真），stats 侧已据此收尾任务。
+            // 此处不再发任何事件——发 task:error 会误归类，重发 task:interrupted 会重复记账。
+            if (!isUserInterrupt) {
+                this.eventBus.publish({
+                    type: 'task:error',
+                    sessionId: session.id,
+                    error: errorMsg,
+                    errorType,
+                    agentName: agentNameForStats,
+                });
+            }
             // 记录处理失败
             logger.message({
                 msgId: messageId,
                 sessionId: session.id,
                 dir: 'inbound',
-                status: 'failed',
+                status: isUserInterrupt ? 'interrupted' : 'failed',
                 error: error instanceof Error ? error.message : String(error)
             });
             if (error instanceof Error && !isUserInterrupt) {
@@ -1154,23 +1409,98 @@ export class MessageProcessor {
                     ...(sendOpts ?? {}),
                     metadata: { ...(sendOpts?.metadata ?? {}), taskId, chatmode },
                 };
-                const errorPayload = isTimeout
-                    ? { kind: 'result.error', text: userMessage, reason: 'timeout' }
-                    : { kind: 'result.text', text: userMessage, isFinal: true };
+                const errorPayload = {
+                    kind: 'result.error',
+                    text: userMessage,
+                    reason: isTimeout ? 'timeout' : errType,
+                };
                 await adapter.send({ ...envelope, replyContext: sendOpts }, errorPayload);
                 // Proactive 可观测：catch 块的基础设施错误也透传为 thought，保证按 task_id 聚合完整
             }
         }
     }
+    async runPendingAutoCompactAtTaskStart(session, agent, absoluteProjectPath, adapter, envelope) {
+        if (!session.agentSessionId || !canCompactAgent(agent))
+            return;
+        const ctx = await this.readLastModelCallContextUsage(session.id, session.agentSessionId);
+        if (!ctx || ctx.totalTokens < ctx.autoCompactTokens)
+            return;
+        logger.info(`[MessageProcessor] Auto compact at task.start: session=${session.id} totalTokens=${ctx.totalTokens} autoCompactTokens=${ctx.autoCompactTokens}`);
+        await adapter.send(envelope, { kind: 'system.notice', text: '上下文接近上限，正在压缩会话...', subtype: 'auto-compact-start' }).catch(() => { });
+        try {
+            const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
+            if (compacted) {
+                await adapter.send(envelope, { kind: 'system.notice', text: '✅ 上下文压缩完成，继续处理...', subtype: 'auto-compact-complete' }).catch(() => { });
+            }
+            else {
+                logger.warn(`[MessageProcessor] Auto compact at task.start returned false (session=${session.id})`);
+            }
+        }
+        catch (err) {
+            logger.warn(`[MessageProcessor] Auto compact at task.start failed (non-fatal):`, err);
+        }
+    }
+    async readLastModelCallContextUsage(sessionId, agentSessionId) {
+        try {
+            const { openReadonlyDb, getDbPath } = await import('../stats/db.js');
+            const rdb = openReadonlyDb(getDbPath(resolveRoot()));
+            if (!rdb)
+                return undefined;
+            try {
+                const row = rdb.prepare(`SELECT model, input_tokens, cache_creation_tokens, cache_read_tokens,
+                  context_tokens, max_tokens, auto_compact_tokens
+             FROM model_calls
+            WHERE session_id = ?
+              AND agent_session_id = ?
+            ORDER BY ts DESC, call_index DESC
+            LIMIT 1`).get(sessionId, agentSessionId);
+                if (!row)
+                    return undefined;
+                const model = row.model || '';
+                const recordedTotalTokens = row.context_tokens ?? undefined;
+                let totalTokens;
+                if (recordedTotalTokens && recordedTotalTokens > 0) {
+                    totalTokens = recordedTotalTokens;
+                }
+                else if (isClaudeContextUsageModel(model)) {
+                    totalTokens = (row.input_tokens ?? 0) + (row.cache_creation_tokens ?? 0) + (row.cache_read_tokens ?? 0);
+                }
+                else {
+                    totalTokens = row.input_tokens ?? 0;
+                }
+                if (totalTokens <= 0)
+                    return undefined;
+                const recordedAutoCompactTokens = row.auto_compact_tokens ?? undefined;
+                const inferredAutoCompactTokens = autoCompactTokensFromMaxTokens(row.max_tokens ?? undefined);
+                const autoCompactTokens = recordedAutoCompactTokens && recordedAutoCompactTokens > 0
+                    ? recordedAutoCompactTokens
+                    : inferredAutoCompactTokens ?? autoCompactWindowForModel(model);
+                return { totalTokens, autoCompactTokens };
+            }
+            finally {
+                rdb.close();
+            }
+        }
+        catch (err) {
+            logger.debug(`[MessageProcessor] Failed to read last model call context usage: ${err}`);
+            return undefined;
+        }
+    }
     /**
      * 解析会话和项目路径
      */
     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();
+        // 话题创建权限守卫已统一移至 MessageBridge.canCreateThreadSession（enqueue 前拦截），
+        // 此处不再重复检查——bridge 层拒绝后消息根本不会到达 processMessage。
         // 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);
@@ -1187,7 +1517,7 @@ 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`);
@@ -1204,6 +1534,14 @@ export class MessageProcessor {
                 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') {
@@ -1278,6 +1616,7 @@ export class MessageProcessor {
                 // session_id 已在 AgentRunner.transformStream 中处理，此处仅记录
                 if (event.type === 'session_id') {
                     logger.debug(`[MessageProcessor] Session ID updated: ${event.sessionId} for session: ${session.id}`);
+                    session.agentSessionId = event.sessionId;
                     continue;
                 }
                 // session 状态变更（idle/running/requires_action）
@@ -1359,7 +1698,6 @@ export class MessageProcessor {
                             sessionId: session.id,
                             toolName: event.name,
                             isError: event.isError,
-                            content: event.result,
                             agentName: agentNameForStats,
                             timestamp: Date.now()
                         });
@@ -1382,7 +1720,7 @@ export class MessageProcessor {
                         // 记录错误文本到 lastReplyText，供后续 isPromptTooLong 检测
                         lastReplyText += event.error || '';
                         // 上下文过长的错误不在此处输出 notice，留给外层 isPromptTooLong 触发 auto-compact
-                        const isContextError = /prompt is too long|input is too long|上下文过长/i.test(event.error || '');
+                        const isContextError = isContextTooLongText(event.error || '');
                         if (!isContextError && !hasErrorResult && !shouldSuppress()) {
                             hasErrorResult = true;
                             renderer.addNotice(`${event.error}`, 'warn', 'runtime-error', true);
@@ -1400,7 +1738,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 摘要
@@ -1409,8 +1747,8 @@ export class MessageProcessor {
                         const interruptReason = this.interruptedSessions.get(session.id);
                         const isUserInterrupt = interruptReason === 'new_message' || interruptReason === 'stop' || interruptReason === 'recalled';
                         const isContextTooLong = event.terminalReason === 'prompt_too_long'
-                            || /prompt is too long|input is too long|上下文过长/i.test(event.errors?.join(' ') || '')
-                            || /prompt is too long|input is too long|上下文过长/i.test(lastReplyText);
+                            || isContextTooLongText(event.errors?.join(' ') || '')
+                            || isContextTooLongText(lastReplyText);
                         if (event.isError && !hasErrorResult && !shouldSuppress() && !isUserInterrupt && !isContextTooLong) {
                             const errorSummary = event.errors?.join('; ') || '任务执行失败';
                             // 使用 terminalReason 提供更友好的错误提示（不带 emoji，由 formatter 统一加）
@@ -1456,7 +1794,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',