evolclaw 3.1.5 → 3.1.6

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';
@@ -14,6 +15,22 @@ 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')}`;
+}
 function getContextTooLongHint(agent) {
     if (canCompactAgent(agent)) {
         return '上下文过长，请精简提问或使用 /compact 压缩上下文';
@@ -69,6 +86,8 @@ export class MessageProcessor {
     agentMap;
     primaryRunnerKey;
     interruptedSessions = new Map(); // sessionId → reason ('new_message' | 'stop' | ...)
+    /** sessionId → 模型降级状态（带退避探测，进程重启清零） */
+    modelFallbackMap = new Map();
     interactionRouter;
     messageQueue;
     /** sessionId → 活跃的空闲监控器，用于等待用户交互期间暂停/恢复计时 */
@@ -208,15 +227,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 +246,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 +430,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,
@@ -524,6 +566,9 @@ export class MessageProcessor {
             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 +602,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 +644,8 @@ 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'),
+                        // 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 +659,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 +675,10 @@ 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(),
+                        osInfo: OS_INFO,
                         threadId: session.threadId || undefined,
                         // Stage 3: sessionKey 持久化字段
                         sessionKey: session.sessionKey,
@@ -614,6 +687,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,
@@ -632,12 +708,32 @@ export class MessageProcessor {
                         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 +753,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 +775,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 +790,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 +906,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 +982,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 +992,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 +1124,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 +1343,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 +1399,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/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;
     }

package/dist/core/trigger/scheduler.js

@@ -209,12 +209,12 @@ export class TriggerScheduler {
         this.inflightCron.delete(triggerId);
     }
     buildSyntheticMessage(trigger, messageId) {
-        return {
+        const base = {
             channel: trigger.targetChannel,
             channelType: trigger.targetChannelType,
             channelId: trigger.targetChannelId,
             selfAID: this.aid,
-            threadId: trigger.targetThreadId ?? '',
+            threadId: '',
             agentId: trigger.agentId,
             chatType: 'private',
             peerId: `__trigger__:${trigger.id}`, // unique per trigger to prevent greedy merge
@@ -222,10 +222,24 @@ export class TriggerScheduler {
             messageId,
             timestamp: Date.now(),
             source: 'trigger',
-            triggerMeta: {
-                triggerId: trigger.id,
-                silent: trigger.targetSessionStrategy === 'silent',
-            },
         };
+        if (trigger.targetSessionStrategy === 'current') {
+            base.triggerMeta = { triggerId: trigger.id, boundSessionId: trigger.boundSessionId };
+        }
+        else if (trigger.targetSessionStrategy === 'thread') {
+            if (trigger.threadKind === 'feishu' && trigger.pendingThread) {
+                base.triggerMeta = { triggerId: trigger.id, pendingThread: true, rootMessageId: trigger.rootMessageId };
+                // threadId intentionally empty — first fire builds the thread via reply_in_thread
+            }
+            else {
+                base.threadId = trigger.targetThreadId ?? '';
+                base.triggerMeta = { triggerId: trigger.id };
+            }
+        }
+        else {
+            // latest
+            base.triggerMeta = { triggerId: trigger.id };
+        }
+        return base;
     }
 }

package/dist/index.js

@@ -452,11 +452,58 @@ async function main() {
             continue;
         const scheduler = agent.triggerScheduler;
         const primaryProjectPath = agent.config.projects?.defaultPath ?? primaryAgent.projectPath;
+        function scheduleRetryWhenIdle(boundId, msg, trigger) {
+            let done = false;
+            const handler = (ev) => {
+                if (ev.sessionId !== boundId || done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                eventBus.unsubscribe('task:completed', handler);
+                retry();
+            };
+            const timer = setTimeout(() => {
+                if (done)
+                    return;
+                done = true;
+                eventBus.unsubscribe('task:completed', handler);
+                retry();
+            }, 30_000);
+            eventBus.subscribe('task:completed', handler);
+            function retry() {
+                if (messageQueue.isProcessing(boundId)) {
+                    scheduleRetryWhenIdle(boundId, msg, trigger);
+                    return;
+                }
+                sessionManager.getSessionById(boundId).then(bound => {
+                    if (!bound) {
+                        logger.warn(`[Trigger] Bound session ${boundId} deleted, aborting`);
+                        return;
+                    }
+                    messageQueue.enqueue(boundId, msg, bound.projectPath, { interruptible: false })
+                        .catch(err => logger.error(`[Trigger] Retry failed ${trigger.id}: ${err}`));
+                });
+            }
+        }
         scheduler.setFireCallback((msg, trigger) => {
-            const sessionKey = `${msg.channel}:${msg.channelId}`;
-            messageQueue.enqueue(sessionKey, msg, primaryProjectPath, { interruptible: false }).catch(err => {
-                logger.error(`[Trigger] Failed to enqueue trigger ${trigger.id}: ${err}`);
-            });
+            if (trigger.targetSessionStrategy === 'current' && trigger.boundSessionId) {
+                const boundId = trigger.boundSessionId;
+                if (messageQueue.isProcessing(boundId)) {
+                    scheduleRetryWhenIdle(boundId, msg, trigger);
+                    return;
+                }
+                sessionManager.getSessionById(boundId).then(bound => {
+                    if (!bound) {
+                        logger.warn(`[Trigger] Bound session ${boundId} not found`);
+                        return;
+                    }
+                    messageQueue.enqueue(boundId, msg, bound.projectPath, { interruptible: false })
+                        .catch(err => logger.error(`[Trigger] Enqueue failed ${trigger.id}: ${err}`));
+                });
+                return;
+            }
+            messageQueue.enqueue(`${msg.channel}:${msg.channelId}`, msg, primaryProjectPath, { interruptible: false })
+                .catch(err => logger.error(`[Trigger] Enqueue failed ${trigger.id}: ${err}`));
         });
         // Subscribe to trigger:completed/failed/skipped to update cron inflight state
         eventBus.subscribe('trigger:completed', (ev) => scheduler.onTriggerComplete(ev.triggerId, 'completed'));
@@ -504,7 +551,7 @@ async function main() {
                     nextFireAt: calcNextFireAt('cron', cronExpr),
                     targetChannel: firstChannel,
                     targetChannelId: '__system__',
-                    targetSessionStrategy: 'silent',
+                    targetSessionStrategy: 'latest',
                     prompt: '检查 evolclaw 是否有新版本可用。执行 `npm view evolclaw version` 获取最新版本，与当前版本（执行 `evolclaw --version`）对比。如果有新版本，执行 /restart 进行升级。如果已是最新版本，无需任何操作。',
                     createdByPeerId: '__system__',
                     createdByChannel: '__system__',
@@ -756,8 +803,11 @@ async function main() {
                 continue;
             }
             logger.info(`[Resume] Resuming session: ${session.id} (agent: ${evolName}::${baseagentName})`);
+            const parsedResumeKey = tryParseChannelKey(session.channel);
             const resumeMessage = {
                 channel: session.channel,
+                channelType: session.channelType || parsedResumeKey?.type,
+                selfAID: parsedResumeKey?.selfAID,
                 channelId: session.channelId,
                 content: '服务已重启，请继续之前未完成的任务。',
                 timestamp: Date.now(),

package/dist/ipc.js

@@ -93,7 +93,7 @@ export class IpcServer {
             case 'status':
                 return this.getStatus();
             case 'ping':
-                return { pong: true, pid: process.pid };
+                return { pong: true, pid: process.pid, protocolVersion: 1 };
             case 'aun-aids': {
                 const aids = this.aunAidProvider ? this.aunAidProvider() : [];
                 return { ok: true, aids };

package/dist/utils/error-utils.js

@@ -10,6 +10,7 @@ export var ErrorType;
     ErrorType["FILE_CORRUPT"] = "file_corrupt";
     ErrorType["STREAM_ERROR"] = "stream_error";
     ErrorType["CONTEXT_TOO_LONG"] = "context_too_long";
+    ErrorType["MODEL_UNAVAILABLE"] = "model_unavailable";
     ErrorType["UNKNOWN"] = "unknown";
 })(ErrorType || (ErrorType = {}));
 /**
@@ -210,6 +211,11 @@ export function classifyError(error) {
         || msg.includes('上下文过长')) {
         return ErrorType.CONTEXT_TOO_LONG;
     }
+    if (msg.includes('invalid_model') || msg.includes('model_not_found')
+        || msg.includes('no such model') || msg.includes('unknown model')
+        || /api error: 404\b/.test(msg)) {
+        return ErrorType.MODEL_UNAVAILABLE;
+    }
     if (msg.includes('401') || msg.includes('authentication_error')) {
         return ErrorType.AUTH_ERROR;
     }

package/dist/utils/process-introspect.js

@@ -51,18 +51,20 @@ function getStartTimeLinux(pid) {
     const starttimeJiffies = parseInt(fields[19], 10);
     if (isNaN(starttimeJiffies))
         return null;
-    let uptimeSec;
+    let btimeSec;
     try {
-        uptimeSec = parseFloat(fs.readFileSync('/proc/uptime', 'utf-8').split(' ')[0]);
+        const m = fs.readFileSync('/proc/stat', 'utf-8').match(/^btime (\d+)/m);
+        if (!m)
+            return null;
+        btimeSec = parseInt(m[1], 10);
     }
     catch {
         return null;
     }
-    if (isNaN(uptimeSec))
+    if (isNaN(btimeSec))
         return null;
     const clkTck = 100;
-    const bootTimeMs = Date.now() - uptimeSec * 1000;
-    return bootTimeMs + (starttimeJiffies / clkTck) * 1000;
+    return (btimeSec + starttimeJiffies / clkTck) * 1000;
 }
 // ── macOS ──
 function getStartTimeMacOS(pid) {