evolclaw 2.8.3 → 3.0.0

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

@@ -2,32 +2,55 @@ import path from 'path';
 import fs from 'fs';
 import crypto from 'crypto';
 import { hasCompact } from '../../agents/claude-runner.js';
-import { StreamFlusher } from './stream-flusher.js';
-import { ThoughtEmitter } from './thought-emitter.js';
+import { appendMessageLog, buildOutboundEntry } from './message-log.js';
+import { IMRenderer } from './im-renderer.js';
 import { StreamIdleMonitor } from './stream-idle-monitor.js';
 import { logger } from '../../utils/logger.js';
 import { getErrorMessage, classifyError, ErrorType, ERROR_PREFIX, isInfraError, prefixErrorType, isRetryableError } from '../../utils/error-utils.js';
 import { summarizeToolInput } from '../permission.js';
 import { DEFAULT_PERMISSION_MODE } from '../../types.js';
-import { getOwner } from '../../config.js';
 import { getPackageRoot, resolveRoot } from '../../paths.js';
 import { renderPromptSection } from '../../agents/templates.js';
+import { renderActionAsText, renderCommandCardAsText } from '../interaction-router.js';
+/**
+ * 构造 OutboundEnvelope —— 出站三件套的信封部分。
+ *
+ * 用于所有走 adapter.send 的出站路径：
+ *  - 任务流内的 IMRenderer 投影（chatmode 由会话决定）
+ *  - 命令回显（MessageBridge.handleCommand，taskId 用合成 ID `cmd-...`）
+ *  - 网关层系统通知（src/index.ts，taskId 用 `system-...` / `restart-...` 等便于 events.log 关联）
+ *
+ * 注意：
+ *  - chatmode 缺省 `'interactive'`（系统通知 / 命令回显都属于同步交互）；
+ *  - timestamp 可由调用方注入（便于测试），缺省 `Date.now()`。
+ */
+export function buildEnvelope(opts) {
+    return {
+        taskId: opts.taskId ?? `interaction-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        channel: opts.channel,
+        channelId: opts.channelId,
+        agentName: opts.agentName ?? '<unknown>',
+        chatmode: opts.chatmode ?? 'interactive',
+        replyContext: opts.replyContext,
+        timestamp: opts.timestamp ?? Date.now(),
+    };
+}
 /**
  * 统一消息处理器
  * 负责处理来自不同渠道的消息，协调事件流处理
  */
 export class MessageProcessor {
     sessionManager;
-    config;
+    globalSettings;
     messageCache;
     eventBus;
     commandHandler;
     channels = new Map();
     channelTypeMap = new Map(); // channelType → channelName（首个实例）
-    currentFlusher;
+    currentRenderer;
     shouldSuppressActivities = false;
     agentMap;
-    defaultAgentId;
+    primaryRunnerKey;
     interruptedSessions = new Map(); // sessionId → reason ('new_message' | 'stop' | ...)
     interactionRouter;
     messageQueue;
@@ -38,18 +61,18 @@ export class MessageProcessor {
      * - `channel` is used to look up the owning EvolAgent (via registry).
      * - `baseagent` (e.g. 'claude') comes from `session.agentId`.
      *
-     * Falls back to `defaultAgentId` (a composite key, e.g. `[default]::claude`)
+     * Falls back to `primaryRunnerKey` (a composite key, e.g. `aid::claude`)
      * when no match is found.
      */
     getAgent(channel, baseagent) {
         if (channel && baseagent) {
-            const evolName = this.agentRegistry?.resolveByChannel(channel)?.name || '[default]';
+            const evolName = this.agentRegistry?.resolveByChannel(channel)?.name || '<unknown>';
             const key = `${evolName}::${baseagent}`;
             if (this.agentMap.has(key))
                 return this.agentMap.get(key);
         }
-        if (this.agentMap.has(this.defaultAgentId))
-            return this.agentMap.get(this.defaultAgentId);
+        if (this.agentMap.has(this.primaryRunnerKey))
+            return this.agentMap.get(this.primaryRunnerKey);
         return this.agentMap.values().next().value;
     }
     /** 获取可用 agent 列表 */
@@ -63,23 +86,23 @@ export class MessageProcessor {
         const active = await this.sessionManager.getActiveSession(channel, channelId);
         return active ? session.id !== active.id : false;
     }
-    constructor(agentRunnerOrMap, sessionManager, config, messageCache, eventBus, commandHandler, defaultAgentId) {
+    constructor(agentRunnerOrMap, sessionManager, globalSettings, messageCache, eventBus, commandHandler, primaryRunnerKey) {
         this.sessionManager = sessionManager;
-        this.config = config;
+        this.globalSettings = globalSettings;
         this.messageCache = messageCache;
         this.eventBus = eventBus;
         this.commandHandler = commandHandler;
         if (agentRunnerOrMap instanceof Map) {
             this.agentMap = agentRunnerOrMap;
-            this.defaultAgentId = defaultAgentId || '[default]::claude';
+            this.primaryRunnerKey = primaryRunnerKey || '<unknown>::claude';
         }
         else {
-            // Backward-compat single-runner path.
-            this.agentMap = new Map([[`[default]::${agentRunnerOrMap.name}`, agentRunnerOrMap]]);
-            this.defaultAgentId = `[default]::${agentRunnerOrMap.name}`;
+            // 测试 / 单 runner 路径：占位 agent name 用 '<unknown>'
+            this.agentMap = new Map([[`<unknown>::${agentRunnerOrMap.name}`, agentRunnerOrMap]]);
+            this.primaryRunnerKey = `<unknown>::${agentRunnerOrMap.name}`;
         }
         // 监听中断事件，标记被中断的 session
-        this.eventBus.subscribe('message:interrupted', (event) => {
+        this.eventBus.subscribe('task:interrupted', (event) => {
             if ('sessionId' in event && event.sessionId) {
                 this.interruptedSessions.set(event.sessionId, event.reason || 'unknown');
             }
@@ -101,7 +124,7 @@ export class MessageProcessor {
         const agent = this.agentRegistry.resolveByChannel(channelName);
         if (!agent)
             return null;
-        const globalCm = this.config.chatmode;
+        const globalCm = this.agentRegistry?.resolveByChannel(channelName)?.config?.chatmode;
         return agent.getContext(channelName, chatType, globalCm);
     }
     /**
@@ -132,10 +155,10 @@ export class MessageProcessor {
      */
     handleCompactStart(sessionId) {
         if (sessionId) {
-            this.eventBus.publish({ type: 'agent:compact-start', sessionId });
+            this.eventBus.publish({ type: 'runner:compact-start', sessionId });
         }
-        if (this.currentFlusher && !this.shouldSuppressActivities) {
-            this.currentFlusher.addActivity('\u23f3 会话压缩中...');
+        if (this.currentRenderer && !this.shouldSuppressActivities) {
+            this.currentRenderer.addNotice('\u23f3 会话压缩中...', 'info', 'compact-start', true);
         }
     }
     /**
@@ -170,7 +193,7 @@ export class MessageProcessor {
      * 处理消息（主入口）
      */
     async processMessage(message) {
-        const idleMs = (this.config.idleMonitor?.timeout ?? 120) * 1000;
+        const idleMs = (this.globalSettings.idleMonitor?.timeout ?? 120) * 1000;
         // 先解析会话，再优先用 session.metadata.channelName 精确定位实例级 adapter
         // message.channel 现在存实例名（channelName），可直接用于精确路由
         const { session, absoluteProjectPath } = await this.resolveSession(message);
@@ -184,6 +207,7 @@ export class MessageProcessor {
         const streamKey = session.id;
         const chatType = message.chatType || 'private';
         const identityRole = session.identity?.role || 'anonymous';
+        const agentNameForMonitor = this.agentRegistry?.resolveByChannel(channelKey)?.name ?? '<unknown>';
         // Resolve agent context from registry (Phase 2 foundation)
         const agentContext = this.getAgentContext(channelKey, chatType);
         if (agentContext) {
@@ -191,7 +215,7 @@ export class MessageProcessor {
         }
         // 按 session.agentId 选择 agent 后端
         const agent = this.getAgent(channelKey, session.agentId);
-        const monitorEnabled = this.config.idleMonitor?.enabled !== false;
+        const monitorEnabled = this.globalSettings.idleMonitor?.enabled !== false;
         const showIdleMonitor = policy.showIdleMonitor(chatType, identityRole);
         // 计算是否抑制中间输出（工具活动 + 流式文本）
         const shouldSuppress = () => {
@@ -217,13 +241,13 @@ export class MessageProcessor {
                 while (result) {
                     if (result.action === 'kill') {
                         logger.warn(`[MessageProcessor] Idle monitor: kill after ${result.idleSec}s idle, stream: ${streamKey}`);
-                        this.eventBus.publish({ type: 'agent:idle-timeout', sessionId: streamKey, idleSec: result.idleSec });
+                        this.eventBus.publish({ type: 'runner:idle-timeout', sessionId: streamKey, idleSec: result.idleSec });
                         // 后台任务也需要中断（释放资源），但不发送通知
                         if (channelInfo && !isBackground) {
                             const msg = showIdleMonitor
                                 ? result.message
                                 : `\u26a0\ufe0f 任务超时（${result.idleSec}秒无响应），已自动中断`;
-                            channelInfo.adapter.sendText(message.channelId, msg, this.getReplyContext(message)).catch(e => {
+                            channelInfo.adapter.send(buildEnvelope({ channel: channelInfo.adapter.channelName, channelId: message.channelId, agentName: agentNameForMonitor }), { kind: 'system.notice', text: msg, subtype: 'health' }).catch(e => {
                                 logger.debug(`[MessageProcessor] Failed to send kill diagnostic message:`, e);
                             });
                         }
@@ -239,7 +263,7 @@ export class MessageProcessor {
                         logger.info(`[MessageProcessor] Idle monitor: ${result.action} after ${result.idleSec}s idle, stream: ${streamKey}`);
                         if (channelInfo && showIdleMonitor && !shouldSuppress()) {
                             if (!isBackground) {
-                                channelInfo.adapter.sendText(message.channelId, result.message, this.getReplyContext(message)).catch(e => {
+                                channelInfo.adapter.send(buildEnvelope({ channel: channelInfo.adapter.channelName, channelId: message.channelId, agentName: agentNameForMonitor }), { kind: 'system.notice', text: result.message, subtype: 'health' }).catch(e => {
                                     logger.debug(`[MessageProcessor] Failed to send idle monitor message:`, e);
                                 });
                             }
@@ -302,8 +326,8 @@ export class MessageProcessor {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
         const channelKey = session.metadata?.channelName || message.channel;
         const channelInfo = this.resolveChannelInfo(channelKey);
-        // Per-method agent name for stats bucketing (agent.name or '[default]')
-        const agentNameForStats = this.agentRegistry?.resolveByChannel(channelKey)?.name ?? '[default]';
+        // Per-method agent name for stats bucketing (agent.name or '<unknown>')
+        const agentNameForStats = this.agentRegistry?.resolveByChannel(channelKey)?.name ?? '<unknown>';
         if (!channelInfo) {
             logger.error(`[MessageProcessor] Unknown channel: ${channelKey}`);
             return;
@@ -329,8 +353,16 @@ export class MessageProcessor {
                 metadata: { ...(base?.metadata ?? {}), taskId, chatmode },
             };
         };
-        // Proactive 模式可观测：ThoughtEmitter 声明在 try 外，catch 块也能透传错误为 thought
-        let thoughtEmitter = null;
+        const isProactive = session.sessionMode === 'proactive';
+        const isAutonomous = session.sessionMode === 'autonomous' || message.triggerMeta?.silent === true;
+        const envelope = buildEnvelope({
+            taskId,
+            channel: message.channel,
+            channelId: message.channelId,
+            agentName: agentNameForStats,
+            chatmode: isProactive ? 'proactive' : 'interactive',
+            replyContext: taskReplyContext(),
+        });
         try {
             const isBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
             // 记录收到消息
@@ -360,8 +392,11 @@ export class MessageProcessor {
             const peerLabel = peerName && peerName !== peerShort ? `${peerShort}(${peerName})` : peerShort;
             logger.info(`[MessageProcessor] session=${session.id} task=${taskId} peer=${peerLabel} chatType=${session.chatType} sessionMode=${session.sessionMode} agentId=${session.agentId} msgChatType=${message.chatType ?? 'n/a'}`);
             // 记录开始处理
-            this.eventBus.publish({ type: 'message:processing', sessionId: session.id });
-            adapter.sendProcessingStatus?.(message.channelId, 'start', session.id, taskId, taskReplyContext());
+            this.eventBus.publish({ type: 'task:started', sessionId: session.id });
+            // 触发器消息不发 processing status（无需通知用户）
+            if (message.source !== 'trigger') {
+                adapter.send(envelope, { kind: 'status.started' }).catch(() => { });
+            }
             logger.message({
                 msgId: messageId,
                 sessionId: session.id,
@@ -369,42 +404,43 @@ export class MessageProcessor {
                 status: 'processing'
             });
             const startTime = Date.now();
-            // 创建 StreamFlusher，传入文件标记模式用于自动过滤
-            // 使用动态判断，确保切换项目后不会继续输出
+            // 创建 IMRenderer（统一 interactive/proactive 两条路径）
             let firstReply = true;
-            const isProactive = session.sessionMode === 'proactive';
-            const flusher = new StreamFlusher(async (text, isFinal, hasText) => {
-                const isCurrentlyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
-                if (!isCurrentlyBackground) {
+            const renderer = new IMRenderer({
+                adapter,
+                envelope,
+                flushDelay: (options?.flushDelay ?? this.agentRegistry?.resolveByChannel(channelKey)?.config?.flush_delay ?? 3) * 1000,
+                suppressActivities: shouldSuppress() || isAutonomous,
+                fileMarkerPattern: options?.fileMarkerPattern,
+                diagEnabled: this.globalSettings.debug?.flusherDiag,
+                send: async (payload) => {
+                    if (isAutonomous)
+                        return; // autonomous session: never send to channel
+                    const isCurrentlyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
+                    if (isCurrentlyBackground)
+                        return;
                     const opts = {};
-                    if (isFinal)
-                        opts.title = '\u2713 \u6700\u7ec8\u56de\u590d:';
-                    // replyContext 跟着任务走：优先用当前 message 的，兜底用 session 的（话题会话创建时写入）
-                    const replyCtx = this.getReplyContext(message);
-                    if (replyCtx) {
-                        Object.assign(opts, replyCtx);
+                    const baseReplyCtx = this.getReplyContext(message);
+                    if (baseReplyCtx) {
+                        Object.assign(opts, baseReplyCtx);
                     }
                     else if (firstReply && message.messageId) {
-                        // 主会话：首条消息引用回复用户原消息（只在含真实文字时消费）
-                        if (hasText) {
+                        if (payload.kind === 'result.text' && payload.text) {
                             opts.replyToMessageId = message.messageId;
                             firstReply = false;
                         }
                     }
+                    if (payload.kind === 'result.text' && payload.isFinal) {
+                        opts.title = '\u2713 \u6700\u7ec8\u56de\u590d:';
+                    }
                     opts.metadata = { ...(opts.metadata ?? {}), taskId, chatmode };
-                    await adapter.sendText(message.channelId, text, opts);
-                }
-                // 后台任务：静默，不发送输出
-            }, (options?.flushDelay ?? this.config.flushDelay ?? 3) * 1000, options?.fileMarkerPattern, this.config.debug?.flusherDiag, isProactive);
-            // 保存当前 flusher，用于 compact 事件
-            this.currentFlusher = flusher;
+                    const enrichedEnvelope = { ...envelope, replyContext: opts };
+                    await adapter.send(enrichedEnvelope, payload);
+                },
+            });
+            this.currentRenderer = renderer;
             if (isProactive) {
-                logger.info(`[MessageProcessor] proactive mode: flusher silent, outputs via thought.put task=${taskId}`);
-            }
-            // Proactive 模式可观测：创建 ThoughtEmitter，将静默的流式事件转发为 thought
-            // selector: context = { type: 'task', id: taskId }
-            if (isProactive && adapter.putThought) {
-                thoughtEmitter = new ThoughtEmitter(adapter, message.channelId, taskId, chatmode, this.getReplyContext(message));
+                logger.info(`[MessageProcessor] proactive mode: outputs via thought.put task=${taskId}`);
             }
             // 调用 AgentRunner（含上下文过长自动 compact 重试）
             // 捕获当前消息的上下文（闭包），避免后续消息处理时串台
@@ -412,7 +448,7 @@ export class MessageProcessor {
             const capturedReplyContext = taskReplyContext();
             // 设置权限审批的消息发送回调（指向当前渠道）
             agent.setSendPrompt(async (text) => {
-                await adapter.sendText(capturedChannelId, text, capturedReplyContext);
+                await adapter.send({ ...envelope, replyContext: capturedReplyContext }, { kind: 'result.text', text, isFinal: true });
             });
             // 设置权限审批的交互上下文（支持交互卡片）
             agent.setPermissionContext?.(session.id, {
@@ -420,6 +456,11 @@ export class MessageProcessor {
                 channelId: capturedChannelId,
                 replyContext: capturedReplyContext,
                 interactionRouter: this.interactionRouter,
+                userId: message.peerId || undefined,
+                channel: message.channel,
+                agentName: agentNameForStats,
+                taskId,
+                chatmode: isProactive ? 'proactive' : 'interactive',
                 interceptNextMessage: this.messageQueue
                     ? (sessionKey, handler) => this.messageQueue.interceptNext(sessionKey, handler)
                     : undefined,
@@ -442,6 +483,7 @@ export class MessageProcessor {
                 ? `【新消息插入】\n\n${message.content}\n\n【请无视之前中断继续处理】`
                 : message.content;
             let streamResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
+            let effectiveSystemPrompt;
             try {
                 // 动态构建运行时上下文提示
                 const contextParts = [];
@@ -465,9 +507,9 @@ export class MessageProcessor {
                 let currentCanSend = false;
                 if (!isProactive) {
                     const fileChannelTypes = new Set();
-                    currentCanSend = !!channelInfo.adapter.sendFile;
+                    currentCanSend = !!(channelInfo.adapter.capabilities?.file);
                     for (const [, info] of this.channels) {
-                        if (info.adapter.sendFile) {
+                        if (info.adapter.capabilities?.file) {
                             fileChannelTypes.add(info.options?.channelType || info.adapter.channelName);
                         }
                     }
@@ -477,10 +519,20 @@ export class MessageProcessor {
                 const capParts = [];
                 if (options?.supportsImages)
                     capParts.push('图片输入');
-                if (channelInfo.adapter.sendImage)
+                if (channelInfo.adapter.capabilities?.image)
                     capParts.push('图片输出');
-                if (channelInfo.adapter.sendFile)
+                if (channelInfo.adapter.capabilities?.file)
                     capParts.push('文件发送');
+                // Personal layer: persona.md + working memory 注入
+                const owningAgent = this.agentRegistry?.resolveByChannel(channelKey);
+                if (owningAgent) {
+                    const persona = owningAgent.getPersona?.();
+                    if (persona)
+                        contextParts.push(persona);
+                    const working = owningAgent.getWorkingMemory?.();
+                    if (working)
+                        contextParts.push(`[当前关注]\n${working}`);
+                }
                 contextParts.push(renderPromptSection('runtime', {
                     channel: currentChannelType,
                     project: path.basename(absoluteProjectPath),
@@ -508,7 +560,13 @@ export class MessageProcessor {
                 if (isProactive) {
                     contextParts.push(renderPromptSection('proactive', {}));
                 }
-                const effectiveSystemPrompt = [options?.systemPromptAppend, ...contextParts].filter(Boolean).join('\n') || undefined;
+                // 4. 触发器功能提示词（非触发器消息时注入，让 AI 知道可以使用触发器）
+                if (message.source !== 'trigger') {
+                    const triggerSection = renderPromptSection('trigger', {});
+                    if (triggerSection)
+                        contextParts.push(triggerSection);
+                }
+                effectiveSystemPrompt = [options?.systemPromptAppend, ...contextParts].filter(Boolean).join('\n') || undefined;
                 // 可重试错误（403/429/5xx）指数退避重试，最多 3 次
                 const MAX_RETRIES = 3;
                 for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
@@ -518,7 +576,7 @@ export class MessageProcessor {
                         const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, session.agentSessionId, message.images, effectiveSystemPrompt, this.sessionManager);
                         agent.registerStream(streamKey, stream);
                         streamRegistered = true;
-                        streamResult = await this.processEventStream(stream, session, flusher, resetTimer, shouldSuppress, thoughtEmitter);
+                        streamResult = await this.processEventStream(stream, session, renderer, resetTimer, shouldSuppress);
                         break; // 成功，跳出重试循环
                     }
                     catch (retryError) {
@@ -528,8 +586,8 @@ export class MessageProcessor {
                         if (attempt < MAX_RETRIES && isRetryableError(retryError)) {
                             const delay = Math.pow(2, attempt) * 1000; // 2s, 4s
                             logger.warn(`[MessageProcessor] Retryable error (attempt ${attempt}/${MAX_RETRIES}), retrying in ${delay}ms:`, retryError);
-                            flusher.addActivity(`⚠️ API 暂时不可用，${delay / 1000}秒后重试 (${attempt}/${MAX_RETRIES})...`);
-                            await flusher.flush();
+                            renderer.addNotice(`⚠️ API 暂时不可用，${delay / 1000}秒后重试 (${attempt}/${MAX_RETRIES})...`, 'warn', 'retry', true);
+                            await renderer.flush();
                             await new Promise(resolve => setTimeout(resolve, delay));
                             continue;
                         }
@@ -540,15 +598,15 @@ export class MessageProcessor {
             catch (error) {
                 if (classifyError(error) === ErrorType.CONTEXT_TOO_LONG && session.agentSessionId && hasCompact(agent)) {
                     // 尝试 compact 压缩会话
-                    flusher.addActivity('\u26a0\ufe0f 上下文过长，正在压缩会话...');
-                    await flusher.flush();
+                    renderer.addNotice('\u26a0\ufe0f 上下文过长，正在压缩会话...', 'warn', 'compact-trigger', true);
+                    await renderer.flush();
                     const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
                     if (compacted) {
                         // compact 成功，带 resume 重试（不重复原始消息，让 Agent 继续未完成的工作）
-                        flusher.addActivity('\u2705 压缩完成，正在重试...');
-                        const retryStream = await agent.runQuery(session.id, '上下文已自动压缩，请继续之前未完成的任务。', absoluteProjectPath, session.agentSessionId, undefined, options?.systemPromptAppend, this.sessionManager);
+                        renderer.addNotice('\u2705 压缩完成，正在重试...', 'info', 'compact-retry', true);
+                        const retryStream = await agent.runQuery(session.id, '上下文已自动压缩，请继续之前未完成的任务。', absoluteProjectPath, session.agentSessionId, undefined, effectiveSystemPrompt, this.sessionManager);
                         agent.registerStream(streamKey, retryStream);
-                        streamResult = await this.processEventStream(retryStream, session, flusher, resetTimer, shouldSuppress, thoughtEmitter);
+                        streamResult = await this.processEventStream(retryStream, session, renderer, resetTimer, shouldSuppress);
                     }
                     else {
                         throw new Error('CONTEXT_COMPACT_FAILED');
@@ -560,12 +618,12 @@ export class MessageProcessor {
             }
             // 处理文件标记 - 支持 [SEND_FILE:path] 和 [SEND_FILE:channel:path]
             // 注意：始终扫描全部文本（含中间轮），因为文件标记可能出现在任意轮次
-            // suppressed 模式下 flusher 只有最后一轮文本，需要用 streamResult.fullText（SDK 全文）兜底
+            // suppressed 模式下 renderer 只有最后一轮文本，需要用 streamResult.fullText（SDK 全文）兜底
             // proactive 模式：agent 主动调用 ctl file 发送文件，跳过标记处理
             if (!isProactive) {
                 const FILE_MARKER_RE = /\[SEND_FILE:(?:(\w+):)?([^\]]+)\]/g;
                 const markerPattern = options?.fileMarkerPattern ?? FILE_MARKER_RE;
-                const flusherText = flusher.getFinalText();
+                const flusherText = renderer.getFinalText();
                 const fullText = flusherText.length >= (streamResult.fullText?.length || 0) ? flusherText : streamResult.fullText;
                 const fileMatches = [...fullText.matchAll(markerPattern)];
                 for (const match of fileMatches) {
@@ -596,22 +654,22 @@ export class MessageProcessor {
                         && targetSpec !== currentChannelType;
                     // 跨通道仅限 owner
                     if (isCrossChannel && session.identity?.role !== 'owner') {
-                        await adapter.sendText(message.channelId, `\u274c 跨通道发送仅限管理员`, taskReplyContext());
+                        await adapter.send(envelope, { kind: 'system.error', text: `\u274c 跨通道发送仅限管理员`, subtype: 'fatal' });
                         continue;
                     }
                     const resolvedPath = this.resolveFilePath(filePath, absoluteProjectPath);
                     if (!fs.existsSync(resolvedPath)) {
                         logger.warn(`[${adapter.channelName}] File not found: ${resolvedPath}`);
-                        await adapter.sendText(message.channelId, `\u26a0\ufe0f 文件未找到: ${filePath}`, taskReplyContext());
+                        await adapter.send(envelope, { kind: 'system.error', text: `\u26a0\ufe0f 文件未找到: ${filePath}`, subtype: 'fatal' });
                         continue;
                     }
                     // 找目标 adapter
                     if (!targetInfo) {
-                        await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 未启用或不存在`, taskReplyContext());
+                        await adapter.send(envelope, { kind: 'system.error', text: `\u274c 通道 ${targetLabel} 未启用或不存在`, subtype: 'channel_down' });
                         continue;
                     }
