evolcore 0.0.3 → 0.0.4

package/dist/core/message/response-engine.js

@@ -5,6 +5,7 @@ import crypto from 'crypto';
 import { BaseagentRunnerUnavailableError, hasCompact, hasClearSession, autoCompactWindowForModel, isClaudeContextUsageModel } from '../../agents/runner-types.js';
 import { buildTaskRuntimeEnv } from '../../cli/task-context.js';
 import { IMRenderer } from './im-renderer.js';
+import { createSendFileMarkerPattern } from './file-markers.js';
 import { createTextInferenceProvider } from '../inference/text-inference.js';
 import { StreamIdleMonitor } from './stream-idle-monitor.js';
 import { logger } from '../../utils/logger.js';
@@ -90,6 +91,45 @@ export function normalizeCompleteAgentEvent(event) {
         terminalReason: normalizedTerminalReason,
     };
 }
+class RetryAttemptTimeoutError extends Error {
+    timeoutMs;
+    constructor(timeoutMs) {
+        super(`RETRY_ATTEMPT_STALLED: no agent events for ${Math.round(timeoutMs / 1000)}s`);
+        this.timeoutMs = timeoutMs;
+        this.name = 'RetryAttemptTimeoutError';
+    }
+}
+function createRetryAttemptTimeout(timeoutMs) {
+    let timer;
+    let settled = false;
+    let rejectTimeout;
+    const promise = new Promise((_, reject) => {
+        rejectTimeout = reject;
+    });
+    const arm = () => {
+        if (settled)
+            return;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            settled = true;
+            timer = undefined;
+            rejectTimeout(new RetryAttemptTimeoutError(timeoutMs));
+        }, timeoutMs);
+        timer.unref?.();
+    };
+    arm();
+    return {
+        promise,
+        reset: arm,
+        clear: () => {
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            timer = undefined;
+        },
+    };
+}
 const RETRY_EXHAUSTED_MARK = Symbol('evolcore.retryExhausted');
 const RETRY_MADE_PROGRESS_MARK = Symbol('evolcore.retryMadeProgress');
 const RETRY_HEALTH_RECORDED_MARK = Symbol('evolcore.retryHealthRecorded');
