evolclaw 3.1.0 → 3.1.1

package/dist/utils/error-utils.js

@@ -245,27 +245,29 @@ export function isRetryableError(error) {
         return true;
     return false;
 }
-export function getErrorMessage(error, terminalReason) {
+export function getErrorMessage(error, terminalReason, includeEmoji = true) {
     // terminalReason 提供更精确的错误提示（SDK 0.2.100+）
     if (terminalReason) {
+        const prefix = includeEmoji ? '❌ ' : '';
+        const warnPrefix = includeEmoji ? '⚠️ ' : '';
         switch (terminalReason) {
             case 'max_turns':
-                return '❌ 任务达到最大轮次限制，请简化需求或分步执行';
+                return `${prefix}任务达到最大轮次限制，请简化需求或分步执行`;
             case 'prompt_too_long':
-                return '⚠️ 输入过长，请精简提问或使用 /compact 压缩上下文';
+                return `${warnPrefix}输入过长，请精简提问或使用 /compact 压缩上下文`;
             case 'rapid_refill_breaker':
-                return '⚠️ API 限流中，请稍后重试';
+                return `${warnPrefix}API 限流中，请稍后重试`;
             case 'context_compact_failed':
-                return '⚠️ 上下文过长，自动压缩失败，请手动输入 /compact 重试';
+                return `${warnPrefix}上下文过长，自动压缩失败，请手动输入 /compact 重试`;
             case 'model_error':
-                return '❌ 模型服务异常，请稍后重试';
+                return `${prefix}模型服务异常，请稍后重试`;
             case 'tool_error':
-                return '❌ 工具执行失败，请检查操作或重试';
+                return `${prefix}工具执行失败，请检查操作或重试`;
             case 'permission_denied':
-                return '❌ 权限被拒绝，操作已取消';
+                return `${prefix}权限被拒绝，操作已取消`;
             case 'aborted_streaming':
             case 'aborted_tools':
-                return '❌ 任务已中断';
+                return `${prefix}任务已中断`;
         }
     }
     // 回退到原有的错误消息匹配逻辑
@@ -275,15 +277,17 @@ export function getErrorMessage(error, terminalReason) {
     if (rule?.message)
         return rule.message;
     // 内置兜底规则（结构性错误）
+    const warnPrefix = includeEmoji ? '⚠️ ' : '';
+    const errPrefix = includeEmoji ? '❌ ' : '';
     if (msg.includes('CONTEXT_COMPACT_FAILED') || msg.includes('context_length_exceeded')
         || msg.includes('Context limit')) {
-        return '⚠️ 上下文过长，自动压缩失败，请手动输入 /compact 重试';
+        return `${warnPrefix}上下文过长，自动压缩失败，请手动输入 /compact 重试`;
     }
     if (msg.includes('401') || msg.includes('authentication_error')) {
-        return '❌ API Key 无效，请检查密钥配置。使用 /status 查看当前配置';
+        return `${errPrefix}API Key 无效，请检查密钥配置。使用 /status 查看当前配置`;
     }
     if (msg.includes('timeout')) {
-        return '⚠️ 请求超时，请重试';
+        return `${warnPrefix}请求超时，请重试`;
     }
-    return '❌ 处理消息时出错，请稍后重试';
+    return `${errPrefix}处理消息时出错，请稍后重试`;
 }

package/dist/utils/stats.js

@@ -1,3 +1,5 @@
+import fs from 'fs';
+import path from 'path';
 export class StatsCollector {
     events = [];
     startTime;
@@ -100,6 +102,71 @@ export class StatsCollector {
 export class AidStatsCollector {
     entries = new Map();
     queueStatsProvider;
+    /** sessionId → 当前正在跑该 session 的 agent，task:started 写入，task:completed/error 清除 */
+    sessionToAgent = new Map();
+    constructor(eventBus) {
+        if (!eventBus)
+            return;
+        eventBus.subscribe('task:started', (event) => {
+            const e = event;
+            if (e.agentName)
+                this.onTaskStart(e.agentName, e.encrypt, e.chatmode);
+            if (e.agentName && e.sessionId)
+                this.sessionToAgent.set(e.sessionId, e.agentName);
+        });
+        eventBus.subscribe('task:completed', (event) => {
+            const e = event;
+            if (e.agentName)
+                this.onTaskEnd(e.agentName, 'completed', undefined, e.finalText, e.numTurns);
+            if (e.sessionId)
+                this.sessionToAgent.delete(e.sessionId);
+        });
+        eventBus.subscribe('task:error', (event) => {
+            const e = event;
+            if (e.agentName)
+                this.onTaskEnd(e.agentName, 'error', e.errorType);
+            if (e.sessionId)
+                this.sessionToAgent.delete(e.sessionId);
+        });
+        // thought.put 次数 + 最后一次 thought 文本
+        // 注意：thought.put 是 fire-and-forget async，可能在 task:completed 之后才到达，
+        // 所以同时累加到 currentTask（task 进行中）或 lastTaskEnd（task 已结束但 thought 属于它）
+        eventBus.subscribe('message:thought-put', (event) => {
+            const e = event;
+            if (!e.agentName)
+                return;
+            const entry = this.entries.get(e.agentName);
+            if (!entry)
+                return;
+            if (entry.currentTaskStartAt != null) {
+                // task 进行中
+                entry.currentTaskThoughtPutCount++;
+                if (e.text)
+                    entry.currentTaskLastThoughtText = e.text;
+            }
+            else if (entry.lastTaskEnd) {
+                // task 已结束，回填到最近一次 task
+                entry.lastTaskEnd.thoughtPutCount++;
+                entry.lastTaskEnd.thoughtDuringTask = true;
+                if (e.text) {
+                    const t = e.text.length > 100 ? e.text.slice(0, 100) + '…' : e.text;
+                    entry.lastTaskEnd.lastThoughtText = t;
+                }
+            }
+        });
+        // 工具调用次数（tool:use 事件）
+        eventBus.subscribe('tool:use', (event) => {
+            const e = event;
+            if (!e.sessionId)
+                return;
+            const agent = this.sessionToAgent.get(e.sessionId);
+            if (!agent)
+                return;
+            const entry = this.entries.get(agent);
+            if (entry && entry.currentTaskStartAt != null)
+                entry.currentTaskToolUseCount++;
+        });
+    }
     setQueueStatsProvider(provider) {
         this.queueStatsProvider = provider;
     }
@@ -119,19 +186,145 @@ export class AidStatsCollector {
                 lastSentAt: null,
                 lastReceivedText: null,
                 lastReceivedFrom: null,
+                lastReceivedEncrypt: null,
+                lastReceivedChatmode: null,
                 lastSentText: null,
                 lastSentTo: null,
+                lastSentEncrypt: null,
+                lastSentChatmode: null,
                 uniquePeers: new Set(),
+                currentTaskStartAt: null,
+                currentTaskReplyCount: 0,
+                currentTaskThoughtPutCount: 0,
+                currentTaskToolUseCount: 0,
+                currentTaskNumTurns: 0,
+                currentTaskLastThoughtText: null,
+                currentTaskSessionId: null,
+                currentTaskChatmode: null,
+                currentTaskEncrypt: null,
+                lastTaskEnd: undefined,
             };
             this.entries.set(aid, entry);
         }
         return entry;
     }
+    sessionsDir;
+    setSessionsDir(dir) {
+        this.sessionsDir = dir;
+    }
+    onTaskStart(aid, encrypt, chatmode) {
+        const entry = this.getOrCreate(aid);
+        entry.currentTaskStartAt = Date.now();
+        entry.currentTaskReplyCount = 0;
+        entry.currentTaskThoughtPutCount = 0;
+        entry.currentTaskToolUseCount = 0;
+        entry.currentTaskNumTurns = 0;
+        entry.currentTaskLastThoughtText = null;
+        entry.currentTaskChatmode = chatmode ?? null;
+        entry.currentTaskEncrypt = encrypt ?? null;
+    }
+    onTaskEnd(aid, status, errorType, finalText, numTurns) {
+        const entry = this.getOrCreate(aid);
+        const startedAt = entry.currentTaskStartAt;
+        const taskEndTs = Date.now();
+        // 先用内存计数写入初始值（立即可用）
+        const buildTaskEnd = (msgCount, thoughtCount, lastThought) => ({
+            ts: taskEndTs,
+            status,
+            errorType,
+            sentDuringTask: msgCount > 0,
+            thoughtDuringTask: thoughtCount > 0,
+            lastThoughtText: lastThought,
+            replyCount: msgCount,
+            thoughtPutCount: thoughtCount,
+            toolUseCount: entry.currentTaskToolUseCount,
+            numTurns: numTurns ?? entry.currentTaskNumTurns,
+            finalText: finalText ? (finalText.length > 100 ? finalText.slice(0, 100) + '…' : finalText) : undefined,
+            chatmode: entry.currentTaskChatmode ?? undefined,
+            encrypt: entry.currentTaskEncrypt ?? undefined,
+        });
+        entry.lastTaskEnd = buildTaskEnd(entry.currentTaskReplyCount, entry.currentTaskThoughtPutCount, entry.currentTaskLastThoughtText ?? undefined);
+        // 500ms 后从 jsonl 重新统计（覆盖 thought.put 异步延迟问题）
+        if (this.sessionsDir && startedAt != null) {
+            const sessionsDir = this.sessionsDir;
+            const toolUseCount = entry.currentTaskToolUseCount;
+            const resolvedNumTurns = numTurns ?? entry.currentTaskNumTurns;
+            const chatmode = entry.currentTaskChatmode;
+            const encrypt = entry.currentTaskEncrypt;
+            setTimeout(() => {
+                try {
+                    const { chatDirPath } = require('../core/session/session-fs-store.js');
+                    // 找该 aid 下所有 peer 的 messages.jsonl，统计 ts >= startedAt 的出站条目
+                    const aidDir = path.join(sessionsDir, 'aun', aid.replace(/[/%\\:*?"<>|]/g, ch => '%' + ch.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')));
+                    if (!fs.existsSync(aidDir))
+                        return;
+                    let msgCount = 0, thoughtCount = 0;
+                    let lastThoughtText;
+                    let lastMsgText;
+                    for (const peerDir of fs.readdirSync(aidDir, { withFileTypes: true })) {
+                        if (!peerDir.isDirectory() || peerDir.name.startsWith('_'))
+                            continue;
+                        const msgFile = path.join(aidDir, peerDir.name, 'messages.jsonl');
+                        if (!fs.existsSync(msgFile))
+                            continue;
+                        const lines = fs.readFileSync(msgFile, 'utf-8').split('\n').filter(Boolean);
+                        for (const line of lines) {
+                            try {
+                                const rec = JSON.parse(line);
+                                if (rec.dir !== 'out' || rec.ts < startedAt || rec.ts > taskEndTs + 2000)
+                                    continue;
+                                if (rec.msgType === 'thought') {
+                                    thoughtCount++;
+                                    if (rec.content)
+                                        lastThoughtText = rec.content.length > 100 ? rec.content.slice(0, 100) + '…' : rec.content;
+                                }
+                                else if (rec.msgType === 'text') {
+                                    msgCount++;
+                                    if (rec.content)
+                                        lastMsgText = rec.content.length > 100 ? rec.content.slice(0, 100) + '…' : rec.content;
+                                }
+                            }
+                            catch { }
+                        }
+                    }
+                    const currentEntry = this.entries.get(aid);
+                    if (currentEntry?.lastTaskEnd?.ts === taskEndTs) {
+                        currentEntry.lastTaskEnd = {
+                            ts: taskEndTs,
+                            status,
+                            errorType,
+                            sentDuringTask: msgCount > 0,
+                            thoughtDuringTask: thoughtCount > 0,
+                            lastThoughtText: lastThoughtText,
+                            replyCount: msgCount,
+                            thoughtPutCount: thoughtCount,
+                            toolUseCount,
+                            numTurns: resolvedNumTurns,
+                            finalText: finalText ? (finalText.length > 100 ? finalText.slice(0, 100) + '…' : finalText) : undefined,
+                            chatmode: chatmode ?? undefined,
+                            encrypt: encrypt ?? undefined,
+                        };
+                        // 更新 lastSentText 为最后一条 msg（如果有）
+                        if (lastMsgText && msgCount > 0) {
+                            currentEntry.lastSentText = lastMsgText;
+                        }
+                    }
+                }
+                catch { }
+            }, 500);
+        }
+        entry.currentTaskStartAt = null;
+        entry.currentTaskReplyCount = 0;
+        entry.currentTaskThoughtPutCount = 0;
+        entry.currentTaskToolUseCount = 0;
+        entry.currentTaskNumTurns = 0;
+        entry.currentTaskLastThoughtText = null;
+    }
     setSelfName(aid, name) {
         const entry = this.getOrCreate(aid);
         entry.selfName = name;
     }
-    recordInbound(aid, fromPeer, byteLength, text, isSystem = false) {
+    recordInbound(aid, fromPeer, byteLength, text, isSystem = false, encrypt, chatmode) {
         const entry = this.getOrCreate(aid);
         if (isSystem) {
             entry.systemReceived++;
@@ -142,11 +335,15 @@ export class AidStatsCollector {
             entry.lastReceivedFrom = fromPeer;
             if (text)
                 entry.lastReceivedText = text.length > 100 ? text.slice(0, 100) + '…' : text;
+            if (encrypt != null)
+                entry.lastReceivedEncrypt = encrypt;
+            if (chatmode)
+                entry.lastReceivedChatmode = chatmode;
         }
         entry.bytesReceived += byteLength;
         entry.uniquePeers.add(fromPeer);
     }
-    recordOutbound(aid, toPeer, byteLength, text, isSystem = false) {
+    recordOutbound(aid, toPeer, byteLength, text, isSystem = false, encrypt, chatmode) {
         const entry = this.getOrCreate(aid);
         if (isSystem) {
             entry.systemSent++;
@@ -157,6 +354,18 @@ export class AidStatsCollector {
             entry.lastSentTo = toPeer;
             if (text)
                 entry.lastSentText = text.length > 100 ? text.slice(0, 100) + '…' : text;
+            if (encrypt != null)
+                entry.lastSentEncrypt = encrypt;
+            if (chatmode)
+                entry.lastSentChatmode = chatmode;
+            // 累计当前 task 的回复数
+            if (entry.currentTaskStartAt != null) {
+                entry.currentTaskReplyCount++;
+                if (chatmode)
+                    entry.currentTaskChatmode = chatmode;
+                if (encrypt != null)
+                    entry.currentTaskEncrypt = encrypt;
+            }
         }
         entry.bytesSent += byteLength;
         entry.uniquePeers.add(toPeer);
@@ -180,11 +389,16 @@ export class AidStatsCollector {
                 lastSentAt: entry.lastSentAt,
                 lastReceivedText: entry.lastReceivedText,
                 lastReceivedFrom: entry.lastReceivedFrom,
+                lastReceivedEncrypt: entry.lastReceivedEncrypt,
+                lastReceivedChatmode: entry.lastReceivedChatmode,
                 lastSentText: entry.lastSentText,
                 lastSentTo: entry.lastSentTo,
+                lastSentEncrypt: entry.lastSentEncrypt,
+                lastSentChatmode: entry.lastSentChatmode,
                 uniquePeerCount: entry.uniquePeers.size,
                 processing: queueStats.processing,
                 queued: queueStats.queued,
+                lastTaskEnd: entry.lastTaskEnd,
             });
         }
         return out;

package/kits/docs/evolclaw/MSG_PRIVATE.md

@@ -1,25 +1,72 @@
 # 私聊消息命令
 
-<!-- TODO: 填充私聊消息命令详细参考 -->
-
 ## 发送消息
 
+### 以指定 AID 发送（首选）
+
+```bash
+# 明文
+ec msg send <from-aid> <to-aid> "<message>"
+
+# 密文（E2EE）
+ec msg send <from-aid> <to-aid> "<message>" --encrypt
+```
+
+### 发送文件
+
 ```bash
-evolclaw msg send <from-aid> <to-aid> "<message>"
+ec msg send <from-aid> <to-aid> --file <path>
+ec msg send <from-aid> <to-aid> --file <path> --as image
+ec msg send <from-aid> <to-aid> --file <path> --encrypt
 ```
 
+`--as` 可选值：`image` | `video` | `voice` | `file`（默认按扩展名推断）
+
 ## 拉取消息
 
 ```bash
-evolclaw msg pull <self-aid> --app <app-name>
+ec msg pull <self-aid> --app <app-name>
+ec msg pull <self-aid> --app <app-name> --after-seq <N> --limit <N>
+```
+
+## 确认消息已读
+
+```bash
+ec msg ack <self-aid> <seq> --app <app-name>
 ```
 
-## 确认消息
+`--app` 必须传，否则会污染 daemon 游标。
+
+## 撤回消息
 
 ```bash
-evolclaw msg ack <self-aid> --app <app-name> --seq <seq>
+ec msg recall <self-aid> <message-id>
+```
+
+## 查询在线状态
+
+```bash
+ec msg online <self-aid> <target-aid>
 ```
 
 ## 自主回复策略
 
 收到消息 ≠ 必须回复。是否回复、怎么回复、何时回复由 agent 自主决定。
+
+加密策略：
+- 对端发来密文消息时，回复也应使用 `--encrypt`（保持对话加密一致性）
+- 对端发来明文消息时，默认明文回复
+
+## 在当前会话中快速回复（备选）
+
+仅当无法使用 `ec msg send` 时（如不知道自己的 AID），可用 `ec ctl send`：
+
+```bash
+# 明文
+ec ctl send "<text>"
+
+# 密文
+ec ctl send --encrypt "<text>"
+```
+
+`ec ctl send` 自动继承当前会话的 AID 和对端，无需指定。

package/kits/rules/06-channel.md

@@ -13,6 +13,36 @@
 
 与其他主体通信时，**必须调用 CLI 命令**发消息，不要把输出当成发送给对方的内容。
 
+### 必须使用 `ec msg send`（首选）
+
+```bash
+# 明文
+ec msg send <self-aid> <to-aid> "<text>"
+
+# 密文
+ec msg send <self-aid> <to-aid> "<text>" --encrypt
+```
+
+`<self-aid>` 是注入上下文里的 selfAid，`<to-aid>` 是 peerKey 解析出的对端 AID。
+
+### 仅在无法获取 selfAid 时才用 `ec ctl send`
+
+```bash
+ec ctl send "<text>"
+ec ctl send --encrypt "<text>"
+```
+
+### 加密策略
+
+对端发来密文消息时回复必须加密；明文消息默认明文回复。
+
+### 命令返回值
+
+- 成功：`ok` 或包含 `✓ 已发送 ...` 的输出（exit 0）
+- 失败：`✗ ...` 错误信息（exit 非零）
+
+发送成功后**继续后续处理**。一次任务可能发 0 到多条消息，不要因为看到"已发送"就反复发送同一条消息。
+
 不同渠道有不同的命令行工具，使用方式参见各渠道文档。
 
 ## Agent 管理命令

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolclaw",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Lightweight AI Agent gateway connecting Claude Agent SDK to messaging channels (Feishu, ACP) with multi-project session management",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
     "prepublishOnly": "npm run build && npm test"
   },
   "dependencies": {
-    "@agentunion/fastaun": "^0.3.0",
+    "@agentunion/fastaun": "^0.3.2",
     "@anthropic-ai/claude-agent-sdk": "^0.2.100",
     "cron-parser": "^5.5.0",
     "image-type": "^6.0.0",