evolcore 0.0.2 → 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,21 +516,107 @@ export class ResponseEngine {
         if (!session)
             return;
         this.turnCoordinator.hydrate(session);
-        this.turnCoordinator.invalidate(sessionId, reason);
-        this.interruptedSessions.set(sessionId, reason);
-        await this.interactionRouter?.cancelAll(sessionId, reason);
-        const agent = this.getAgent(session.metadata?.channelKey || session.channel, session.baseagent, session.selfAID);
-        await agent.interrupt(sessionId).catch(error => {
-            logger.debug(`[ResponseEngine] interrupt barrier runner failure: session=${sessionId} error=${error instanceof Error ? error.message : String(error)}`);
-        });
-        const taskId = await this.turnCoordinator.completeInterrupt(session, 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, 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 || effectiveReason === 'timeout')
+                return Promise.resolve();
+            const channelInfo = this.resolveChannelInfo(channelKey);
+            if (!channelInfo)
+                return Promise.resolve();
+            const envelope = buildEnvelope({
+                taskId: interruptedTaskId,
+                sessionId: session.id,
+                channel: channelInfo.adapter.channelName,
+                channelId: session.channelId,
+                agentName: agent.name,
+                chatmode: this.resolveEffectiveChatmodeForSession(session, channelKey, session.channelId),
+                replyContext: {
+                    ...(session.metadata?.replyContext ?? {}),
+                    sessionId: session.id,
+                    threadId: session.threadId || session.metadata?.replyContext?.threadId,
+                },
+            });
+            const payload = {
+                kind: 'status.interrupted',
+                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)}`);
+            });
+        })();
+        const runnerInterrupt = agent.interrupt(sessionId).catch(error => {
+            logger.debug(`[ResponseEngine] interrupt barrier runner failure: session=${sessionId} error=${error instanceof Error ? error.message : String(error)}`);
+        });
+        await Promise.all([terminalStatus, runnerInterrupt]);
+    }
+    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) {
         this.handoffRuntime = runtime;
@@ -460,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 };
         }
@@ -620,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');
@@ -657,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, // 重试分支不调插件钩子
@@ -878,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;
@@ -979,26 +1185,40 @@ export class ResponseEngine {
         const shouldSuppress = () => {
             return outputState.middleOutputMode === 'none';
         };
-        this.shouldSuppressActivities = shouldSuppress();
         let monitor;
         let monitorInterval;
         let totalExecutionTimer;
         let rejectFn;
         let lastIdleSec = 0;
         let timeoutTriggered = false;
+        const timeoutControl = {
+            claimedByInternal: false,
+            terminalDelivered: false,
+            claim: () => {
+                if (!timeoutControl.error || this.interruptedSessions.get(session.id) !== 'timeout')
+                    return undefined;
+                timeoutControl.claimedByInternal = true;
+                return timeoutControl.error;
+            },
+        };
         const rejectAfterInterruptBarrier = (error) => {
             if (timeoutTriggered)
                 return;
             timeoutTriggered = true;
+            timeoutControl.error = error;
             this.timeoutErrors.set(session.id, error);
             this.turnCoordinator.hydrate(session);
             this.turnCoordinator.invalidate(session.id, 'timeout');
             this.interruptedSessions.set(session.id, 'timeout');
-            void this.interruptSession(session.id, 'timeout')
+            const barrier = this.interruptSession(session.id, 'timeout')
                 .catch(interruptError => {
                 logger.debug(`[ResponseEngine] Timeout interrupt barrier failed: ${interruptError instanceof Error ? interruptError.message : String(interruptError)}`);
-            })
-                .finally(() => rejectFn(error));
+            });
+            timeoutControl.barrier = barrier;
+            void barrier.finally(() => {
+                if (!timeoutControl.claimedByInternal)
+                    rejectFn(error);
+            });
         };
         const triggerAttemptId = message.replyContext?.metadata?.triggerAttemptId;
         const resetTimer = (eventType, toolName) => {
@@ -1052,13 +1272,27 @@ export class ResponseEngine {
             totalExecutionTimer.unref?.();
         });
         try {
+            const processingPromise = this._processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, () => lastIdleSec, outputState, timeoutControl);
+            const guardedProcessingPromise = processingPromise.then(async () => {
+                if (!timeoutControl.error)
+                    return;
+                await timeoutControl.barrier;
+                throw timeoutControl.error;
+            });
             await Promise.race([
-                this._processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, () => lastIdleSec, outputState),
+                guardedProcessingPromise,
                 timeoutPromise,
                 totalExecutionPromise,
             ]);
         }
         catch (error) {
+            if (error instanceof Error && (error.message === 'SDK_TIMEOUT' || error.message === 'TOTAL_EXECUTION_TIMEOUT')) {
+                await timeoutControl.barrier;
+                if (!timeoutControl.terminalDelivered) {
+                    await timeoutControl.deliverUnhandled?.(error);
+                }
+                this.timeoutErrors.delete(session.id);
+            }
             // 超时错误：kill 级别已发送诊断信息，无需再发
             // 非超时错误走通用处理
             // 记录错误到健康状态（复用已有 session）
@@ -1111,8 +1345,20 @@ 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' }) {
+    async _processMessageInternal(message, session, absoluteProjectPath, resetTimer, shouldSuppress, getLastIdleSec, outputState = { middleOutputMode: 'all' }, timeoutControl) {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
         const channelKey = this.messageChannelKey(message, session);
         const channelInfo = this.resolveChannelInfo(channelKey);
@@ -1169,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)
@@ -1193,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);
@@ -1327,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（本次任务所有出站消息共用）
@@ -1386,6 +1638,71 @@ export class ResponseEngine {
             replyContext: taskReplyContext(),
             causation: taskCausation,
         });
+        if (timeoutControl) {
+            timeoutControl.deliverUnhandled = async (timeoutError) => {
+                if (timeoutControl.terminalDelivered)
+                    return;
+                timeoutControl.terminalDelivered = true;
+                const isTotalExecutionTimeout = timeoutError.message === 'TOTAL_EXECUTION_TIMEOUT';
+                const totalExecutionMs = this.totalExecutionLimitMs();
+                const statusPayload = {
+                    kind: 'status.timeout',
+                    metadata: isTotalExecutionTimeout
+                        ? { totalExecutionMs }
+                        : { idleSec: getLastIdleSec?.() || undefined },
+                };
+                const idleSec = getLastIdleSec?.() || 0;
+                const userMessage = isTotalExecutionTimeout
+                    ? `⚠️ 任务超过总执行时限（${Math.round(totalExecutionMs / 1000)}秒），已自动中断`
+                    : idleSec > 0
+                        ? `⚠️ 任务超时（${idleSec}秒无响应），已自动中断`
+                        : '⚠️ 任务超时，已自动中断';
+                agent.cleanupStream(streamKey);
+                this.sessionManager.clearProcessingIfTask(session.id, taskId);
+                if (this.activeTaskRuntimeContexts.get(session.id)?.taskId === taskId) {
+                    this.activeTaskRuntimeContexts.delete(session.id);
+                }
+                this.agentDelegationRegistry?.revokeTask(session.id, taskId);
+                const daemonTrigger = this.isTrustedDaemonTrigger(message);
+                if (!daemonTrigger) {
+                    await adapter.send(envelope, statusPayload).catch(() => { });
+                }
+                await adapter.send(envelope, {
+                    kind: 'result.error',
+                    text: userMessage,
+                    reason: isTotalExecutionTimeout ? 'total_execution_timeout' : 'timeout',
+                }).catch(() => { });
+                if (daemonTrigger) {
+                    await adapter.send(envelope, statusPayload).catch(() => { });
+                }
+                this.touchAgentActivity(channelKey);
+                this.publishTriggerExecutionFailure(message, timeoutError.message, {
+                    messageId,
+                    causation: taskCausation,
+                });
+                const errorType = prefixErrorType(ERROR_PREFIX.INFRA, classifyError(timeoutError));
+                this.eventBus.publish({
+                    type: 'task:error',
+                    sessionId: session.id,
+                    error: timeoutError.message,
+                    errorType,
+                    agentName: agentNameForStats,
+                    causation: taskCausation,
+                });
+                recordCausationSpan(taskCausation, 'task.run', {
+                    status: 'failed',
+                    refs: { taskId, sessionId: session.id, messageId },
+                    reason: errorType,
+                });
+                logger.message({
+                    msgId: messageId,
+                    sessionId: session.id,
+                    dir: 'inbound',
+                    status: 'failed',
+                    error: timeoutError.message,
+                });
+            };
+        }
         try {
             const isBackground = this.isBackgroundSession(session, message.channel, message.channelId);
             // 记录收到消息
@@ -1474,19 +1791,32 @@ export class ResponseEngine {
             const peerShort = peerId ? peerId.split('.')[0].split(':')[0] : '?';
             const peerLabel = peerName && peerName !== peerShort ? `${peerShort}(${peerName})` : peerShort;
             logger.info(`[ResponseEngine] session=${session.id} task=${taskId} peer=${peerLabel} chatType=${session.chatType} chatMode=${effectiveChatMode} baseagent=${session.baseagent} msgChatType=${message.chatType ?? 'n/a'}`);
+            // Establish the durable turn before exposing any processing state. This
+            // lets an immediate /stop or replacement message close the same task and
+            // prevents a BusinessTrip reaction from becoming orphaned during setup.
+            turnLease = await this.turnCoordinator.begin(session, taskId);
             // 记录开始处理
             const taskEncrypt = message.replyContext?.metadata?.encrypted != null ? !!(message.replyContext.metadata.encrypted) : undefined;
             this.eventBus.publish({ type: 'task:started', sessionId: session.id, agentName: agentNameForStats, encrypt: taskEncrypt, chatmode, causation: taskCausation });
             this.touchAgentActivity(channelKey);
+            // Upgrade the channel acknowledgement at task start, before compaction and
+            // runner setup, so processing feedback remains visible for the whole run.
+            // Trigger messageId is an internal runId and has no channel reaction.
+            if (message.messageId && message.source !== 'trigger') {
+                adapter.promoteAck?.(message.messageId, {
+                    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({
@@ -1495,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) => {
@@ -1538,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}`);
             }