@@ -123,6 +163,12 @@ function markRetryHealthRecorded(error) {
 function wasRetryHealthRecorded(error) {
     return !!(error && typeof error === 'object' && error[RETRY_HEALTH_RECORDED_MARK] === true);
 }
+function isNonErrorInterruptReason(reason) {
+    return reason === 'new_message'
+        || reason === 'stop'
+        || reason === 'recalled'
+        || reason === 'daemon_restart';
+}
 function formatRetryableErrorFinalMessage(error, retries) {
     const reason = getErrorMessage(error, undefined, false) || 'API 暂时不可用';
     return `❌ API 暂时不可用，已自动重试 ${retries} 次仍失败，任务已停止。\n原因：${reason}`;
@@ -171,6 +217,25 @@ function streamHitContextLimit(result) {
         isContextTooLongText(result.errors?.join(' ') || '') ||
         isContextTooLongText(result.fullText);
 }
+/**
+ * `isContextTooLongText` 是给错误分类用的宽松匹配，不能拿来删除模型正文：正常回答
+ * 可能会说明或引用 `Prompt is too long`。这里只识别网关会单独输出的短错误行。
+ */
+function isStandaloneContextLimitErrorLine(line) {
+    return /^(?:(?:api )?error\s*:\s*)?(?:prompt is too long|input is too long|context too long|context_length_exceeded|context_window_exceeded|context window limit|maximum context length|上下文过长)\s*[.!。]?$/i.test(line.trim());
+}
+/**
+ * 网关有时把上下文超限错误包装进 text event。只丢弃独立错误行，保留同一 event
+ * 中其它行及包含错误字面量的正常输出；原文本仍由调用方保留作恢复判定。
+ */
+function stripContextLimitErrorLines(text) {
+    if (!isContextTooLongText(text))
+        return text;
+    return text
+        .split(/\r?\n/)
+        .filter(line => !isStandaloneContextLimitErrorLine(line))
+        .join('\n');
+}
 const SHELL_CONTROL_RE = /[;&|`]|[$][(]|\r|\n/;
 function isCtlQueueReadCommand(toolName, input) {
     if (toolName !== 'Bash' && toolName !== 'Shell')
@@ -230,6 +295,15 @@ function canCompactAgent(agent) {
 function canClearAgent(agent) {
     return hasClearSession(agent) && agent.capabilities?.clear !== false;
 }
+export async function resolveGroupRulesForTurn(opts, sync = syncGroupRulesContext) {
+    if (!opts.isAunGroup)
+        return {};
+    if (opts.mode === 'ignore') {
+        logger.debug(`[GroupRules] skipped by local policy: group=${opts.groupId ?? '<unknown>'} mode=ignore`);
+        return { groupRulesStatus: 'ignored' };
+    }
+    return sync({ selfAid: opts.selfAid, groupId: opts.groupId, channel: opts.channel });
+}
 function autoCompactTokensFromMaxTokens(maxTokens) {
     if (!maxTokens || maxTokens <= 0)
         return undefined;
@@ -259,8 +333,10 @@ export class ResponseEngine {
     commandHandler;
     channels = new Map();
     channelTypeMap = new Map(); // channelType → channelName（首个实例）
-    currentRenderer;
-    shouldSuppressActivities = false;
+    /** 仅登记正在处理的任务，runner 的 session 回调绝不能投递到其它会话。 */
+    activeRenderers = new Map();
+    /** 已主动发送开始提示时，忽略 runner 对同一次 compact 的回调。 */
+    announcedCompactStarts = new Set();
     agentMap;
     primaryRunnerKey;
     interruptedSessions = new Map(); // sessionId → reason ('new_message' | 'stop' | ...)
@@ -274,6 +350,10 @@ export class ResponseEngine {
     activeMonitors = new Map();
     /** sessionId → 当前正在处理任务的运行时上下文，供 in-task CLI 通过 IPC 查询。 */
     activeTaskRuntimeContexts = new Map();
+    /** task.run started 后立即登记，覆盖运行时上下文尚未建立的 shutdown 窗口。 */
+    activeTaskSpans = new Map();
+    /** sessionId → 尚未收到 runner:task-notification 的子任务。 */
+    activeRunnerTasks = new Map();
     triggerTerminalMessages = new WeakSet();
     agentDelegationRegistry;
     turnCoordinator;
@@ -402,6 +482,14 @@ export class ResponseEngine {
                 this.agentDelegationRegistry?.revokeSession(event.sessionId);
             }
         });
+        this.eventBus.subscribe('task:completed', event => {
+            if ('sessionId' in event && event.sessionId)
+                this.activeTaskSpans.delete(event.sessionId);
+        });
+        this.eventBus.subscribe('task:error', event => {
+            if ('sessionId' in event && event.sessionId)
+                this.activeTaskSpans.delete(event.sessionId);
+        });
         // 初始化响应模式协调器，注册内置模式（interactive/proactive）
         const registry = new ResponseModeRegistry();
         registerBuiltinModes(registry);
@@ -428,17 +516,50 @@ export class ResponseEngine {
         if (!session)
             return;
         this.turnCoordinator.hydrate(session);
-        const interruptedTurn = this.turnCoordinator.invalidate(sessionId, reason);
+        const effectiveReason = reason === 'daemon_restart'
+            || this.interruptedSessions.get(sessionId) === 'daemon_restart'
+            ? 'daemon_restart'
+            : reason;
+        const interruptedTurn = this.turnCoordinator.invalidate(sessionId, effectiveReason);
         const interruptedTaskId = interruptedTurn?.active?.taskId;
-        this.interruptedSessions.set(sessionId, reason);
-        await this.interactionRouter?.cancelAll(sessionId, reason);
+        this.interruptedSessions.set(sessionId, effectiveReason);
+        this.messageQueue?.markActiveTerminal?.(sessionId, effectiveReason);
+        // 终态必须先于渠道发送和 runner I/O 落盘。否则任一外部调用卡住时，
+        // shutdown 超时退出会再次留下 started/interrupting 的悬空任务。
+        const runtimeContext = this.activeTaskRuntimeContexts.get(sessionId);
+        const taskSpan = this.activeTaskSpans.get(sessionId);
+        const taskId = (await this.turnCoordinator.completeInterrupt(session, effectiveReason))
+            ?? interruptedTaskId
+            ?? taskSpan?.taskId;
+        if (taskId) {
+            const taskCausation = taskSpan?.causation ?? runtimeContext?.causation;
+            if (taskCausation && effectiveReason === 'daemon_restart') {
+                recordCausationSpan(taskCausation, 'task.run', {
+                    status: 'interrupted',
+                    refs: {
+                        taskId,
+                        sessionId,
+                        messageId: taskSpan?.messageId ?? runtimeContext?.messageId,
+                    },
+                    reason: effectiveReason,
+                });
+            }
+            this.activeTaskSpans.delete(sessionId);
+            this.sessionManager.clearProcessingIfTask(sessionId, taskId);
+            if (this.activeTaskRuntimeContexts.get(sessionId)?.taskId === taskId) {
+                this.activeTaskRuntimeContexts.delete(sessionId);
+            }
+            this.agentDelegationRegistry?.revokeTask(sessionId, taskId);
+        }
+        this.closeActiveRunnerTasks(sessionId, effectiveReason, taskSpan?.causation ?? runtimeContext?.causation);
+        await this.interactionRouter?.cancelAll(sessionId, effectiveReason);
         const channelKey = session.metadata?.channelKey || session.channel;
         const agent = this.getAgent(channelKey, session.baseagent, session.selfAID);
         const terminalStatus = (() => {
             // TimeoutController owns timeout delivery (including user-facing timeout
             // details) and already guarantees a single terminal status. Sending it
             // here as well would race that barrier and duplicate status.timeout.
-            if (!interruptedTaskId || reason === 'timeout')
+            if (!interruptedTaskId || effectiveReason === 'timeout')
                 return Promise.resolve();
             const channelInfo = this.resolveChannelInfo(channelKey);
             if (!channelInfo)
@@ -458,7 +579,7 @@ export class ResponseEngine {
             });
             const payload = {
                 kind: 'status.interrupted',
-                metadata: { reason },
+                metadata: { reason: effectiveReason },
             };
             return channelInfo.adapter.send(envelope, payload).then(() => undefined).catch(error => {
                 logger.debug(`[ResponseEngine] interrupt terminal status failure: session=${sessionId} task=${interruptedTaskId} error=${error instanceof Error ? error.message : String(error)}`);
@@ -468,13 +589,33 @@ export class ResponseEngine {
             logger.debug(`[ResponseEngine] interrupt barrier runner failure: session=${sessionId} error=${error instanceof Error ? error.message : String(error)}`);
         });
         await Promise.all([terminalStatus, runnerInterrupt]);
-        const taskId = (await this.turnCoordinator.completeInterrupt(session, reason)) ?? interruptedTaskId;
-        if (taskId) {
-            this.sessionManager.clearProcessingIfTask(sessionId, taskId);
-            if (this.activeTaskRuntimeContexts.get(sessionId)?.taskId === taskId) {
-                this.activeTaskRuntimeContexts.delete(sessionId);
-            }
-            this.agentDelegationRegistry?.revokeTask(sessionId, taskId);
+    }
+    closeActiveRunnerTasks(sessionId, reason, causation) {
+        const tasks = this.activeRunnerTasks.get(sessionId);
+        if (!tasks || tasks.size === 0)
+            return;
+        this.activeRunnerTasks.delete(sessionId);
+        for (const task of tasks.values()) {
+            const hasUsage = task.totalTokens != null || task.toolUses != null || task.durationMs != null;
+            this.eventBus.publish({
+                type: 'runner:task-notification',
+                sessionId,
+                taskId: task.taskId,
+                taskKind: task.taskKind,
+                toolUseId: task.toolUseId,
+                description: task.description,
+                subagentType: task.subagentType,
+                status: 'stopped',
+                terminalReason: reason,
+                usage: hasUsage ? {
+                    totalTokens: task.totalTokens,
+                    toolUses: task.toolUses,
+                    durationMs: task.durationMs,
+                } : undefined,
+                skipTranscript: task.skipTranscript,
+                timestamp: Date.now(),
+                causation,
+            });
         }
     }
     setHandoffRuntime(runtime) {
@@ -493,7 +634,7 @@ export class ResponseEngine {
         if (!params.sessionId)
             return { ok: false, code: 'HANDOFF_ID_REQUIRED', error: 'current session is required' };
         if (this.agentDelegationRegistry) {
-            const delegation = this.agentDelegationRegistry.validate(params.delegationToken, params.sessionId);
+            const delegation = this.agentDelegationRegistry.validate(params.delegationToken, params.sessionId, params.delegationCommandHash);
             if (!delegation.ok)
                 return { ok: false, code: delegation.code, error: delegation.reason };
         }
@@ -653,26 +794,44 @@ export class ResponseEngine {
         if (sessionId) {
             this.eventBus.publish({ type: 'runner:compact-start', sessionId });
         }
-        if (this.currentRenderer && !this.shouldSuppressActivities) {
-            this.currentRenderer.addNotice('\u23f3 会话压缩中...', 'info', 'compact-start', true);
-        }
+        if (!sessionId || this.announcedCompactStarts.has(sessionId))
+            return;
+        const active = this.activeRenderers.get(sessionId);
+        if (!active || active.suppressActivities)
+            return;
+        void this.emitOperationalNotice(active.renderer, '\u23f3 会话压缩中...', 'info', 'compact-start');
+    }
+    async emitOperationalNotice(renderer, text, severity, subtype) {
+        if (await renderer.sendOperationalNoticeAsText(text))
+            return;
+        renderer.addNotice(text, severity, subtype, true);
     }
     async retryAfterContextRecovery(prompt, opts) {
         const { streamKey, renderer, agent, session, absoluteProjectPath, effectiveSystemPrompt, modelOverride, runtimeEnv, resetTimer, shouldSuppress, proactive, turnLease, } = opts;
         if (!session.agentSessionId || !canCompactAgent(agent)) {
             throw new Error('CONTEXT_COMPACT_FAILED');
         }
-        renderer.addNotice('上下文过长，正在压缩会话...', 'warn', 'compact-trigger', true);
+        // text event 在进入 renderer 前已经剔除了上下文超限错误行。保留缓冲中的
+        // 有效正文，由 sendOperationalNoticeAsText 先 flush，避免恢复过程丢失已有模型输出。
+        await this.emitOperationalNotice(renderer, '上下文过长，正在压缩会话...', 'warn', 'compact-trigger');
         await renderer.flush();
-        const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
+        this.announcedCompactStarts.add(session.id);
+        let compacted;
+        try {
+            compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
+        }
+        finally {
+            this.announcedCompactStarts.delete(session.id);
+        }
         if (compacted) {
-            renderer.addNotice('✅ 压缩完成，继续处理...', 'info', 'compact-retry', true);
+            await this.emitOperationalNotice(renderer, '✅ 压缩完成，继续处理...', 'info', 'compact-retry');
+            await renderer.flush();
             const retryStream = await agent.runQuery(session.id, prompt, absoluteProjectPath, session.agentSessionId, undefined, effectiveSystemPrompt, this.sessionManager, modelOverride, runtimeEnv);
             agent.registerStream(streamKey, retryStream);
             return await this.processEventStream(retryStream, session, agent, renderer, resetTimer, shouldSuppress, proactive, undefined, // 重试分支不调插件钩子
             undefined, turnLease);
         }
-        renderer.addNotice('⚠️ 压缩失败，尝试清空会话历史后重试...', 'warn', 'compact-failed-clear', true);
+        await this.emitOperationalNotice(renderer, '⚠️ 压缩失败，尝试清空会话历史后重试...', 'warn', 'compact-failed-clear');
         await renderer.flush();
         if (!canClearAgent(agent)) {
             throw new Error('CONTEXT_COMPACT_FAILED');
@@ -690,7 +849,8 @@ export class ResponseEngine {
         }
         session.agentSessionId = undefined;
         await this.sessionManager.updateSession(session.id, { agentSessionId: null });
-        renderer.addNotice('✅ 会话已清空，继续处理...', 'info', 'clear-retry', true);
+        await this.emitOperationalNotice(renderer, '✅ 会话已清空，继续处理...', 'info', 'clear-retry');
+        await renderer.flush();
         const retryStream = await agent.runQuery(session.id, '会话历史已清空，请继续之前未完成的任务。', absoluteProjectPath, undefined, undefined, effectiveSystemPrompt, this.sessionManager, modelOverride, runtimeEnv);
         agent.registerStream(streamKey, retryStream);
         return await this.processEventStream(retryStream, session, agent, renderer, resetTimer, shouldSuppress, proactive, undefined, // 重试分支不调插件钩子
@@ -911,6 +1071,19 @@ export class ResponseEngine {
         const accessAdapter = accessChannelInfo?.adapter;
         const accessAdapterSelfAid = typeof accessAdapter?._selfAid === 'function' ? accessAdapter._selfAid() : undefined;
         const selfAidForAccess = accessAdapterSelfAid || message.selfAID || session.selfAID || undefined;
+        if (message.handoffDelivery?.direction === 'target'
+            && this.handoffRuntime
+            && selfAidForAccess) {
+            const handoffIds = message.handoffDelivery.handoffIds?.length
+                ? message.handoffDelivery.handoffIds
+                : [message.handoffDelivery.handoffId];
+            const validation = this.handoffRuntime.validateTargetSessionBinding(selfAidForAccess, handoffIds, session.id);
+            if (!validation.ok) {
+                logger.error(`[ResponseEngine] Refusing mismatched handoff context: executionSession=${session.id}`
+                    + ` handoffs=${validation.invalidHandoffIds.join(',')}`);
+                delete message.handoffDelivery;
+            }
+        }
         const triggerExecutionIdentity = this.resolveTriggerExecutionIdentity(message, selfAidForAccess);
         const handoffExecutionIdentity = this.resolveHandoffOriginExecutionIdentity(message, selfAidForAccess);
         const executionIdentity = triggerExecutionIdentity ?? handoffExecutionIdentity;
@@ -1012,7 +1185,6 @@ export class ResponseEngine {
         const shouldSuppress = () => {
             return outputState.middleOutputMode === 'none';
         };
-        this.shouldSuppressActivities = shouldSuppress();
         let monitor;
         let monitorInterval;
         let totalExecutionTimer;
@@ -1173,6 +1345,18 @@ export class ResponseEngine {
             ? configuredSeconds * 1000
             : 60 * 60 * 1000;
     }
+    retryAttemptTimeoutMs() {
+        if (this.globalSettings.idleMonitor?.enabled === false)
+            return undefined;
+        const configuredSeconds = this.globalSettings.idleMonitor?.retryAttemptTimeout
+            ?? this.globalSettings.idleMonitor?.timeout
+            ?? 120;
+        return typeof configuredSeconds === 'number'
+            && Number.isFinite(configuredSeconds)
+            && configuredSeconds > 0
+            ? configuredSeconds * 1000
+            : undefined;
+    }
     /** 自动安全模式已禁用：仅保留错误计数，不再自动切换状态 */
     async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, getLastIdleSec, outputState = { middleOutputMode: 'all' }, timeoutControl) {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
@@ -1231,6 +1415,11 @@ export class ResponseEngine {
             status: 'started',
             refs: { taskId, sessionId: session.id, messageId: message.messageId },
         });
+        this.activeTaskSpans.set(session.id, {
+            taskId,
+            messageId: message.messageId,
+            causation: taskCausation,
+        });
         for (const item of message.items ?? []) {
             const linked = normalizeCausation(item.causation);
             if (!linked || linked.spanId === inputCausation.spanId)
@@ -1255,7 +1444,9 @@ export class ResponseEngine {
         const adapterAny = channelInfo.adapter;
         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 registrySelfName = selfAid ? this.agentRegistry?.resolveDisplayName?.(selfAid) : undefined;
+        const adapterSelfName = typeof adapterAny._selfName === 'function' ? adapterAny._selfName() : undefined;
+        const selfName = registrySelfName ?? adapterSelfName;
         const peerName = message.peerName || session.metadata?.peerName;
         const peerIdRaw = message.peerId;
         const triggerExecutionIdentity = this.resolveTriggerExecutionIdentity(message, selfAid);
@@ -1389,7 +1580,6 @@ export class ResponseEngine {
                 ? 'none'
                 : configuredMiddleOutputMode;
         outputState.middleOutputMode = middleOutputMode;
-        this.shouldSuppressActivities = shouldSuppress();
         // 诊断日志：记录 inbound message_id 和生成的 task_id 的对应关系
         logger.info(`[ResponseEngine] Task created: inboundMsgId=${message.messageId ?? 'none'} taskId=${taskId} sessionId=${session.id} chatmode=${chatmode} mode=${resolvedMode?.mode.id ?? 'override/fallback'}`);
         // 构建带 taskId/chatmode 的 ReplyContext（本次任务所有出站消息共用）
@@ -1617,17 +1807,16 @@ export class ResponseEngine {
                     taskId,
                     channelId: message.channelId,
                     messageIds: message.sourceMessageIds,
+                    restartResume: message.restartResume?.submitted === true,
                 }).catch(() => { });
             }
             adapter.send(envelope, { kind: 'status.started' }).catch(() => { });
-            await this.runPendingAutoCompactAtTaskStart(session, agent, absoluteProjectPath, adapter, envelope, false);
             logger.message({
                 msgId: messageId,
                 sessionId: session.id,
                 dir: 'inbound',
                 status: 'processing'
             });
-            const startTime = Date.now();
             // 创建 IMRenderer（统一 interactive/proactive 两条路径）
             let firstReply = true;
             const renderer = new IMRenderer({
@@ -1636,6 +1825,7 @@ export class ResponseEngine {
                 flushDelay: (options?.flushDelay ?? this.agentRegistry?.resolveByChannel(channelKey)?.config?.flush_delay ?? 3) * 1000,
                 suppressActivityItems: isProactive ? false : middleOutputMode !== 'all',
                 suppressIntermediateText: isProactive ? false : middleOutputMode === 'none',
+                operationalNoticesAsText: !isProactive && middleOutputMode !== 'none',
                 fileMarkerPattern: options?.fileMarkerPattern,
                 diagEnabled: this.globalSettings.debug?.flusherDiag,
                 send: async (payload) => {
@@ -1679,8 +1869,17 @@ export class ResponseEngine {
                     await adapter.send(enrichedEnvelope, payload);
                 },
             });
-            this.currentRenderer = renderer;
+            this.activeRenderers.set(session.id, {
+                taskId,
+                renderer,
+                suppressActivities: shouldSuppress(),
+            });
             renderer.addLifecycle('started');
+            // 预压缩与任务过程中的自动压缩共用同一投影规则：interactive 的 text/all
+            // 均以普通非最终文本显示运行提示；none 不显示。其它 activity 在 all 下仍保持结构化。
+            // 它仍发生在真正的 prompt 执行之前。
+            await this.runPendingAutoCompactAtTaskStart(session, agent, absoluteProjectPath, renderer);
+            const startTime = Date.now();
             if (isProactive) {
                 logger.info(`[ResponseEngine] proactive mode: outputs via thought.put task=${taskId}`);
             }
@@ -1821,6 +2020,14 @@ export class ResponseEngine {
                 approvalRouting,
                 approvalInteractionPolicy: authorizationIdentity ? 'deny' : 'interactive',
                 recordExecutionAnomaly,
+                armApprovedDelegationCommand: this.agentDelegationRegistry
+                    ? (carrierToken, commandHash) => this.agentDelegationRegistry.armApprovedCommand({
+                        carrierToken,
+                        sessionId: session.id,
+                        taskId,
+                        commandHash,
+                    })
+                    : undefined,
                 turn: {
                     taskId,
                     turnId: turnLease.turnId,
@@ -2125,13 +2332,13 @@ export class ResponseEngine {
                     + ` modelSource=${effectiveModelSource ?? 'runner-default'}`
                     + ` effort=${effectiveEffort ?? '<runner-default>'}`
                     + ` effortSource=${effectiveEffortSource ?? 'runner-default'}`);
-                const groupRulesVars = session.chatType === 'group' && currentChannelType === 'aun'
-                    ? await syncGroupRulesContext({
-                        selfAid,
-                        groupId: session.metadata?.groupId || message.channelId,
-                        channel: currentChannelType || message.channel,
-                    })
-                    : {};
+                const groupRulesVars = await resolveGroupRulesForTurn({
+                    isAunGroup: session.chatType === 'group' && currentChannelType === 'aun',
+                    mode: effectiveAgentConfig?.groupRules?.mode ?? 'load',
+                    selfAid,
+                    groupId: session.metadata?.groupId || message.channelId,
+                    channel: currentChannelType || message.channel,
+                });
                 // Kit renderer: 组装上下文
                 const pkgRoot = getPackageRoot();
                 const kitCtx = {
@@ -2197,6 +2404,7 @@ export class ResponseEngine {
                         // Stage 3: sessionKey 持久化字段
                         sessionKey: session.sessionKey,
                         chatMode: isProactive ? 'proactive' : 'interactive',
+                        isTriggerTask: causationPath.length > 0 || message.source === 'trigger',
                         // proactive 为 null（interactive 模式，这些开关不适用）时如实为 false——
                         // 默认值不在此硬编码，出厂默认由模式 schema 声明、经 buildState 落入 proactive.*。
                         proactivePreTool1stMsgChk: proactive?.preTool1stMsgChk ?? false,
@@ -2276,9 +2484,9 @@ export class ResponseEngine {
                         if (message.handoffDelivery && this.handoffRuntime) {
                             const items = this.handoffRuntime.buildPromptItems(message);
                             if (items.length > 0) {
-                                v2HandoffIds = items
-                                    .map(item => item.handoff?.handoffId)
-                                    .filter((handoffId) => !!handoffId);
+                                v2HandoffIds = Array.from(new Set(items.flatMap(item => (item.handoff?.handoffIds?.length
+                                    ? item.handoff.handoffIds
+                                    : (item.handoff?.handoffId ? [item.handoff.handoffId] : [])))));
                                 v2HandoffDirection = message.handoffDelivery.direction;
                                 return items;
                             }
@@ -2345,9 +2553,12 @@ export class ResponseEngine {
                     this.publishTriggerExecutionSkipped(message, 'empty_prompt', taskCausation);
                     return;
                 }
-                if (v2HandoffIds.length > 0 && v2HandoffDirection === 'origin' && handoffPromptRendered && this.handoffRuntime && selfAid) {
+                if (v2HandoffIds.length > 0 && handoffPromptRendered && this.handoffRuntime && selfAid) {
                     for (const handoffId of v2HandoffIds) {
-                        this.handoffRuntime.completeOriginContext(selfAid, handoffId);
+                        if (v2HandoffDirection === 'origin')
+                            this.handoffRuntime.completeOriginContext(selfAid, handoffId);
+                        else if (v2HandoffDirection === 'target')
+                            this.handoffRuntime.completeTargetContext(selfAid, handoffId);
                     }
                 }
                 const taskRuntimeContext = {
@@ -2395,6 +2606,7 @@ export class ResponseEngine {
                 // 可重试错误（403/429/5xx/模型繁忙）按明确退避序列重试。
                 const RETRY_DELAYS_MS = [5_000, 10_000, 30_000];
                 const MAX_RETRIES = RETRY_DELAYS_MS.length;
+                const retryAttemptTimeoutMs = this.retryAttemptTimeoutMs();
                 let runAttempt = 1;
                 let consecutiveRetryFailures = 0;
                 const recordRetryHealthError = async (retryError) => {
@@ -2412,12 +2624,24 @@ export class ResponseEngine {
                 };
                 while (true) {
                     let streamRegistered = false;
+                    const shouldTimeoutRetryAttempt = consecutiveRetryFailures > 0 && retryAttemptTimeoutMs !== undefined;
+                    let attemptTimeout;
                     try {
                         logger.info(`[ResponseEngine] agent.runQuery start: agent=${agent.name} session=${session.id} task=${taskId} attempt=${runAttempt} consecutiveFailures=${consecutiveRetryFailures} agentSessionId=${session.agentSessionId ?? 'none'}`);
                         const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, session.agentSessionId, renderResult?.images.length ? renderResult.images : message.images, effectiveSystemPrompt, this.sessionManager, modelOverride, runtimeEnv);
                         agent.registerStream(streamKey, stream);
                         streamRegistered = true;
-                        streamResult = await this.processEventStream(stream, session, agent, renderer, resetTimer, shouldSuppress, proactive, resolvedMode ? { mode: resolvedMode.mode, state: modeState } : undefined, taskCausation, turnLease);
+                        if (shouldTimeoutRetryAttempt) {
+                            attemptTimeout = createRetryAttemptTimeout(retryAttemptTimeoutMs);
+                            resetTimer('retry_attempt');
+                        }
+                        const processAttempt = this.processEventStream(stream, session, agent, renderer, (eventType, toolName) => {
+                            resetTimer(eventType, toolName);
+                            attemptTimeout?.reset();
+                        }, shouldSuppress, proactive, resolvedMode ? { mode: resolvedMode.mode, state: modeState } : undefined, taskCausation, turnLease);
+                        streamResult = attemptTimeout
+                            ? await Promise.race([processAttempt, attemptTimeout.promise])
+                            : await processAttempt;
                         if (streamResult.isError && !streamHitContextLimit(streamResult)) {
                             const streamErrorText = getStreamErrorText(streamResult);
                             if (streamErrorText && isRetryableError(new Error(streamErrorText))) {
@@ -2433,6 +2657,14 @@ export class ResponseEngine {
                         break; // 成功，跳出重试循环
                     }
                     catch (retryError) {
+                        const retryAttemptTimedOut = retryError instanceof RetryAttemptTimeoutError;
+                        if (retryAttemptTimedOut) {
+                            logger.warn(`[ResponseEngine] Retry attempt ${runAttempt} timed out after ${retryError.timeoutMs}ms without agent events; interrupting current stream`);
+                            renderer.discardPending();
+                            await agent.interrupt(session.id).catch(interruptError => {
+                                logger.warn(`[ResponseEngine] Failed to interrupt timed-out retry attempt: ${interruptError instanceof Error ? interruptError.message : String(interruptError)}`);
+                            });
+                        }
                         if (streamRegistered) {
                             agent.cleanupStream(streamKey);
                         }
@@ -2463,7 +2695,7 @@ export class ResponseEngine {
                             runAttempt++;
                             continue;
                         }
-                        if (isRetryableError(retryError)) {
+                        if (retryAttemptTimedOut || isRetryableError(retryError)) {
                             if (didRetryMakeProgress(retryError)) {
                                 consecutiveRetryFailures = 0;
                             }
@@ -2479,7 +2711,7 @@ export class ResponseEngine {
                                 const nextRetryNumber = consecutiveRetryFailures + 1;
                                 consecutiveRetryFailures++;
                                 logger.warn(`[ResponseEngine] Retryable error (attempt ${runAttempt}, consecutive ${consecutiveRetryFailures}/${MAX_RETRIES}), retrying in ${delay}ms:`, retryError);
-                                renderer.addNotice(`API 不可用，${delay / 1000}秒后重试 ${nextRetryNumber}/${MAX_RETRIES}`, 'warn', 'retry', true);
+                                await this.emitOperationalNotice(renderer, `API 不可用，${delay / 1000}秒后重试 ${nextRetryNumber}/${MAX_RETRIES}`, 'warn', 'retry');
                                 await renderer.flush();
                                 await new Promise(resolve => setTimeout(resolve, delay));
                                 // 延迟后再次检查中断状态（延迟期间可能收到中断信号）
@@ -2495,6 +2727,9 @@ export class ResponseEngine {
                         }
                         throw retryError; // 不可重试或已耗尽重试次数
                     }
+                    finally {
+                        attemptTimeout?.clear();
+                    }
                 }
             }
             catch (error) {
@@ -2557,12 +2792,12 @@ export class ResponseEngine {
                 // 重试后仍然 prompt_too_long：显示友好提示
                 const retryStillTooLong = streamResult.isError && streamHitContextLimit(streamResult);
                 if (retryStillTooLong) {
-                    renderer.addNotice(getContextTooLongHint(agent), 'warn', 'context-too-long', true);
+                    await this.emitOperationalNotice(renderer, getContextTooLongHint(agent), 'warn', 'context-too-long');
                 }
             }
             else if (streamResult.isError && streamHitContextLimit(streamResult)) {
                 // 上下文过长但无法 auto-compact（无 session ID 或 agent 不支持），显示友好提示
-                renderer.addNotice(getContextTooLongHint(agent), 'warn', 'context-too-long', true);
+                await this.emitOperationalNotice(renderer, getContextTooLongHint(agent), 'warn', 'context-too-long');
             }
             if (!streamResult.isError) {
                 const commitEvidence = this.buildTurnCommitEvidence(session, streamResult);
@@ -2634,7 +2869,7 @@ export class ResponseEngine {
                         if (!this.turnCoordinator.isCurrent(turnLease))
                             return 0;
                         // 仅支持公开文件标记语法：[SEND_FILE:path] 或 [SEND_FILE:channel:path]。
-                        const SEND_FILE_RE = options?.fileMarkerPattern ?? /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g;
+                        const SEND_FILE_RE = options?.fileMarkerPattern ?? createSendFileMarkerPattern();
                         const sendFileMatches = [...scanText.matchAll(SEND_FILE_RE)];
                         if (sendFileMatches.length === 0)
                             return 0;
@@ -2730,6 +2965,7 @@ export class ResponseEngine {
             }
             // 最终回复文本：suppressed 模式或无 text 事件时需要兜底添加
             const finalReplyText = streamResult.lastReplyText || streamResult.fullText;
+            const visibleFinalReplyText = stripContextLimitErrorLines(finalReplyText);
             if (!this.turnCoordinator.isCurrent(turnLease)) {
                 agent.cleanupStream(streamKey);
                 this.sessionManager.clearProcessingIfTask(session.id, taskId);
@@ -2741,9 +2977,11 @@ export class ResponseEngine {
                 await this.publishTriggerExecutionInterrupted(message, adapter, envelope, 'stale_turn', taskCausation);
                 return;
             }
-            if (finalReplyText) {
-                if (shouldSuppress() || !streamResult.hasReceivedText) {
-                    renderer.addText(finalReplyText);
+            if (visibleFinalReplyText) {
+                // `hasReceivedText` 是任务级计数。工具调用前的文字已经显示，并不表示最后一轮
+                // （通常来自 complete.result）的文字也已显示；用本轮投影标记避免终态丢失。
+                if (shouldSuppress() || !streamResult.hasProjectedCurrentReplyText) {
+                    renderer.addText(visibleFinalReplyText);
                 }
             }
             // 先清理流和处理中状态（保证即使 flush 卡住，session 也不会永久处于"处理中"）
@@ -2771,7 +3009,7 @@ export class ResponseEngine {
             }
             // 被用户中断（新消息打断）时跳过 flush — 新 task 已接管渠道，旧 task 的 flush 无意义且可能卡住
             const preFlushInterrupt = this.interruptedSessions.get(session.id);
-            if (preFlushInterrupt === 'new_message' || preFlushInterrupt === 'stop' || preFlushInterrupt === 'recalled') {
+            if (isNonErrorInterruptReason(preFlushInterrupt)) {
                 logger.info(`[ResponseEngine] Skipping flush for interrupted task=${taskId} reason=${preFlushInterrupt}`);
             }
             else {
@@ -2812,13 +3050,13 @@ export class ResponseEngine {
                 // 用户主动打断（新消息/​/stop/​撤回）会让 SDK 流在工具调用中途被掐断，
                 // 末尾 result message 形状异常并被标记为 error（含 SDK 内部 ede_diagnostic 串）。
                 // 这不是真正的失败，不应把诊断串暴露给用户，也不计入错误统计。
-                const isUserInterrupt = interruptReason === 'new_message' || interruptReason === 'stop' || interruptReason === 'recalled';
-                if (!isUserInterrupt && !permissionTerminalFailure) {
+                const isExpectedInterrupt = isNonErrorInterruptReason(interruptReason);
+                if (!isExpectedInterrupt && !permissionTerminalFailure) {
                     await adapter.send(envelope, { kind: 'result.error', text: userErrorSummary, reason: rawSubtype }).catch(() => { });
                     await adapter.send(envelope, { kind: 'status.error', metadata: { errorType: rawSubtype } }).catch(() => { });
                     this.touchAgentActivity(channelKey);
                 }
-                if (isUserInterrupt) {
+                if (isExpectedInterrupt) {
                     // 用户打断：打断本身已由 message-queue 发过 task:interrupted 事件，
                     // 这里不再补发 task:error（否则同一次打断被记两遍且错误归类为 error）。
                     // 仅记 info 日志收尾。注意：task:interrupted 已填充 interruptedSessions，
@@ -2835,6 +3073,8 @@ export class ResponseEngine {
                     await this.publishTriggerExecutionInterrupted(message, adapter, envelope, interruptReason ?? 'interrupted', taskCausation);
                 }
                 else {
+                    logger.error(`[ResponseEngine] Task failed: session=${session.id} task=${taskId} ` +
+                        `type=${errorType} terminalReason=${streamResult.terminalReason ?? 'none'} error=${errorSummary}`);
                     this.publishTriggerExecutionFailure(message, errorSummary, { messageId, causation: taskCausation });
                     this.eventBus.publish({
                         type: 'task:error',
@@ -3128,10 +3368,7 @@ export class ResponseEngine {
                 && interruptReason !== 'timeout'
                 && !isTimeout
                 && !isTotalExecutionTimeout;
-            const isUserInterrupt = interruptReason === 'new_message'
-                || interruptReason === 'stop'
-                || interruptReason === 'recalled'
-                || staleSupersededTurn;
+            const isUserInterrupt = isNonErrorInterruptReason(interruptReason) || staleSupersededTurn;
             const errorMsg = error instanceof Error ? error.message : String(error);
             if (isUserInterrupt) {
                 await this.publishTriggerExecutionInterrupted(message, adapter, envelope, interruptReason ?? 'stale_turn', taskCausation);
@@ -3257,6 +3494,12 @@ export class ResponseEngine {
                 timeoutControl.terminalDelivered = true;
             }
         }
+        finally {
+            // 同一 session 的新任务可能已替换登记；旧任务结束时不得删掉新任务的 renderer。
+            if (this.activeRenderers.get(session.id)?.taskId === taskId) {
+                this.activeRenderers.delete(session.id);
+            }
+        }
         // [迁移探针] 任务收尾：记录工具提醒最终状态并落盘（防线 1）
         if (snapshot.isEnabled()) {
             snapshot.set(session.id, taskId, {
@@ -3265,7 +3508,7 @@ export class ResponseEngine {
             snapshot.end(session.id, taskId);
         }
     }
-    async runPendingAutoCompactAtTaskStart(session, agent, absoluteProjectPath, adapter, envelope, suppressOutput = false) {
+    async runPendingAutoCompactAtTaskStart(session, agent, absoluteProjectPath, renderer) {
         if (!session.agentSessionId || !canCompactAgent(agent)) {
             logger.debug(`[ResponseEngine] Auto compact skipped: session=${session.id} agentSessionId=${session.agentSessionId || 'none'} canCompact=${canCompactAgent(agent)} agent=${agent.name}`);
             return;
@@ -3276,15 +3519,14 @@ export class ResponseEngine {
             return;
         }
         logger.info(`[ResponseEngine] Auto compact at task.start: session=${session.id} totalTokens=${ctx.totalTokens} autoCompactTokens=${ctx.autoCompactTokens}`);
-        if (!suppressOutput) {
-            await adapter.send(envelope, { kind: 'system.notice', text: '上下文接近上限，正在压缩会话...', subtype: 'auto-compact-start' }).catch(() => { });
-        }
+        await this.emitOperationalNotice(renderer, '上下文接近上限，正在压缩会话...', 'info', 'auto-compact-start');
+        await renderer.flush();
+        this.announcedCompactStarts.add(session.id);
         try {
             const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
             if (compacted) {
-                if (!suppressOutput) {
-                    await adapter.send(envelope, { kind: 'system.notice', text: '✅ 上下文压缩完成，继续处理...', subtype: 'auto-compact-complete' }).catch(() => { });
-                }
+                await this.emitOperationalNotice(renderer, '✅ 上下文压缩完成，继续处理...', 'info', 'auto-compact-complete');
+                await renderer.flush();
             }
             else {
                 logger.warn(`[ResponseEngine] Auto compact at task.start returned false (session=${session.id})`);
@@ -3293,6 +3535,9 @@ export class ResponseEngine {
         catch (err) {
             logger.warn(`[ResponseEngine] Auto compact at task.start failed (non-fatal):`, err);
         }
+        finally {
+            this.announcedCompactStarts.delete(session.id);
+        }
     }
     async readLastModelCallContextUsage(sessionId, agentSessionId) {
         try {
@@ -3359,17 +3604,28 @@ export class ResponseEngine {
         const owningAgent = this.agentRegistry?.resolveByChannel(message.channel);
         const projectPath = owningAgent?.projectPath || process.cwd();
         const resolvedBaseagent = message.baseagent || owningAgent?.baseagent || (!this.agentRegistry ? this.inferPrimaryBaseagent() : undefined);
-        const resolvedIdentity = this.inferDirectSessionIdentity(message, owningAgent);
+        // 优先复用 MessageBridge 入队前已解析的身份，避免二次独立解析产生角色漂移
+        // （曾观测到瞬时竞态下把 owner 误判为 none，导致合法用户被静默拒绝）。
+        // 仅当消息不经 MessageBridge.register()（如 trigger 直接投递）时才回退重新解析。
+        const resolvedIdentity = message.resolvedIdentity ?? this.inferDirectSessionIdentity(message, owningAgent);
         if (!resolvedBaseagent) {
             throw new Error(`[ResponseEngine] resolveSession: baseagent could not be determined (message.baseagent=${message.baseagent}, owningAgent=${owningAgent?.name || 'none'})`);
         }
         // 话题创建权限守卫已统一移至 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);
+        // Resume the exact session selected before enqueue. Handoff binding and model
+        // execution must never independently re-resolve to different sessions.
+        const boundSessionId = message.boundSessionId ?? message.triggerMeta?.boundSessionId;
+        if (boundSessionId) {
+            const bound = await this.sessionManager.getSessionById(boundSessionId);
             if (bound) {
                 this.ensureSessionBaseagent(bound, resolvedBaseagent);
+                // Session.identity is deliberately runtime-only and is not persisted in
+                // active.json/session JSONL. Re-attaching a bridge-bound session without
+                // restoring the freshly resolved identity would therefore downgrade a
+                // valid mapped owner/admin to role=none at the execution boundary.
+                if (resolvedIdentity)
+                    bound.identity = resolvedIdentity;
                 if (bound.threadId) {
                     const absoluteProjectPath = path.isAbsolute(bound.projectPath)
                         ? bound.projectPath : path.resolve(process.cwd(), bound.projectPath);
@@ -3378,14 +3634,22 @@ export class ResponseEngine {
                 const switched = await this.sessionManager.switchToSession(bound.channel, bound.channelId, bound.id);
                 if (switched) {
                     this.ensureSessionBaseagent(switched, resolvedBaseagent);
+                    if (resolvedIdentity)
+                        switched.identity = resolvedIdentity;
                     const absoluteProjectPath = path.isAbsolute(switched.projectPath)
                         ? switched.projectPath : path.resolve(process.cwd(), switched.projectPath);
                     return { session: switched, absoluteProjectPath };
                 }
+                if (message.boundSessionId) {
+                    throw new Error(`[ResponseEngine] Bound session ${bound.id} could not be activated`);
+                }
                 logger.warn(`[ResponseEngine] switchToSession failed for bound session ${bound.id}, falling back to latest`);
             }
             else {
-                logger.warn(`[ResponseEngine] Bound session ${message.triggerMeta.boundSessionId} not found, falling back to latest`);
+                if (message.boundSessionId) {
+                    throw new Error(`[ResponseEngine] Bound session ${boundSessionId} not found`);
+                }
+                logger.warn(`[ResponseEngine] Bound session ${boundSessionId} not found, falling back to latest`);
             }
         }
         const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, projectPath, message.threadId, metadata, message.topicName, message.peerId, message.chatType, resolvedBaseagent, message.selfAID, message.channelType, message.peerType, resolvedIdentity);
@@ -3444,6 +3708,7 @@ export class ResponseEngine {
         const statsChannelKey = session.channel === 'daemon' ? session.channel : (session.metadata?.channelKey || session.channel);
         const agentNameForStats = this.agentRegistry?.resolveByChannel(statsChannelKey)?.name ?? '<unknown>';
         let hasReceivedText = false;
+        let hasProjectedCurrentReplyText = false;
         let hasErrorResult = false; // 是否已有 tool_result/error 事件输出过错误
         let madeProgress = false;
         let completeResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
@@ -3457,6 +3722,7 @@ export class ResponseEngine {
         const finalizeResult = () => ({
             ...completeResult,
             hasReceivedText,
+            hasProjectedCurrentReplyText,
             inputAccepted,
             assistantUuid,
             protocolIncompleteReason,
@@ -3583,6 +3849,19 @@ export class ResponseEngine {
                     continue;
                 }
                 if (event.type === 'task_started') {
+                    let tasks = this.activeRunnerTasks.get(session.id);
+                    if (!tasks) {
+                        tasks = new Map();
+                        this.activeRunnerTasks.set(session.id, tasks);
+                    }
+                    tasks.set(event.taskId, {
+                        taskId: event.taskId,
+                        taskKind: event.taskKind,
+                        toolUseId: event.toolUseId,
+                        description: event.description,
+                        subagentType: event.subagentType,
+                        skipTranscript: event.skipTranscript,
+                    });
                     this.eventBus.publish({
                         type: 'runner:task-started',
                         sessionId: session.id,
@@ -3622,6 +3901,10 @@ export class ResponseEngine {
                     continue;
                 }
                 if (event.type === 'task_notification') {
+                    const tasks = this.activeRunnerTasks.get(session.id);
+                    tasks?.delete(event.taskId);
+                    if (tasks?.size === 0)
+                        this.activeRunnerTasks.delete(session.id);
                     this.eventBus.publish({
                         type: 'runner:task-notification',
                         sessionId: session.id,
@@ -3656,6 +3939,16 @@ export class ResponseEngine {
                     continue;
                 }
                 if (event.type === 'task_progress') {
+                    if (event.taskId) {
+                        const task = this.activeRunnerTasks.get(session.id)?.get(event.taskId);
+                        if (task) {
+                            task.description = task.description || event.description;
+                            task.subagentType = task.subagentType || event.subagentType;
+                            task.totalTokens = event.totalTokens ?? task.totalTokens;
+                            task.toolUses = event.toolUses ?? task.toolUses;
+                            task.durationMs = event.durationMs ?? task.durationMs;
+                        }
+                    }
                     this.eventBus.publish({
                         type: 'runner:task-progress',
                         sessionId: session.id,
@@ -3678,13 +3971,21 @@ export class ResponseEngine {
                 if (!isCurrentlyBackground) {
                     // 流式文本
                     if (event.type === 'text') {
-                        hasReceivedText = true;
-                        if (event.text.trim())
-                            madeProgress = true;
+                        // 网关偶尔会把上下文超限错误伪装成普通 text event。不要向事件总线或
+                        // 渲染器投影错误行；lastReplyText 仍保留原文本，以便流结束后触发恢复。
+                        const visibleText = stripContextLimitErrorLines(event.text);
+                        if (visibleText) {
+                            hasReceivedText = true;
+                            if (visibleText.trim())
+                                madeProgress = true;
+                        }
                         lastReplyText += event.text;
-                        this.eventBus.publish({ type: 'message:text', sessionId: session.id, text: event.text, isFinal: false });
-                        if (!shouldSuppress()) {
-                            renderer.addText(event.text, event.outputTokens, event.turn);
+                        if (visibleText) {
+                            this.eventBus.publish({ type: 'message:text', sessionId: session.id, text: visibleText, isFinal: false });
+                        }
+                        if (visibleText && !shouldSuppress()) {
+                            renderer.addText(visibleText, event.outputTokens, event.turn);
+                            hasProjectedCurrentReplyText = true;
                         }
                     }
                     // compact 完成
@@ -3692,7 +3993,7 @@ export class ResponseEngine {
                         madeProgress = true;
                         this.eventBus.publish({ type: 'runner:compact-complete', sessionId: session.id, preTokens: event.preTokens });
                         if (!shouldSuppress()) {
-                            renderer.addNotice(`\ud83d\udca1 会话压缩完成，继续执行...）`, 'info', 'compact');
+                            await this.emitOperationalNotice(renderer, '\ud83d\udca1 会话压缩完成，继续执行...', 'info', 'compact');
                         }
                     }
                     // 子任务进度
@@ -3718,6 +4019,7 @@ export class ResponseEngine {
                         }
                         // 重置最后回复追踪
                         lastReplyText = '';
+                        hasProjectedCurrentReplyText = false;
                         this.eventBus.publish({
                             type: 'tool:use',
                             sessionId: session.id,
@@ -3830,7 +4132,7 @@ export class ResponseEngine {
                         // 但用户主动中断（新消息打断 或 /stop 命令）时不显示错误提示
                         // 上下文过长的错误留给外层 isPromptTooLong 触发 auto-compact，不在此处输出
                         const interruptReason = this.interruptedSessions.get(session.id);
-                        const isUserInterrupt = interruptReason === 'new_message' || interruptReason === 'stop' || interruptReason === 'recalled';
+                        const isUserInterrupt = isNonErrorInterruptReason(interruptReason);
                         const isContextTooLong = event.terminalReason === 'prompt_too_long'
                             || isContextTooLongText(event.errors?.join(' ') || '')
                             || isContextTooLongText(lastReplyText);
@@ -3899,7 +4201,7 @@ export class ResponseEngine {
         catch (error) {
             // User interrupt (AbortError) is expected, log at info level
             const catchInterruptReason = this.interruptedSessions.get(session.id);
-            const catchIsUserInterrupt = catchInterruptReason === 'new_message' || catchInterruptReason === 'stop' || catchInterruptReason === 'recalled';
+            const catchIsUserInterrupt = isNonErrorInterruptReason(catchInterruptReason);
             if (catchInterruptReason === 'timeout') {
                 logger.info('[ResponseEngine] Stream closed by timeout barrier');
                 throw this.timeoutErrors.get(session.id) ?? new Error('SDK_TIMEOUT');