evolclaw 3.1.5 → 3.1.7

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

@@ -1,5 +1,6 @@
 import path from 'path';
 import fs from 'fs';
+import os from 'os';
 import crypto from 'crypto';
 import { hasCompact } from '../../agents/claude-runner.js';
 import { IMRenderer } from './im-renderer.js';
@@ -10,10 +11,41 @@ import { summarizeToolInput } from '../permission.js';
 import { DEFAULT_PERMISSION_MODE } from '../../types.js';
 import { getPackageRoot, resolveRoot } from '../../paths.js';
 import { renderKitSections } from '../../agents/kit-renderer.js';
+import { renderMessageBody } from '../../agents/message-renderer.js';
 import { normalizeBaseagent } from '../../agents/baseagent-normalize.js';
 import { renderActionAsText, renderCommandCardAsText } from '../interaction-router.js';
 import { formatPeerKey } from '../relation/peer-key.js';
 import { resolveEffectiveModel } from '../model/model-scope.js';
+/** OS 信息在进程生命周期内是常量，模块加载时算一次。例: "Windows 11 Pro (win32 10.0.26200)" */
+const OS_INFO = (() => {
+    let label = '';
+    try {
+        label = os.version();
+    }
+    catch { /* 旧 Node 无 os.version */ }
+    return `${label ? label + ' ' : ''}(${os.platform()} ${os.release()})`;
+})();
+/** 当前 UTC 偏移，格式 +08:00 / -05:00。每条消息算（DST 安全）。 */
+function currentTzOffset() {
+    const off = -new Date().getTimezoneOffset(); // 分钟，东区为正
+    const sign = off >= 0 ? '+' : '-';
+    const abs = Math.abs(off);
+    return `${sign}${String(Math.floor(abs / 60)).padStart(2, '0')}:${String(abs % 60).padStart(2, '0')}`;
+}
+/** 当前本地日期 YYYY-MM-DD（按运行环境时区）。系统提示词用，一天才变一次（缓存友好）。 */
+function currentLocalDate() {
+    const d = new Date();
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+/** 当前本地星期几（中文，如「星期四」）。 */
+function currentWeekday() {
+    try {
+        return new Intl.DateTimeFormat('zh-CN', { weekday: 'long' }).format(new Date());
+    }
+    catch {
+        return ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'][new Date().getDay()];
+    }
+}
 function getContextTooLongHint(agent) {
     if (canCompactAgent(agent)) {
         return '上下文过长，请精简提问或使用 /compact 压缩上下文';
@@ -69,6 +101,8 @@ export class MessageProcessor {
     agentMap;
     primaryRunnerKey;
     interruptedSessions = new Map(); // sessionId → reason ('new_message' | 'stop' | ...)
+    /** sessionId → 模型降级状态（带退避探测，进程重启清零） */
+    modelFallbackMap = new Map();
     interactionRouter;
     messageQueue;
     /** sessionId → 活跃的空闲监控器，用于等待用户交互期间暂停/恢复计时 */
@@ -208,15 +242,15 @@ export class MessageProcessor {
     }
     // 命令前缀列表（与 CommandHandler.quickCommandPrefixes 保持同步）
     static COMMAND_PREFIXES = [
-        '/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart',
+        '/new', '/pwd', '/help', '/status', '/restart',
         '/model', '/effort', '/agent', '/slist', '/session', '/rename', '/repair', '/fork',
         '/stop', '/clear', '/compact', '/safe', '/del', '/perm', '/file', '/check',
-        '/p ', '/s ', '/name ', '/rewind', '/rw', '/rw ', '/activity', '/chatmode',
+        '/s ', '/name ', '/rewind', '/rw', '/rw ', '/activity', '/chatmode',
         '/aid', '/upgrade', '/evolagent',
     ];
     /** 判断消息内容是否为已知命令 */
     isKnownCommand(content) {
-        return content === '/p' || content === '/s' ||
+        return content === '/s' ||
             MessageProcessor.COMMAND_PREFIXES.some(cmd => content.startsWith(cmd));
     }
     /**
@@ -227,6 +261,29 @@ export class MessageProcessor {
         // 先解析会话，再优先用 session.metadata.channelKey 精确定位实例级 adapter
         // message.channel 现在存实例名（channelName），可直接用于精确路由
         const { session, absoluteProjectPath } = await this.resolveSession(message);
+        // thread(feishu) pending strategy: inject replyContext so first reply creates the thread
+        if (message.triggerMeta?.pendingThread && message.triggerMeta?.rootMessageId) {
+            const triggerId = message.triggerMeta.triggerId;
+            const channelKeyForAgent = session.metadata?.channelKey || message.channel;
+            const trigMgr = this.agentRegistry?.resolveByChannel(channelKeyForAgent)?.triggerManager;
+            const onThreadCreated = trigMgr
+                ? (threadId) => {
+                    try {
+                        trigMgr.update(triggerId, { targetThreadId: threadId, pendingThread: false });
+                        logger.info(`[MessageProcessor] Feishu thread created for trigger ${triggerId}: ${threadId}`);
+                    }
+                    catch (e) {
+                        logger.warn(`[MessageProcessor] Failed to write back thread_id for trigger ${triggerId}: ${e}`);
+                    }
+                }
+                : undefined;
+            message.replyContext = {
+                ...(message.replyContext ?? {}),
+                replyToMessageId: message.triggerMeta.rootMessageId,
+                replyInThread: true,
+                ...(onThreadCreated ? { metadata: { ...(message.replyContext?.metadata ?? {}), onThreadCreated } } : {}),
+            };
+        }
         const channelKey = session.metadata?.channelKey || message.channel;
         const channelInfo = this.resolveChannelInfo(channelKey);
         if (!channelInfo) {
@@ -388,7 +445,7 @@ export class MessageProcessor {
             };
         };
         const isProactive = session.sessionMode === 'proactive';
-        const isAutonomous = session.sessionMode === 'autonomous' || message.triggerMeta?.silent === true;
+        const isAutonomous = session.sessionMode === 'autonomous';
         const envelope = buildEnvelope({
             taskId,
             channel: message.channel,
@@ -518,12 +575,18 @@ export class MessageProcessor {
             // 检查是否因新消息自动中断 — 包装 prompt 让 Agent 知道上下文
             const prevInterruptReason = this.interruptedSessions.get(session.id);
             this.interruptedSessions.delete(session.id);
-            const effectivePrompt = prevInterruptReason === 'new_message' && session.agentSessionId
-                ? `【新消息插入】\n\n${message.content}\n\n【请无视之前中断继续处理】`
-                : message.content;
+            const wasInterrupted = prevInterruptReason === 'new_message' && !!session.agentSessionId;
+            const wrapPrompt = (body) => wasInterrupted
+                ? `【新消息插入】\n\n${body}\n\n【请无视之前中断继续处理】`
+                : body;
+            // 先用裸文本兜底；vars 构造完成后用消息渲染层重算（见下方 effectivePrompt 重赋值）。
+            let effectivePrompt = wrapPrompt(message.content);
             let streamResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
             let effectiveSystemPrompt;
             let modelOverride;
+            let usedFallback = false;
+            let skipEvolclawModel = false;
+            let agentModel;
             try {
                 // 动态构建运行时上下文提示
                 const contextParts = [];
@@ -557,16 +620,35 @@ export class MessageProcessor {
                 // 按 关系级 > agent级 > 全局 解析本次调用的模型/强度，作为 per-call 入参传入 runQuery。
                 // 不缓存、不绑会话——改关系级/agent级后该范围所有会话的下条消息即时生效；
                 // 多对端并发各自独立解析、各自传参，无共享状态可被污染。
-                try {
-                    const resolved = resolveEffectiveModel({ self: selfAid || undefined, peerKey });
-                    if (resolved.model)
-                        modelOverride = { model: resolved.model, effort: resolved.effort };
+                let effectiveModel;
+                // 取降级状态，按退避策略决定是否跳过 evolclaw 作用域模型
+                const fbState = this.modelFallbackMap.get(session.id) ?? {
+                    failCount: 0, fallbackActive: false,
+                    messagesSinceFallback: 0, nextProbeAt: 2, hintShown: false,
+                };
+                // 退避期内递增消息计数，判断是否到探测点
+                if (fbState.fallbackActive) {
+                    fbState.messagesSinceFallback++;
+                    skipEvolclawModel = fbState.messagesSinceFallback < fbState.nextProbeAt;
+                    this.modelFallbackMap.set(session.id, fbState);
                 }
-                catch (e) {
-                    logger.warn(`[MessageProcessor] resolveEffectiveModel failed: ${e instanceof Error ? e.message : String(e)}`);
+                // 非跳过时：尝试解析 evolclaw 作用域模型
+                let evolclawModelOverride;
+                if (!skipEvolclawModel) {
+                    try {
+                        const resolved = resolveEffectiveModel({ self: selfAid || undefined, peerKey });
+                        if (resolved.model) {
+                            evolclawModelOverride = { model: resolved.model, effort: resolved.effort };
+                            effectiveModel = resolved.model;
+                        }
+                    }
+                    catch (e) {
+                        logger.warn(`[MessageProcessor] resolveEffectiveModel failed: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                    modelOverride = evolclawModelOverride;
                 }
                 const normalizedBaseagent = normalizeBaseagent(agent.name);
-                const agentModel = (typeof agent.getModel === 'function') ? agent.getModel() : undefined;
+                agentModel = (typeof agent.getModel === 'function') ? agent.getModel() : undefined;
                 // Kit renderer: 组装上下文
                 const pkgRoot = getPackageRoot();
                 const kitCtx = {
@@ -580,6 +662,9 @@ export class MessageProcessor {
                         KITS_DOCS: path.join(pkgRoot, 'kits', 'docs'),
                         KITS_TEMPLATES: path.join(pkgRoot, 'kits', 'templates'),
                         KITS_FRAGMENTS: path.join(pkgRoot, 'kits', 'templates', 'system-fragments'),
+                        KITS_MESSAGE_FRAGMENTS: path.join(pkgRoot, 'kits', 'templates', 'message-fragments'),
+                        // evolclaw 运行模式：dev=源码仓库 | install=全局安装包
+                        evolclawMode: fs.existsSync(path.join(pkgRoot, 'src', 'index.ts')) ? 'dev' : 'install',
                         // 路径变量(用于 manifest 路径展开,resolvePath 用 ctx.vars 取真值)
                         PERSONAL_DIR: selfAid ? path.join(resolveRoot(), 'agents', selfAid, 'personal') : undefined,
                         RELATIONS_DIR: selfAid ? path.join(resolveRoot(), 'agents', selfAid, 'relations') : undefined,
@@ -593,6 +678,9 @@ export class MessageProcessor {
                         peerName: peerName || undefined,
                         peerRole: session.identity?.role || 'anonymous',
                         peerType: message.peerType || undefined,
+                        sameDevice: message.sameDevice || undefined,
+                        sameNetwork: message.sameNetwork || undefined,
+                        sameEgressIp: message.sameEgressIp || undefined,
                         groupId: session.metadata?.groupId || undefined,
                         chatType: session.chatType || null,
                         channel: currentChannelType || null,
@@ -606,6 +694,12 @@ export class MessageProcessor {
                         sessionId: session.id,
                         sessionName: session.name || undefined,
                         sessionCreatedAt: session.createdAt ? new Date(session.createdAt).toISOString() : undefined,
+                        // 时区（把 ISO 时间戳转本地时间用）+ OS 环境
+                        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || undefined,
+                        tzOffset: currentTzOffset(),
+                        localDate: currentLocalDate(),
+                        weekday: currentWeekday(),
+                        osInfo: OS_INFO,
                         threadId: session.threadId || undefined,
                         // Stage 3: sessionKey 持久化字段
                         sessionKey: session.sessionKey,
@@ -614,6 +708,9 @@ export class MessageProcessor {
                         baseAgent: normalizedBaseagent.canonical,
                         baseAgentName: normalizedBaseagent.displayName,
                         baseAgentModel: agentModel || undefined,
+                        effectiveModel: effectiveModel || agentModel || undefined,
+                        modelFallbackActive: (fbState.fallbackActive || skipEvolclawModel) ? true : undefined,
+                        modelFallbackModel: (fbState.fallbackActive || skipEvolclawModel) ? (agentModel || undefined) : undefined,
                         agentSessionId: session.agentSessionId || undefined,
                     },
                     sessionId: session.id,
@@ -622,22 +719,67 @@ export class MessageProcessor {
                 if (kitContext)
                     contextParts.push(kitContext);
                 effectiveSystemPrompt = [options?.systemPromptAppend, ...contextParts].filter(Boolean).join('\n') || undefined;
+                // 消息渲染层：用 message manifest 逐条渲染（时间 + 群聊发送者），组装成最终正文。
+                // 单条消息构造单元素 items；批量合并的消息 message.items 已由队列填充。
+                let renderResult;
+                const hasContent = message.content.trim() || (message.items && message.items.length > 0);
+                if (hasContent) {
+                    try {
+                        const renderItems = message.items && message.items.length > 0
+                            ? message.items
+                            : [{
+                                    peerId: message.peerId, peerName: peerName || undefined,
+                                    peerType: message.peerType, content: message.content,
+                                    timestamp: message.timestamp,
+                                    images: message.images,
+                                }];
+                        renderResult = renderMessageBody(renderItems, kitCtx.vars, session.id);
+                        if (renderResult.body.trim())
+                            effectivePrompt = wrapPrompt(renderResult.body);
+                        else
+                            effectivePrompt = wrapPrompt(message.content);
+                    }
+                    catch (e) {
+                        logger.warn(`[MessageProcessor] renderMessageBody failed, using raw content: ${e instanceof Error ? e.message : String(e)}`);
+                        effectivePrompt = wrapPrompt(message.content);
+                    }
+                }
                 // 可重试错误（403/429/5xx）指数退避重试，最多 3 次
                 const MAX_RETRIES = 3;
                 for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
                     let streamRegistered = false;
                     try {
                         logger.info(`[MessageProcessor] agent.runQuery start: agent=${agent.name} session=${session.id} task=${taskId} attempt=${attempt}/${MAX_RETRIES} agentSessionId=${session.agentSessionId ?? 'none'}`);
-                        const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, session.agentSessionId, message.images, effectiveSystemPrompt, this.sessionManager, modelOverride);
+                        const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, session.agentSessionId, renderResult?.images.length ? renderResult.images : message.images, effectiveSystemPrompt, this.sessionManager, modelOverride);
                         agent.registerStream(streamKey, stream);
                         streamRegistered = true;
                         streamResult = await this.processEventStream(stream, session, agent, renderer, resetTimer, shouldSuppress);
+                        // 探测成功（退避期内到达探测点且用的是 evolclaw 模型）→ 清零降级状态
+                        if (fbState.fallbackActive && !skipEvolclawModel && !usedFallback) {
+                            this.modelFallbackMap.delete(session.id);
+                            logger.info(`[MessageProcessor] Model probe succeeded, cleared fallback state for session=${session.id}`);
+                        }
                         break; // 成功，跳出重试循环
                     }
                     catch (retryError) {
                         if (streamRegistered) {
                             agent.cleanupStream(streamKey);
                         }
+                        // 模型不可用：累计计数，本次切换到 baseAgentModel 立即重试，不让用户看到失败
+                        if (classifyError(retryError) === ErrorType.MODEL_UNAVAILABLE && evolclawModelOverride?.model) {
+                            fbState.failCount++;
+                            if (fbState.failCount >= 2) {
+                                fbState.fallbackActive = true;
+                                fbState.messagesSinceFallback = 0;
+                                fbState.nextProbeAt = Math.min(Math.pow(2, fbState.failCount - 1), 8);
+                            }
+                            this.modelFallbackMap.set(session.id, fbState);
+                            logger.warn(`[MessageProcessor] Model unavailable: ${evolclawModelOverride.model}, failCount=${fbState.failCount}, fallbackActive=${fbState.fallbackActive}`);
+                            // 切换到 baseAgentModel 重试（清除 modelOverride，让 runQuery 使用 this.model）
+                            modelOverride = undefined;
+                            usedFallback = true;
+                            continue;
+                        }
                         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);
@@ -657,9 +799,6 @@ export class MessageProcessor {
                     await renderer.flush();
                     const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
                     if (compacted) {
-                        // compact 成功，清除第一次流中混入的错误文本，再重试
-                        const ctxErrPattern = /prompt is too long|input is too long|上下文过长/i;
-                        renderer.stripContextError(ctxErrPattern);
                         renderer.addNotice('✅ 压缩完成，继续处理...', 'info', 'compact-retry', true);
                         const retryStream = await agent.runQuery(session.id, '上下文已自动压缩，请继续之前未完成的任务。', absoluteProjectPath, session.agentSessionId, undefined, effectiveSystemPrompt, this.sessionManager, modelOverride);
                         agent.registerStream(streamKey, retryStream);
@@ -682,7 +821,6 @@ export class MessageProcessor {
                 contextTooLongPattern.test(errorsText) ||
                 contextTooLongPattern.test(streamResult.fullText));
             if (isPromptTooLong) {
-                renderer.stripContextError(contextTooLongPattern);
                 renderer.addNotice('上下文过长，正在压缩会话...', 'warn', 'compact-trigger', true);
                 await renderer.flush();
                 const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
@@ -698,7 +836,6 @@ export class MessageProcessor {
                         contextTooLongPattern.test(retryErrorsText) ||
                         contextTooLongPattern.test(streamResult.fullText));
                     if (retryStillTooLong) {
-                        renderer.stripContextError(contextTooLongPattern);
                         renderer.addNotice(getContextTooLongHint(agent), 'warn', 'context-too-long', true);
                     }
                 }
@@ -815,6 +952,20 @@ export class MessageProcessor {
             logger.info(`[MessageProcessor] agent.cleanupStream ok: session=${session.id} task=${taskId}`);
             this.sessionManager.clearProcessing(session.id);
             logger.info(`[MessageProcessor] session ${session.id} processing cleared task=${taskId}`);
+            // 降级模型回复末尾追加标记（代码层硬注入，不依赖模型输出）
+            const usingFallback = usedFallback || (skipEvolclawModel && agentModel != null);
+            if (usingFallback && agentModel) {
+                const curFbState = this.modelFallbackMap.get(session.id);
+                const showHint = curFbState && curFbState.nextProbeAt >= 8 && !curFbState.hintShown;
+                const suffix = showHint
+                    ? `\n\n---\n⚠️ [降级模型: ${agentModel} | 可告诉我"帮我检查可用模型"来诊断]`
+                    : `\n\n---\n⚠️ [降级模型: ${agentModel}]`;
+                renderer.addText(suffix);
+                if (showHint && curFbState) {
+                    curFbState.hintShown = true;
+                    this.modelFallbackMap.set(session.id, curFbState);
+                }
+            }
             // 被用户中断（新消息打断）时跳过 flush — 新 task 已接管渠道，旧 task 的 flush 无意义且可能卡住
             const preFlushInterrupt = this.interruptedSessions.get(session.id);
             if (preFlushInterrupt === 'new_message' || preFlushInterrupt === 'stop' || preFlushInterrupt === 'recalled') {
@@ -877,7 +1028,7 @@ export class MessageProcessor {
                         adapter.send(envelope, { kind: 'status.interrupted', metadata: { reason: interruptReason } }).catch(() => { });
                     }
                     else {
-                        adapter.send(envelope, { kind: 'status.completed', metadata: { durationMs, ttftMs: streamResult.ttftMs, numTurns: streamResult.numTurns, usage: streamResult.usage } }).catch(() => { });
+                        adapter.send(envelope, { kind: 'status.completed', metadata: { durationMs, ttftMs: streamResult.ttftMs, numTurns: streamResult.numTurns, tokenUsage: streamResult.tokenUsage, contextUsage: streamResult.contextUsage } }).catch(() => { });
                     }
                 }
                 if (message.triggerMeta) {
@@ -887,10 +1038,6 @@ export class MessageProcessor {
                     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({
@@ -1023,19 +1170,21 @@ export class MessageProcessor {
             ? { replyContext: message.replyContext }
             : undefined;
         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);
+        // 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);
+            if (bound) {
+                const switched = await this.sessionManager.switchToSession(bound.channel, bound.channelId, bound.id);
+                if (switched) {
+                    const absoluteProjectPath = path.isAbsolute(switched.projectPath)
+                        ? switched.projectPath : path.resolve(process.cwd(), switched.projectPath);
+                    return { session: switched, absoluteProjectPath };
+                }
+                logger.warn(`[MessageProcessor] switchToSession failed for bound session ${bound.id}, falling back to latest`);
+            }
+            else {
+                logger.warn(`[MessageProcessor] Bound session ${message.triggerMeta.boundSessionId} not found, falling back to latest`);
             }
-            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, message.chatType, undefined, message.selfAID, message.channelType, message.peerType);
         // 兜底纠正1：群聊强制 proactive
@@ -1240,7 +1389,7 @@ export class MessageProcessor {
                             logger.info(`[MessageProcessor] Auto-filled session name: ${event.sessionTitle}`);
                         }
                         // 记录完成状态 + 最后一轮回复文本（后续 complete 覆盖前序）
-                        completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, ttftMs: event.ttftMs, usage: event.usage };
+                        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 };
                         // thought jsonl 写入已下沉到 aun.ts:sendThought 成功后，
                         // 由那里按 LLM 输出的每个 text item 单独写一条，此处不再写。
                         // 失败且无前置错误输出：显示 errors 摘要
@@ -1296,7 +1445,7 @@ export class MessageProcessor {
                     logger.info(`[MessageProcessor] Auto-filled session name: ${event.sessionTitle}`);
                 }
                 // 记录完成状态
-                completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, ttftMs: event.ttftMs, usage: event.usage };
+                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 };
                 if (event.subtype === 'success') {
                     this.messageCache.addEvent(session.id, {
                         type: 'completed',

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

@@ -184,7 +184,8 @@ export class MessageQueue {
     }
     /**
      * 合并多条同 peerId 消息：
-     * - content: \n 连接
+     * - content: \n 连接（兜底用，渲染层优先用 items）
+     * - items: 保留每条子消息（含各自 peer/timestamp），供消息渲染层逐条渲染
      * - images / mentions: 扁平合并
      * - messageId: 取最新一条的 messageId（用于 thought 锚定与中断追踪）
      * - replyContext / peerName / 其余字段: 取最后一条
@@ -193,6 +194,7 @@ export class MessageQueue {
         const contents = [];
         const allImages = [];
         const allMentions = [];
+        const subMessages = [];
         for (const item of items) {
             const m = item.message;
             contents.push(m.content);
@@ -200,6 +202,17 @@ export class MessageQueue {
                 allImages.push(...m.images);
             if (m.mentions)
                 allMentions.push(...m.mentions);
+            // 逐条保留发送者、时刻、图片；若该条已自带 items（罕见），展开保留细粒度
+            if (m.items && m.items.length > 0) {
+                subMessages.push(...m.items);
+            }
+            else {
+                subMessages.push({
+                    peerId: m.peerId, peerName: m.peerName, peerType: m.peerType,
+                    content: m.content, timestamp: m.timestamp,
+                    images: m.images && m.images.length > 0 ? m.images : undefined,
+                });
+            }
         }
         const last = items[items.length - 1];
         // 保留最新一条的 messageId（若最后一条无 ID 则回退到前面已有的 ID）
@@ -213,6 +226,7 @@ export class MessageQueue {
         const merged = {
             ...last.message,
             content: contents.join('\n'),
+            items: subMessages,
             images: allImages.length > 0 ? allImages : undefined,
             mentions: allMentions.length > 0 ? allMentions : undefined,
             messageId: latestMessageId,

package/dist/core/relation/peer-identity.js

@@ -56,8 +56,10 @@ export class PeerIdentityCache {
     }
     /**
      * 从 agent.md 更新身份信息
+     * @param source 'agentmd'（验签通过）或 'agentmd-unverified'（内容可解析但验签未过）
+     * @param verifiedAt 验签通过时间戳；未验签传 0
      */
-    static updateFromAgentMd(channelType, peerId, agentDir, agentMd, verifiedAt) {
+    static updateFromAgentMd(channelType, peerId, agentDir, agentMd, verifiedAt, source = 'agentmd') {
         const typeMatch = agentMd.match(/^type:\s*["']?([^"'\n]+?)["']?\s*$/m);
         const nameMatch = agentMd.match(/^name:\s*["']?(.+?)["']?\s*$/m);
         const type = typeMatch?.[1] || 'unknown';
@@ -74,13 +76,13 @@ export class PeerIdentityCache {
             agentMdUpdatedAt: now,
             verifiedAt,
             lastCheckedAt: now,
-            source: 'agentmd',
+            source,
         };
         const filePath = this.getFilePath(channelType, peerId, agentDir);
         try {
             fs.mkdirSync(path.dirname(filePath), { recursive: true });
             fs.writeFileSync(filePath, JSON.stringify(identity, null, 2), 'utf-8');
-            logger.debug(`[PeerIdentityCache] Updated: ${channelType}#${peerId} type=${type} isAgent=${isAgent}`);
+            logger.debug(`[PeerIdentityCache] Updated: ${channelType}#${peerId} type=${type} isAgent=${isAgent} source=${source}`);
         }
         catch (err) {
             logger.warn(`[PeerIdentityCache] Failed to write cache: ${filePath} err=${err}`);
@@ -151,27 +153,37 @@ export class PeerIdentityCache {
             if (!content) {
                 throw new Error('agent.md content unavailable');
             }
-            // 3. 比较 hash，仅在变化时重写 peer-identity.json
+            // 验签通过 → 可信（source=agentmd）；否则 type 仍解析但标记未验证
+            const verified = result.verification?.status === 'verified';
+            const source = verified ? 'agentmd' : 'agentmd-unverified';
+            if (!verified) {
+                logger.info(`[PeerIdentityCache] agent.md unverified for ${peerId}: status=${result.verification?.status ?? 'unknown'} reason=${result.verification?.reason ?? '-'} (type 仍按声明解析)`);
+            }
+            // 3. 比较 hash，内容与可信级别都未变时仅 touch
             const newHash = 'sha256:' + crypto.createHash('sha256').update(content, 'utf-8').digest('hex');
             const cached = this.get(channelType, peerId, agentDir);
-            if (cached && cached.agentMdHash === newHash && cached.source === 'agentmd') {
+            if (cached && cached.agentMdHash === newHash && cached.source === source) {
                 return this.touchLastChecked(channelType, peerId, agentDir, cached);
             }
-            return this.updateFromAgentMd(channelType, peerId, agentDir, content, Date.now());
+            return this.updateFromAgentMd(channelType, peerId, agentDir, content, verified ? Date.now() : 0, source);
         }
         catch (err) {
-            // 4. 网络失败，fallback 本地文件
+            // 4. agentmdSync 抛错（非网络失败——网络失败时它内部已 fallback 返回本地内容；
+            //    这里通常是无内容或解析异常）。兜底读本地文件，但无法重新验签，
+            //    故沿用缓存里已有的可信级别，绝不凭空升级为已验签。
             const localPath = agentMdPath(peerId);
             try {
                 if (fs.existsSync(localPath)) {
                     const localContent = fs.readFileSync(localPath, 'utf-8');
-                    logger.info(`[PeerIdentityCache] Network failed, using local agent.md for ${peerId}`);
-                    const localHash = 'sha256:' + crypto.createHash('sha256').update(localContent, 'utf-8').digest('hex');
                     const cached = this.get(channelType, peerId, agentDir);
-                    if (cached && cached.agentMdHash === localHash && cached.source === 'agentmd') {
+                    logger.info(`[PeerIdentityCache] Using local agent.md for ${peerId} (cached source=${cached?.source ?? 'none'})`);
+                    const localHash = 'sha256:' + crypto.createHash('sha256').update(localContent, 'utf-8').digest('hex');
+                    if (cached && cached.agentMdHash === localHash && (cached.source === 'agentmd' || cached.source === 'agentmd-unverified')) {
                         return this.touchLastChecked(channelType, peerId, agentDir, cached);
                     }
-                    return this.updateFromAgentMd(channelType, peerId, agentDir, localContent, cached?.verifiedAt ?? 0);
+                    // 无匹配缓存可信级别 → 本地内容未经本次验签，标记为未验证
+                    const fallbackSource = cached?.source === 'agentmd' ? 'agentmd' : 'agentmd-unverified';
+                    return this.updateFromAgentMd(channelType, peerId, agentDir, localContent, cached?.verifiedAt ?? 0, fallbackSource);
                 }
             }
             catch { /* ignore fs errors */ }

package/dist/core/trigger/parser.js

@@ -127,8 +127,8 @@ export function parseTriggerUpdate(args) {
     }
     if (flags.has('session')) {
         const sv = flags.get('session');
-        if (sv !== 'latest' && sv !== 'silent')
-            return { ok: false, error: '--session 只接受 latest 或 silent' };
+        if (sv !== 'latest' && sv !== 'current' && sv !== 'thread')
+            return { ok: false, error: '--session 只接受 latest、current 或 thread' };
         result.targetSessionStrategy = sv;
     }
     if (flags.has('agent')) {
@@ -216,8 +216,8 @@ export function parseTriggerSet(args) {
     let targetSessionStrategy = 'latest';
     if (hasSession) {
         const sv = flags.get('session');
-        if (sv !== 'latest' && sv !== 'silent') {
-            return { ok: false, error: '--session 只接受 latest 或 silent' };
+        if (sv !== 'latest' && sv !== 'current' && sv !== 'thread') {
+            return { ok: false, error: '--session 只接受 latest、current 或 thread' };
         }
         targetSessionStrategy = sv;
     }