@@ -1659,7 +1999,6 @@ export class ResponseEngine {
                     recordTriggerExecutionAnomaly(triggerRunId, anomaly);
                 }
                 : undefined;
-            turnLease = await this.turnCoordinator.begin(session, taskId);
             // 设置权限审批的交互上下文（支持交互卡片）
             agent.setPermissionContext?.(session.id, {
                 sendPrompt: permissionPromptForOrigin,
@@ -1681,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,
@@ -1985,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 = {
@@ -2057,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,
@@ -2136,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;
                             }
@@ -2205,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 = {
@@ -2255,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) => {
@@ -2270,19 +2622,26 @@ export class ResponseEngine {
                         logger.error('[ResponseEngine] Failed to record retry health status:', statusError);
                     }
                 };
-                // Runner 开始执行前：将 Pin 升级为 CheckMark（表示"正在处理"）。
-                // Trigger messageId is an internal runId, so there is no channel ack to promote.
-                if (message.messageId && message.source !== 'trigger') {
-                    adapter.promoteAck?.(message.messageId).catch(() => { });
-                }
                 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))) {
@@ -2298,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);
                         }
@@ -2328,7 +2695,7 @@ export class ResponseEngine {
                             runAttempt++;
                             continue;
                         }
-                        if (isRetryableError(retryError)) {
+                        if (retryAttemptTimedOut || isRetryableError(retryError)) {
                             if (didRetryMakeProgress(retryError)) {
                                 consecutiveRetryFailures = 0;
                             }
@@ -2344,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));
                                 // 延迟后再次检查中断状态（延迟期间可能收到中断信号）
