evolclaw 3.3.0 → 3.4.0

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

@@ -2,18 +2,17 @@ import path from 'path';
 import fs from 'fs';
 import os from 'os';
 import crypto from 'crypto';
-import { hasCompact } from '../../agents/runner-types.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, 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-identity.js';
@@ -66,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 —— 出站三件套的信封部分。
  *
@@ -187,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;
@@ -236,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）
      */
@@ -295,8 +324,6 @@ 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;
@@ -386,7 +413,7 @@ export class MessageProcessor {
         });
         try {
             await Promise.race([
-                this._processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, () => lastIdleSec, responseDepth),
+                this._processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, () => lastIdleSec),
                 timeoutPromise
             ]);
         }
@@ -434,7 +461,7 @@ export class MessageProcessor {
         return message.replyContext;
     }
     /** 自动安全模式已禁用：仅保留错误计数，不再自动切换状态 */
-    async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, getLastIdleSec, responseDepth) {
+    async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, getLastIdleSec) {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
         const channelKey = session.metadata?.channelKey || message.channel;
         const channelInfo = this.resolveChannelInfo(channelKey);
@@ -458,7 +485,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}${responseDepth && responseDepth !== 'standard' ? ` depth=${responseDepth}` : ''}`);
+        logger.info(`[MessageProcessor] Task created: inboundMsgId=${message.messageId ?? 'none'} taskId=${taskId} sessionId=${session.id} chatmode=${chatmode}`);
         // 构建带 taskId/chatmode 的 ReplyContext（本次任务所有出站消息共用）
         const taskReplyContext = () => {
             const base = this.getReplyContext(message);
@@ -503,6 +530,7 @@ export class MessageProcessor {
                 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;
                 }
@@ -522,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,
@@ -565,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);
                 },
@@ -687,20 +719,6 @@ export class MessageProcessor {
                     }
                     modelOverride = evolclawModelOverride;
                 }
-                // ④ 群聊 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();
@@ -744,9 +762,8 @@ export class MessageProcessor {
                         channel: currentChannelType || null,
                         venueUid: undefined,
                         // 群分发模式 / 客户端类型 / 权限模式
-                        // 优先本地 session 覆盖（/dispatch 命令），fallback 到服务器 dispatch_mode
-                        dispatch: session.metadata?.dispatchMode || message.dispatchMode || undefined,
-                        responseDepth: responseDepth || 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,
@@ -844,6 +861,10 @@ export class MessageProcessor {
                 }
                 // 可重试错误（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 {
@@ -912,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();
@@ -928,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);
                     }
@@ -941,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);
             }
@@ -1073,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) {
@@ -1086,37 +1094,60 @@ 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, name: message.triggerMeta.triggerName ?? '', messageId: messageId, error: errorSummary, targetChannel: message.channel, targetChannelId: message.channelId, fireTime: message.triggerMeta.fireTime ?? 0, phase: 'execute' });
+                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 {
                 // 真正的成功
@@ -1160,6 +1191,9 @@ export class MessageProcessor {
                                 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);
@@ -1217,6 +1251,7 @@ export class MessageProcessor {
                 }
                 catch { /* non-fatal */ }
                 if (message.source !== 'trigger') {
+                    this.touchAgentActivity(channelKey);
                     if (interruptReason) {
                         adapter.send(envelope, { kind: 'status.interrupted', metadata: { reason: interruptReason } }).catch(() => { });
                     }
@@ -1311,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) {
@@ -1321,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) {
@@ -1367,14 +1409,83 @@ 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;
+        }
+    }
     /**
      * 解析会话和项目路径
      */
@@ -1388,15 +1499,8 @@ export class MessageProcessor {
             }
             : 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('群聊中无权限创建话题');
-                }
-            }
-        }
+        // 话题创建权限守卫已统一移至 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);
@@ -1458,32 +1562,6 @@ 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）
      *
@@ -1538,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）
@@ -1619,7 +1698,6 @@ export class MessageProcessor {
                             sessionId: session.id,
                             toolName: event.name,
                             isError: event.isError,
-                            content: event.result,
                             agentName: agentNameForStats,
                             timestamp: Date.now()
                         });
@@ -1642,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);
@@ -1669,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 统一加）

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

@@ -16,6 +16,7 @@ export class MessageQueue {
     recentMessageIds = new Set();
     DEDUP_WINDOW = 60_000; // 1 分钟窗口
     interceptors = new Map();
+    mutedAgents = new Set(); // 禁言的 agent：消息照常入队，但不取出给大模型
     constructor(handler) {
         this.handler = handler;
     }
@@ -145,6 +146,14 @@ export class MessageQueue {
                 this.activeMessageIds.clear();
                 return;
             }
+            // 禁言：消息留在队列里，暂停消费（解禁后由 unmuteAgent 重新触发 processNext）
+            const headAgent = queue[0].agentName || DEFAULT_AGENT_NAME;
+            if (this.mutedAgents.has(headAgent)) {
+                logger.info(`[Queue] processNext: agent ${headAgent} muted, pausing key=${queueKey} (${queue.length} queued)`);
+                this.processing.delete(queueKey);
+                this.processingAgent.delete(queueKey);
+                return;
+            }
             // FIFO 贪心合并：弹出队首连续同 peerId 的消息
             const items = this.dequeueGreedy(queue);
             const merged = items.length === 1 ? items[0] : this.mergeItems(items);
@@ -377,4 +386,63 @@ export class MessageQueue {
         }
         return total;
     }
+    /**
+     * 清空指定 agent 的待处理消息（不影响正在处理中的消息）。
+     * 被移除的消息直接 resolve（与 cancel 一致），让 enqueue 的等待方正常解除阻塞。
+     * @returns 被清除的消息数量
+     */
+    clearByAgent(agentName) {
+        let cleared = 0;
+        for (const queue of this.queues.values()) {
+            for (let i = queue.length - 1; i >= 0; i--) {
+                if ((queue[i].agentName || DEFAULT_AGENT_NAME) === agentName) {
+                    const [removed] = queue.splice(i, 1);
+                    removed.resolve();
+                    cleared++;
+                }
+            }
+        }
+        if (cleared > 0)
+            logger.info(`[Queue] Cleared ${cleared} pending message(s) for agent ${agentName}`);
+        return cleared;
+    }
+    /** 禁言 agent：后续消息照常入队，但 processNext 不再取出处理。 */
+    muteAgent(agentName) {
+        this.mutedAgents.add(agentName);
+        logger.info(`[Queue] Muted agent ${agentName}`);
+    }
+    /** 解除禁言：重新触发该 agent 已积压、且当前未在处理的队列。 */
+    unmuteAgent(agentName) {
+        if (!this.mutedAgents.delete(agentName))
+            return;
+        logger.info(`[Queue] Unmuted agent ${agentName}, resuming queued messages`);
+        for (const [key, queue] of this.queues) {
+            if (queue.length > 0 && !this.processing.has(key)) {
+                const headAgent = queue[0].agentName || DEFAULT_AGENT_NAME;
+                if (headAgent === agentName)
+                    this.processNext(key);
+            }
+        }
+    }
+    isAgentMuted(agentName) {
+        return this.mutedAgents.has(agentName);
+    }
+    /** 中断指定 agent 所有正在处理中的会话（停止 agent 时调用）。 */
+    interruptByAgent(agentName) {
+        for (const [queueKey, name] of this.processingAgent) {
+            if ((name || DEFAULT_AGENT_NAME) === agentName) {
+                const sessionKey = queueKey.split('::')[0];
+                logger.info(`[Queue] Interrupting session ${sessionKey} for stopped agent ${agentName}`);
+                this.eventBus?.publish({
+                    type: 'task:interrupted',
+                    sessionId: sessionKey,
+                    reason: 'new_message',
+                    agentName: name,
+                });
+                if (this.interruptCallback) {
+                    this.interruptCallback(sessionKey, this.currentAgentId, name).catch(() => { });
+                }
+            }
+        }
+    }
 }