-                    if (!targetInfo.adapter.sendFile) {
-                        await adapter.sendText(message.channelId, `\u274c 通道 ${targetLabel} 不支持文件发送`, taskReplyContext());
+                    if (!targetInfo.adapter.capabilities?.file) {
+                        await adapter.send(envelope, { kind: 'system.error', text: `\u274c 通道 ${targetLabel} 不支持文件发送`, subtype: 'capability' });
                         continue;
                     }
                     // 找目标 channelId
@@ -619,58 +677,58 @@ export class MessageProcessor {
                     if (isCrossChannel) {
                         const targetAdapterName = targetInfo.adapter.channelName;
                         const targetChannelType = targetInfo.options?.channelType || targetAdapterName;
-                        const ownerPeerId = this.agentRegistry?.getOwner?.(targetAdapterName) ?? getOwner(this.config, targetAdapterName);
+                        const ownerPeerId = this.agentRegistry?.getOwner?.(targetAdapterName);
                         targetChannelId = ownerPeerId ? (this.sessionManager.getOwnerChatId(targetChannelType, ownerPeerId) ?? '') : '';
                         if (!targetChannelId) {
-                            await adapter.sendText(message.channelId, `\u274c 未找到 ${targetLabel} 的私聊会话，请先在该通道发送一条消息`, taskReplyContext());
+                            await adapter.send(envelope, { kind: 'system.error', text: `\u274c 未找到 ${targetLabel} 的私聊会话，请先在该通道发送一条消息`, subtype: 'channel_down' });
                             continue;
                         }
                     }
                     logger.info(`[${adapter.channelName}] Sending file via ${targetInfo.adapter.channelName}: ${resolvedPath}`);
                     try {
-                        await targetInfo.adapter.sendFile(targetChannelId, resolvedPath, taskReplyContext());
-                        this.eventBus.publish({ type: 'agent:file-sent', sessionId: session.id, filePath: resolvedPath, channel: targetInfo.adapter.channelName });
+                        await targetInfo.adapter.send(buildEnvelope({ taskId, channel: targetInfo.adapter.channelName, channelId: targetChannelId, agentName: agentNameForStats, replyContext: taskReplyContext() }), { kind: 'result.file', filePath: resolvedPath });
+                        this.eventBus.publish({ type: 'runner:file-sent', sessionId: session.id, filePath: resolvedPath, channel: targetInfo.adapter.channelName });
                         if (isCrossChannel) {
-                            await adapter.sendText(message.channelId, `\ud83d\udcce 文件已通过 ${targetLabel} 发送`, taskReplyContext());
+                            await adapter.send(envelope, { kind: 'system.notice', text: `\ud83d\udcce 文件已通过 ${targetLabel} 发送`, subtype: 'health' });
                         }
                     }
                     catch (error) {
                         logger.error(`[${adapter.channelName}] Failed to send file: ${resolvedPath}`, error);
-                        await adapter.sendText(message.channelId, `\u274c 文件发送失败: ${filePath}`, taskReplyContext());
+                        await adapter.send(envelope, { kind: 'system.error', text: `\u274c 文件发送失败: ${filePath}`, subtype: 'fatal' });
                     }
                 }
             } // end of !isProactive