@@ -2360,6 +2727,9 @@ export class ResponseEngine {
                         }
                         throw retryError; // 不可重试或已耗尽重试次数
                     }
+                    finally {
+                        attemptTimeout?.clear();
+                    }
                 }
             }
             catch (error) {
@@ -2383,6 +2753,10 @@ export class ResponseEngine {
                     throw error;
                 }
             }
+            const pendingTimeoutError = timeoutControl?.claim();
+            if (pendingTimeoutError) {
+                throw pendingTimeoutError;
+            }
             if (permissionTerminalFailure) {
                 renderer.discardPending();
                 streamResult = {
@@ -2418,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);
@@ -2495,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;
@@ -2591,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);
@@ -2602,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 也不会永久处于"处理中"）
@@ -2632,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 {
@@ -2673,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，
@@ -2696,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',
@@ -2734,6 +3113,12 @@ export class ResponseEngine {
                     return;
                 }
                 const durationMs = Date.now() - startTime;
+                const statsModel = streamResult.lastModelCall?.model
+                    || streamResult.model
+                    || streamResult.contextUsage?.model
+                    || modelOverride?.model
+                    || agentModel
+                    || 'unknown';
                 // ── Stats: 写入 usage_events（在 status.completed 之前，以便带上 cost） ──
                 // cost 含原价(official)与网关实际价(gateway)两套，由 insertUsageEvent 写库时一并算出。
                 let turnCost = { official: null, gateway: null };
@@ -2745,7 +3130,6 @@ export class ResponseEngine {
                             || (configActorId
                                 ? formatPeerKey(configChannelType, configActorId)
                                 : formatPeerKey(configChannelType, message.channelId));
-                        const statsModel = streamResult.contextUsage?.model || 'unknown';
                         const ctxPct = streamResult.contextUsage?.percentage;
                         const event = normalizeUsage(streamResult.tokenUsage, {
                             ts: Date.now(),
@@ -2803,7 +3187,6 @@ export class ResponseEngine {
                 try {
                     const { resolveModelSpec } = await import('../../stats/billing.js');
                     const { querySessionSummary } = await import('../../stats/query.js');
-                    const statsModel = streamResult.contextUsage?.model || 'unknown';
                     modelSpec = resolveModelSpec(resolveRoot(), statsModel);
                     const sum = querySessionSummary(resolveRoot(), session.id);
                     if (sum.calls > 0) {
@@ -2848,7 +3231,7 @@ export class ResponseEngine {
                         let lastModelCall = streamResult.lastModelCall;
                         if (lastModelCall?.tokenUsage) {
                             try {
-                                const lastModel = lastModelCall.model || streamResult.contextUsage?.model || 'unknown';
+                                const lastModel = lastModelCall.model || statsModel;
                                 const lastEvent = normalizeUsage(lastModelCall.tokenUsage, {
                                     ts: Date.now(), agent_aid: '', peer_key: '', session_id: session.id,
                                     model: lastModel, turns: 1,
@@ -2950,7 +3333,14 @@ export class ResponseEngine {
             });
         }
         catch (error) {
-            if (error instanceof Error && (error.message === 'SDK_TIMEOUT' || error.message === 'TOTAL_EXECUTION_TIMEOUT')) {
+            const authoritativeTimeoutError = timeoutControl?.claim();
+            if (authoritativeTimeoutError) {
+                error = authoritativeTimeoutError;
+                await timeoutControl?.barrier;
+            }
+            const handlingTimeout = error instanceof Error
+                && (error.message === 'SDK_TIMEOUT' || error.message === 'TOTAL_EXECUTION_TIMEOUT');
+            if (handlingTimeout) {
                 this.timeoutErrors.delete(session.id);
             }
             const leaseWasCurrent = !!turnLease && this.turnCoordinator.isCurrent(turnLease);
@@ -2978,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);
@@ -3055,7 +3442,7 @@ export class ResponseEngine {
             if (isUserInterrupt) {
                 logger.info(`[ResponseEngine] User interrupt by new_message, skip sending error message`);
             }
-            else if (error?._errorAlreadySent && !retryExhaustedCount) {
+            else if (error?._errorAlreadySent && !retryExhaustedCount && !isTimeout && !isTotalExecutionTimeout) {
                 logger.info(`[ResponseEngine] Error already sent via renderer, skip sending duplicate message`);
             }
             else {
@@ -3103,6 +3490,15 @@ export class ResponseEngine {
                     }).catch(() => { });
                 }
             }
+            if (handlingTimeout && timeoutControl) {
+                timeoutControl.terminalDelivered = true;
+            }
+        }
+        finally {
+            // 同一 session 的新任务可能已替换登记；旧任务结束时不得删掉新任务的 renderer。
+            if (this.activeRenderers.get(session.id)?.taskId === taskId) {
+                this.activeRenderers.delete(session.id);
+            }
         }
         // [迁移探针] 任务收尾：记录工具提醒最终状态并落盘（防线 1）
         if (snapshot.isEnabled()) {
@@ -3112,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;
@@ -3123,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})`);
@@ -3140,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 {
@@ -3206,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);
@@ -3225,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);
@@ -3291,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 };
@@ -3304,6 +3722,7 @@ export class ResponseEngine {
         const finalizeResult = () => ({
             ...completeResult,
             hasReceivedText,
+            hasProjectedCurrentReplyText,
             inputAccepted,
             assistantUuid,
             protocolIncompleteReason,
@@ -3374,7 +3793,7 @@ export class ResponseEngine {
                     assistantUuid = event.assistantUuid ?? assistantUuid;
                     protocolIncompleteReason = event.protocolIncompleteReason ?? protocolIncompleteReason;
                 }
-                // 记录事件类型：高价值事件（text/tool_use/tool_result/complete/error/compact/task_progress）INFO，
+                // 记录事件类型：高价值事件（含子任务生命周期）INFO，
                 // 框架事件（session_id/state_changed/status）DEBUG
                 let eventDetail = '';
                 if (event.type === 'text' && event.text) {
@@ -3429,18 +3848,144 @@ 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,
+                        taskId: event.taskId,
+                        taskKind: event.taskKind,
+                        toolUseId: event.toolUseId,
+                        description: event.description,
+                        subagentType: event.subagentType,
+                        taskType: event.taskType,
+                        workflowName: event.workflowName,
+                        prompt: event.prompt,
+                        skipTranscript: event.skipTranscript,
+                        timestamp: Date.now(),
+                        causation,
+                    });
+                    if (!event.skipTranscript) {
+                        renderer.addLifecycle('started', {
+                            scope: 'runner_task',
+                            taskId: event.taskId,
+                            taskKind: event.taskKind,
+                            toolUseId: event.toolUseId,
+                            description: event.description,
+                            subagentType: event.subagentType,
+                            taskType: event.taskType,
+                        }, `${event.taskKind === 'agent' ? 'Agent' : 'Background'} task started: ${event.description}`);
+                    }
+                    continue;
+                }
+                if (event.type === 'background_tasks_changed') {
+                    this.eventBus.publish({
+                        type: 'runner:background-tasks-changed',
+                        sessionId: session.id,
+                        tasks: event.tasks,
+                        timestamp: Date.now(),
+                        causation,
+                    });
+                    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,
+                        taskId: event.taskId,
+                        taskKind: event.taskKind,
+                        toolUseId: event.toolUseId,
+                        description: event.description,
+                        subagentType: event.subagentType,
+                        status: event.status,
+                        outputFile: event.outputFile,
+                        summary: event.summary,
+                        usage: event.usage,
+                        skipTranscript: event.skipTranscript,
+                        timestamp: Date.now(),
+                        causation,
+                    });
+                    if (!event.skipTranscript) {
+                        const label = event.description || event.taskId;
+                        renderer.addLifecycle('completed', {
+                            scope: 'runner_task',
+                            taskId: event.taskId,
+                            taskKind: event.taskKind,
+                            toolUseId: event.toolUseId,
+                            description: event.description,
+                            subagentType: event.subagentType,
+                            status: event.status,
+                            outputFile: event.outputFile,
+                            summary: event.summary,
+                            usage: event.usage,
+                        }, `${event.taskKind === 'agent' ? 'Agent' : 'Background'} task ${event.status}: ${label}`);
+                    }
+                    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,
+                        taskId: event.taskId,
+                        taskKind: event.taskKind,
+                        toolUseId: event.toolUseId,
+                        description: event.description,
+                        subagentType: event.subagentType,
+                        summary: event.summary,
+                        lastToolName: event.lastToolName,
+                        totalTokens: event.totalTokens,
+                        toolUses: event.toolUses,
+                        durationMs: event.durationMs,
+                        timestamp: Date.now(),
+                        causation,
+                    });
+                }
                 const isCurrentlyBackground = this.isBackgroundSession(session, session.channel, session.channelId);
                 // === 前台任务：正常处理所有事件 ===
                 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 完成
@@ -3448,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');
                         }
                     }
                     // 子任务进度
@@ -3474,6 +4019,7 @@ export class ResponseEngine {
                         }
                         // 重置最后回复追踪
                         lastReplyText = '';
+                        hasProjectedCurrentReplyText = false;
                         this.eventBus.publish({
                             type: 'tool:use',
                             sessionId: session.id,
@@ -3570,14 +4116,14 @@ export class ResponseEngine {
                     // 仅记录状态，最终 flush(true) 在流结束后统一执行
                     if (event.type === 'complete') {
                         const isAbort = event.terminalReason === 'aborted_streaming' || event.terminalReason === 'aborted_tools';
-                        logger.info(`[ResponseEngine] ${isAbort ? 'task interrupted' : 'complete event'}: isError=${event.isError} terminalReason=${event.terminalReason ?? 'none'} subtype=${event.subtype ?? 'none'} hasReceivedText=${hasReceivedText}`);
+                        logger.info(`[ResponseEngine] ${isAbort ? 'task interrupted' : 'complete event'}: queryFinal=${event.queryFinal !== false} isError=${event.isError} terminalReason=${event.terminalReason ?? 'none'} subtype=${event.subtype ?? 'none'} hasReceivedText=${hasReceivedText}`);
                         // 自动回填会话名称
                         if (event.sessionTitle && shouldAutoFillSessionTitle(session.name, session.threadId)) {
                             await this.sessionManager.renameSession(session.id, event.sessionTitle);
                             logger.info(`[ResponseEngine] 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, lastModelCall: event.lastModelCall, modelCalls: event.modelCalls };
+                        completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, ttftMs: event.ttftMs, model: event.model, tokenUsage: event.tokenUsage, contextUsage: event.contextUsage, lastModelCall: event.lastModelCall, modelCalls: event.modelCalls };
                         if (!event.isError)
                             madeProgress = true;
                         // thought jsonl 写入已下沉到 aun.ts:sendThought 成功后，
@@ -3586,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);
@@ -3613,7 +4159,7 @@ export class ResponseEngine {
                         }
                         // 检测 proactive 标志位，设置 lastProactiveFlag 供模式切换提示使用
                         // [迁移点5] 标志位检查：由 ProactiveMode.onComplete 实现
-                        if (modeHooks?.mode?.onComplete && lastReplyText) {
+                        if (event.queryFinal !== false && modeHooks?.mode?.onComplete && lastReplyText) {
                             await modeHooks.mode.onComplete({
                                 session,
                                 state: modeHooks.state,
@@ -3647,7 +4193,7 @@ export class ResponseEngine {
                     logger.info(`[ResponseEngine] 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, lastModelCall: event.lastModelCall };
+                completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, ttftMs: event.ttftMs, model: event.model, tokenUsage: event.tokenUsage, contextUsage: event.contextUsage, lastModelCall: event.lastModelCall };
                 if (event.subtype === 'success')
                     madeProgress = true;
             }
@@ -3655,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');