-            // 最终回复文本添加到 flusher（统一在流结束后处理，避免多 complete 事件重复发送）
+            // 最终回复文本添加到 renderer（统一在流结束后处理，避免多 complete 事件重复发送）
             // suppressed 模式：中间流式文本未推送，使用最后一轮回复（回退到全文）
             // 非 suppressed 且无流式文本：同上
             // 非 suppressed 且有流式文本：已经逐步推送过了，不重复添加
-            //   但如果 flusher 既未发送过内容也没有 pending 内容（如 text 事件全为空），仍需兜底
+            //   但如果 renderer 既未发送过内容也没有 pending 内容（如 text 事件全为空），仍需兜底
             const finalReplyText = streamResult.lastReplyText || streamResult.fullText;
             // 识别 Claude SDK 本地预处理兜底（如 "Unknown skill: xxx"）：
             // 特征：无流式 text + complete.result 匹配已知模式
             // 这类输出不是 agent 的回复意图，而是 SDK 本地拦截到的"未知斜杠命令"提示。
-            // Proactive 模式下 flusher silent，需要兜底发出以告知用户，否则用户完全无反馈。
+            // Proactive 模式下 renderer silent，需要兜底发出以告知用户，否则用户完全无反馈。
             const isSdkFallbackMessage = !!finalReplyText
                 && !streamResult.hasReceivedText
                 && /^Unknown skill:\s+\S+/i.test(finalReplyText.trim());
             if (finalReplyText) {
                 if (isProactive && isSdkFallbackMessage) {
-                    // Proactive 模式 + SDK 本地兜底：直接 sendText 绕过 silent flusher
+                    // Proactive 模式 + SDK 本地兜底：直接 sendText 绕过 silent renderer
                     const isCurrentlyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
                     if (!isCurrentlyBackground) {
-                        await adapter.sendText(message.channelId, finalReplyText, capturedReplyContext);
+                        await adapter.send({ ...envelope, replyContext: capturedReplyContext }, { kind: 'result.text', text: finalReplyText, isFinal: true });
                         logger.info(`[MessageProcessor] proactive SDK fallback replied task=${taskId} text="${finalReplyText.slice(0, 60)}"`);
                     }
                 }
                 else if (shouldSuppress()) {
-                    flusher.addText(finalReplyText);
+                    renderer.addText(finalReplyText);
                 }
-                else if (!streamResult.hasReceivedText || (!flusher.hasSentContent() && !flusher.hasContent())) {
-                    flusher.addText(finalReplyText);
+                else if (!streamResult.hasReceivedText || (!renderer.hasSentContent() && !renderer.hasContent())) {
+                    renderer.addText(finalReplyText);
                 }
             }
             // Flush 剩余内容（文件标记已在 flush 时自动移除）
-            await flusher.flush(true);
+            await renderer.flush(true);
             // 清理 activeStreams（正常完成）
             agent.cleanupStream(streamKey);
             logger.info(`[MessageProcessor] agent.cleanupStream ok: session=${session.id} task=${taskId}`);
@@ -690,9 +748,14 @@ export class MessageProcessor {
                 const errorSummary = streamResult.errors?.join('; ') || '任务执行失败';
                 const rawSubtype = streamResult.subtype || 'agent_error';
                 const errorType = prefixErrorType(ERROR_PREFIX.AGENT, rawSubtype);
-                adapter.sendProcessingStatus?.(message.channelId, 'error', session.id, taskId, taskReplyContext());
+                if (message.source !== 'trigger') {
+                    adapter.send(envelope, { kind: 'status.error', metadata: { errorType: rawSubtype } }).catch(() => { });
+                }
+                if (message.triggerMeta) {
+                    this.eventBus.publish({ type: 'trigger:failed', triggerId: message.triggerMeta.triggerId, messageId: messageId, error: errorSummary });
+                }
                 this.eventBus.publish({
-                    type: 'message:error',
+                    type: 'task:error',
                     sessionId: session.id,
                     error: errorSummary,
                     errorType,
@@ -719,10 +782,30 @@ export class MessageProcessor {
             }
             else {
                 // 真正的成功
-                adapter.sendProcessingStatus?.(message.channelId, interruptReason ? 'interrupted' : 'done', session.id, taskId, taskReplyContext());
+                const durationMs = Date.now() - startTime;
+                if (message.source !== 'trigger') {
+                    if (interruptReason) {
+                        adapter.send(envelope, { kind: 'status.interrupted', metadata: { reason: interruptReason } }).catch(() => { });
+                    }
+                    else {
+                        adapter.send(envelope, { kind: 'status.completed', metadata: { durationMs } }).catch(() => { });
+                    }
+                }
+                if (message.triggerMeta) {
+                    if (interruptReason) {
+                        this.eventBus.publish({ type: 'trigger:skipped', triggerId: message.triggerMeta.triggerId, reason: 'interrupted' });
+                    }
+                    else {
+                        this.eventBus.publish({ type: 'trigger:completed', triggerId: message.triggerMeta.triggerId, messageId: messageId, durationMs });
+                    }
+                    // Clean up autonomous sessions after completion to avoid accumulating orphaned sessions
+                    if (session.sessionMode === 'autonomous') {
+                        this.sessionManager.unbindSession(session.id).catch(() => { });
+                    }
+                }
                 await this.sessionManager.recordSuccess(session.id);
                 this.eventBus.publish({
-                    type: 'message:completed',
+                    type: 'task:completed',
                     sessionId: session.id,
                     channel: message.channel,
                     channelId: message.channelId,
@@ -740,12 +823,28 @@ export class MessageProcessor {
                     status: 'completed',
                     duration: Date.now() - startTime
                 });
+                // 写入消息记录（出方向）
+                if (streamResult.lastReplyText || streamResult.fullText) {
+                    const chatDir = this.sessionManager.getChatDir(session);
+                    appendMessageLog(chatDir, buildOutboundEntry({
+                        from: message.selfId || session.selfId || 'self',
+                        to: message.peerId || message.channelId,
+                        chatType: (message.chatType || session.chatType || 'private'),
+                        groupId: session.metadata?.groupId ?? null,
+                        msgId: `${messageId}_reply`,
+                        content: streamResult.lastReplyText || streamResult.fullText,
+                        replyTo: message.messageId ?? null,
+                        agent: session.agentId || null,
+                        model: agent.getModel?.() || null,
+                        durationMs: Date.now() - startTime,
+                    }));
+                }
             }
             const isFinallyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
-            if (isFinallyBackground) {
+            if (isFinallyBackground && session.sessionMode !== 'autonomous') {
                 const projectName = path.basename(session.projectPath);
                 const count = this.messageCache.getCount(session.id);
-                await adapter.sendText(message.channelId, `[\u540e\u53f0-${projectName}] \u2713 任务完成 (${count}条消息已缓存)`, taskReplyContext());
+                await adapter.send(envelope, { kind: 'system.notice', text: `[\u540e\u53f0-${projectName}] \u2713 任务完成 (${count}条消息已缓存)`, subtype: 'background' });
             }
             // 记录发送响应
             logger.message({
@@ -774,10 +873,12 @@ export class MessageProcessor {
                     : 'error';
             // 用户主动中断（新消息打断 或 /stop 命令）时静默，不发送中断/错误提示
             if (!isUserInterrupt) {
-                try {
-                    adapter.sendProcessingStatus?.(message.channelId, procStatus, session.id, taskId, taskReplyContext());
-                }
-                catch { }
+                const statusPayload = procStatus === 'timeout'
+                    ? { kind: 'status.timeout' }
+                    : procStatus === 'interrupted'
+                        ? { kind: 'status.interrupted', metadata: { reason: 'stream_error' } }
+                        : { kind: 'status.error' };
+                adapter.send(envelope, statusPayload).catch(() => { });
             }
             // 用户主动中断时降级日志；其余仍按 error 记录
             if (isUserInterrupt) {
@@ -789,7 +890,7 @@ export class MessageProcessor {
             const errorMsg = error instanceof Error ? error.message : String(error);
             const errorType = prefixErrorType(ERROR_PREFIX.INFRA, errType);
             this.eventBus.publish({
-                type: 'message:error',
+                type: 'task:error',
                 sessionId: session.id,
                 error: errorMsg,
                 errorType,
@@ -808,7 +909,7 @@ export class MessageProcessor {
             }
             // 发送用户友好的错误消息（SDK_TIMEOUT 已在 kill 级别发过提示，跳过）
             // 用户主动中断（新消息打断 或 /stop 命令）时静默，不发送错误提示
-            // processEventStream 已通过 flusher 发过错误时也跳过
+            // processEventStream 已通过 renderer 发过错误时也跳过
             if (error instanceof Error && error.message === 'SDK_TIMEOUT') {
                 logger.info(`[MessageProcessor] SDK_TIMEOUT error, skip sending duplicate message`);
             }
@@ -816,14 +917,14 @@ export class MessageProcessor {
                 logger.info(`[MessageProcessor] User interrupt by new_message, skip sending error message`);
             }
             else if (error?._errorAlreadySent) {
-                logger.info(`[MessageProcessor] Error already sent via flusher, skip sending duplicate message`);
+                logger.info(`[MessageProcessor] Error already sent via renderer, skip sending duplicate message`);
             }
             else {
                 const userMessage = getErrorMessage(error, undefined);
                 // 获取 session 用于话题回复（如果 resolveSession 已执行）
                 let sendOpts;
                 try {
-                    await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId);
+                    await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.agentRegistry?.resolveByChannel(message.channel)?.projectPath || process.cwd(), message.threadId);
                     sendOpts = this.getReplyContext(message);
                 }
                 catch { }
@@ -832,15 +933,8 @@ export class MessageProcessor {
                     ...(sendOpts ?? {}),
                     metadata: { ...(sendOpts?.metadata ?? {}), taskId, chatmode },
                 };
-                await adapter.sendText(message.channelId, userMessage, sendOpts);
+                await adapter.send({ ...envelope, replyContext: sendOpts }, { kind: 'result.text', text: userMessage, isFinal: true });
                 // Proactive 可观测：catch 块的基础设施错误也透传为 thought，保证按 task_id 聚合完整
-                if (thoughtEmitter) {
-                    const thoughtErrorType = errType === ErrorType.CONTEXT_TOO_LONG ? 'context_too_long' :
-                        errType === ErrorType.AUTH_ERROR ? 'auth' :
-                            (errType === ErrorType.SDK_TIMEOUT || errType === ErrorType.STREAM_ERROR) ? 'network' :
-                                'unknown';
-                    thoughtEmitter.emit({ type: 'error', error: userMessage, errorType: thoughtErrorType }).catch(() => { });
-                }
             }
         }
     }
@@ -852,7 +946,22 @@ export class MessageProcessor {
         const metadata = (message.threadId && message.replyContext)
             ? { replyContext: message.replyContext }
             : undefined;
-        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId, metadata, undefined, message.peerId);
+        const projectPath = this.agentRegistry?.resolveByChannel(message.channel)?.projectPath || process.cwd();
+        // --session silent 触发器：新建独立 autonomous 会话，与原会话历史隔离
+        if (message.triggerMeta?.silent) {
+            const prevActive = await this.sessionManager.getActiveSession(message.channel, message.channelId);
+            const session = await this.sessionManager.createNewSession(message.channel, message.channelId, projectPath, `trigger-${message.triggerMeta.triggerId.slice(0, 8)}`);
+            await this.sessionManager.updateSession(session.id, { sessionMode: 'autonomous' });
+            session.sessionMode = 'autonomous';
+            if (prevActive) {
+                await this.sessionManager.switchToSession(message.channel, message.channelId, prevActive.id);
+            }
+            const absoluteProjectPath = path.isAbsolute(session.projectPath)
+                ? session.projectPath
+                : path.resolve(process.cwd(), session.projectPath);
+            return { session, absoluteProjectPath };
+        }
+        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, projectPath, message.threadId, metadata, undefined, message.peerId);
         // replyContext 不再写入 session.metadata（跟着 message 走，避免群聊多人覆盖）
         const absoluteProjectPath = path.isAbsolute(session.projectPath)
             ? session.projectPath
@@ -865,9 +974,9 @@ export class MessageProcessor {
      * 此方法只消费标准 AgentEvent 类型，不引用任何 SDK 特有事件。
      * SDK 事件 → AgentEvent 的转换在 AgentRunner.transformStream() 中完成。
      */
-    async processEventStream(stream, session, flusher, resetTimer, shouldSuppress, thoughtEmitter) {
+    async processEventStream(stream, session, renderer, resetTimer, shouldSuppress) {
         // Per-session agent name for stats bucketing
-        const agentNameForStats = this.agentRegistry?.resolveByChannel(session.metadata?.channelName || session.channel)?.name ?? '[default]';
+        const agentNameForStats = this.agentRegistry?.resolveByChannel(session.metadata?.channelName || session.channel)?.name ?? '<unknown>';
         let hasReceivedText = false;
         let hasErrorResult = false; // 是否已有 tool_result/error 事件输出过错误
         let completeResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
@@ -906,10 +1015,8 @@ export class MessageProcessor {
                 else {
                     logger.info(`[MessageProcessor] Event: type=${event.type}${eventDetail}`);
                 }
-                // Proactive 可观测：将事件实时透传为 thought（fire-and-forget）
-                if (thoughtEmitter) {
-                    thoughtEmitter.emit(event).catch(() => { });
-                }
+                // IMRenderer 旁路：proactive 模式逐事件投影为 thought（fire-and-forget）
+                renderer.emit(event);
                 // session_id 已在 AgentRunner.transformStream 中处理，此处仅记录
                 if (event.type === 'session_id') {
                     logger.debug(`[MessageProcessor] Session ID updated: ${event.sessionId} for session: ${session.id}`);
@@ -918,14 +1025,14 @@ export class MessageProcessor {
                 // session 状态变更（idle/running/requires_action）
                 if (event.type === 'state_changed') {
                     logger.debug(`[MessageProcessor] Session state: ${event.state} for session: ${session.id}`);
-                    this.eventBus.publish({ type: 'agent:state-changed', sessionId: session.id, state: event.state });
+                    this.eventBus.publish({ type: 'runner:state-changed', sessionId: session.id, state: event.state });
                     continue;
                 }
                 // agent 状态通知（仅事件，不直出给用户）
                 if (event.type === 'status') {
                     logger.debug(`[MessageProcessor] Agent status: ${event.subtype}: ${event.message}`);
                     this.eventBus.publish({
-                        type: 'agent:status',
+                        type: 'runner:status',
                         sessionId: session.id,
                         subtype: event.subtype,
                         message: event.message,
@@ -942,14 +1049,14 @@ export class MessageProcessor {
                         lastReplyText += event.text;
                         this.eventBus.publish({ type: 'message:text', sessionId: session.id, text: event.text, isFinal: false });
                         if (!shouldSuppress()) {
-                            flusher.addText(event.text);
+                            renderer.addText(event.text);
                         }
                     }
                     // compact 完成
                     if (event.type === 'compact') {
-                        this.eventBus.publish({ type: 'agent:compact-complete', sessionId: session.id, preTokens: event.preTokens });
+                        this.eventBus.publish({ type: 'runner:compact-complete', sessionId: session.id, preTokens: event.preTokens });
                         if (!shouldSuppress()) {
-                            flusher.addActivity(`\ud83d\udca1 会话压缩完成，继续执行...（压缩前 tokens: ${event.preTokens}）`);
+                            renderer.addNotice(`\ud83d\udca1 会话压缩完成，继续执行...（压缩前 tokens: ${event.preTokens}）`, 'info', 'compact');
                         }
                     }
                     // 子任务进度
@@ -958,10 +1065,10 @@ export class MessageProcessor {
                         const duration = event.durationMs ? `${Math.round(event.durationMs / 1000)}s` : '';
                         const stats = [tools > 0 ? `${tools}\u6b21\u5de5\u5177\u8c03\u7528` : '', duration].filter(Boolean).join(', ');
                         if (event.summary && !shouldSuppress()) {
-                            flusher.addActivity(`\u23f3 \u5b50\u4efb\u52a1: ${event.summary}${stats ? ` (${stats})` : ''}`);
+                            renderer.addProgress(`\u5b50\u4efb\u52a1: ${event.summary}${stats ? ` (${stats})` : ''}`, { state: 'processing', toolUses: event.toolUses, durationMs: event.durationMs });
                         }
                         else if (stats && !shouldSuppress()) {
-                            flusher.addActivity(`\u23f3 \u5b50\u4efb\u52a1\u8fdb\u884c\u4e2d: ${stats}`);
+                            renderer.addProgress(`\u5b50\u4efb\u52a1\u8fdb\u884c\u4e2d: ${stats}`, { state: 'processing', toolUses: event.toolUses, durationMs: event.durationMs });
                         }
                     }
                     // 工具调用
@@ -977,7 +1084,7 @@ export class MessageProcessor {
                         });
                         if (!shouldSuppress()) {
                             const desc = summarizeToolInput(event.name, event.input || {});
-                            flusher.addActivity(`\ud83d\udd27 ${event.name}${desc ? ': ' + desc : ''}`);
+                            renderer.addToolCall(event.name, event.input, event.callId, desc);
                         }
                     }
                     // 工具结果
@@ -996,7 +1103,10 @@ export class MessageProcessor {
                             let errorMsg = event.error || (typeof event.result === 'string' ? event.result : JSON.stringify(event.result)) || '\u6267\u884c\u5931\u8d25';
                             // 移除 XML 风格的错误标签
                             errorMsg = errorMsg.replace(/<tool_use_error>(.*?)<\/tool_use_error>/gs, '$1');
-                            flusher.addActivity(`\u26a0\ufe0f ${event.name || '\u5de5\u5177'}: ${errorMsg}`);
+                            renderer.addToolResult(event.name || '\u5de5\u5177', false, undefined, errorMsg, event.callId);
+                        }
+                        else if (!event.isError && !shouldSuppress()) {
+                            renderer.addToolResult(event.name || '\u5de5\u5177', true, event.result, undefined, event.callId);
                         }
                     }
                     // 运行时错误（Codex: turn.failed / item error）
@@ -1004,7 +1114,7 @@ export class MessageProcessor {
                         logger.warn(`[MessageProcessor] error event: ${event.errorType}: ${event.error}`);
                         if (!hasErrorResult && !shouldSuppress()) {
                             hasErrorResult = true;
-                            flusher.addActivity(`\u274c ${event.error}`);
+                            renderer.addNotice(`\u274c ${event.error}`, 'warn', 'runtime-error', true);
                         }
                     }
                     // 完成事件
@@ -1029,12 +1139,12 @@ export class MessageProcessor {
                             const userFriendlyMessage = event.terminalReason
                                 ? getErrorMessage(null, event.terminalReason)
                                 : `\u274c ${errorSummary}`;
-                            flusher.addActivity(userFriendlyMessage);
+                            renderer.addNotice(userFriendlyMessage, 'warn', 'task-error', true);
                         }
                         // 中间 complete：flush 掉已有 activities（不带 isFinal），让中间结果及时显示
                         // 最终文本留给流结束后的统一 flush(true)
-                        if (flusher.hasContent()) {
-                            await flusher.flushActivitiesOnly();
+                        if (renderer.hasContent()) {
+                            await renderer.flushActivitiesOnly();
                         }
                     }
                     continue;
@@ -1068,7 +1178,7 @@ export class MessageProcessor {
                     });
                     // 后台任务完成也纳入统计
                     this.eventBus.publish({
-                        type: 'message:completed',
+                        type: 'task:completed',
                         sessionId: session.id,
                         channel: session.channel,
                         channelId: session.channelId,
@@ -1090,7 +1200,7 @@ export class MessageProcessor {
                     });
                     // 后台任务失败也纳入统计
                     this.eventBus.publish({
-                        type: 'message:error',
+                        type: 'task:error',
                         sessionId: session.id,
                         error: event.errors?.join('; ') || '\u672a\u77e5\u9519\u8bef',
                         errorType: bgErrorType,
@@ -1121,13 +1231,13 @@ export class MessageProcessor {
                 logger.error('[MessageProcessor] Stream processing error:', error);
             }
             if (error instanceof Error && error.message.includes('process exited')) {
-                flusher.addActivity('\u274c Claude Code \u8fdb\u7a0b\u5f02\u5e38\u9000\u51fa\uff0c\u8bf7\u91cd\u8bd5');
+                renderer.addNotice('\u274c Claude Code \u8fdb\u7a0b\u5f02\u5e38\u9000\u51fa\uff0c\u8bf7\u91cd\u8bd5', 'warn', 'process-exit', true);
             }
             // Flush any pending error activities before re-throwing,
             // and mark the error so outer catch won't send a duplicate message
-            if (hasErrorResult || flusher.hasContent()) {
+            if (hasErrorResult || renderer.hasContent()) {
                 try {
-                    await flusher.flush(true);
+                    await renderer.flush(true);
                 }
                 catch { }
                 if (error instanceof Error) {
@@ -1261,8 +1371,65 @@ export class MessageProcessor {
         if (/^[.\s\u2026]+$/.test(filePath))
             return true;
         // 含正则/代码特殊字符（Agent 在说明中引用了代码或正则表达式）
-        if (/[\\[\]{}*+?|^$]/.test(filePath))
+        if (/[\[\]{}*+?|^$]/.test(filePath))
             return true;
         return false;
     }
 }
+// ── 出站协议辅助：buildEnvelope / sendInteractionPayload ──
+// Phase 3 of outbound unification: callers (permission flow, CommandHandler
+// interaction cards, claude-runner AskUserQuestion / ExitPlanMode) should
+// produce `{ kind: 'interaction', interaction, fallbackText }` and dispatch
+// via `adapter.send(envelope, payload)` instead of calling
+// `adapter.sendInteraction(...)` directly. These helpers centralise the
+// indirection and provide a backwards-compatible fallback path for adapters
+// that do not yet implement `send`.
+/**
+ * Default fallback text for an InteractionRequest. Used when the caller
+ * does not supply one explicitly. Picks the appropriate renderer based on
+ * the interaction kind.
+ */
+export function defaultFallbackText(interaction) {
+    const kind = interaction.kind;
+    if (kind.kind === 'command-card') {
+        return renderCommandCardAsText(kind);
+    }
+    if (kind.kind === 'action') {
+        try {
+            return renderActionAsText(interaction);
+        }
+        catch {
+            // ActionInteraction without fallback metadata — produce a minimal hint
+            const action = kind;
+            const lines = [action.title];
+            if (action.body)
+                lines.push(action.body);
+            return lines.join('\n');
+        }
+    }
+    return '';
+}
+/**
+ * Send an interaction payload through the unified `adapter.send` entrypoint.
+ *
+ * Sends an interaction via adapter.send(envelope, { kind: 'interaction', ... }).
+ * Returns 'sent' on success, false on failure.
+ */
+export async function sendInteractionPayload(adapter, envelope, interaction, fallbackText, replyCtx) {
+    const text = fallbackText ?? defaultFallbackText(interaction);
+    const payload = {
+        kind: 'interaction',
+        interaction,
+        fallbackText: text || undefined,
+    };
+    try {
+        const enriched = replyCtx
+            ? { ...envelope, replyContext: replyCtx }
+            : envelope;
+        await adapter.send(enriched, payload);
+        return 'sent';
+    }
+    catch {
+        return false;
+    }
+}