evolclaw 3.1.0 → 3.1.2

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

@@ -2,7 +2,6 @@ import path from 'path';
 import fs from 'fs';
 import crypto from 'crypto';
 import { hasCompact } from '../../agents/claude-runner.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';
@@ -396,7 +395,8 @@ 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: 'task:started', sessionId: session.id });
+            const taskEncrypt = message.replyContext?.metadata?.encrypted != null ? !!(message.replyContext.metadata.encrypted) : undefined;
+            this.eventBus.publish({ type: 'task:started', sessionId: session.id, agentName: agentNameForStats, encrypt: taskEncrypt, chatmode: session.sessionMode || 'interactive' });
             // 触发器消息不发 processing status（无需通知用户）
             if (message.source !== 'trigger') {
                 adapter.send(envelope, { kind: 'status.started' }).catch(() => { });
@@ -581,7 +581,7 @@ 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);
-                            renderer.addNotice(`⚠️ API 暂时不可用，${delay / 1000}秒后重试 (${attempt}/${MAX_RETRIES})...`, 'warn', 'retry', true);
+                            renderer.addNotice(`API 暂时不可用，${delay / 1000}秒后重试 (${attempt}/${MAX_RETRIES})...`, 'warn', 'retry', true);
                             await renderer.flush();
                             await new Promise(resolve => setTimeout(resolve, delay));
                             continue;
@@ -593,12 +593,12 @@ export class MessageProcessor {
             catch (error) {
                 if (classifyError(error) === ErrorType.CONTEXT_TOO_LONG && session.agentSessionId && hasCompact(agent)) {
                     // 尝试 compact 压缩会话
-                    renderer.addNotice('\u26a0\ufe0f 上下文过长，正在压缩会话...', 'warn', 'compact-trigger', true);
+                    renderer.addNotice('上下文过长，正在压缩会话...', 'warn', 'compact-trigger', true);
                     await renderer.flush();
                     const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
                     if (compacted) {
                         // compact 成功，带 resume 重试（不重复原始消息，让 Agent 继续未完成的工作）
-                        renderer.addNotice('\u2705 压缩完成，正在重试...', 'info', 'compact-retry', true);
+                        renderer.addNotice('✅ 压缩完成，继续处理...', '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, renderer, resetTimer, shouldSuppress);
@@ -620,11 +620,11 @@ export class MessageProcessor {
                 contextTooLongPattern.test(errorsText) ||
                 contextTooLongPattern.test(streamResult.fullText));
             if (isPromptTooLong) {
-                renderer.addNotice('⚠️ 上下文过长，正在压缩会话...', 'warn', 'compact-trigger', true);
+                renderer.addNotice('上下文过长，正在压缩会话...', 'warn', 'compact-trigger', true);
                 await renderer.flush();
                 const compacted = await agent.compact(session.id, session.agentSessionId, absoluteProjectPath);
                 if (compacted) {
-                    renderer.addNotice('✅ 压缩完成，正在重试...', 'info', 'compact-retry', true);
+                    renderer.addNotice('✅ 压缩完成，继续处理...', '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, renderer, resetTimer, shouldSuppress);
@@ -638,7 +638,7 @@ export class MessageProcessor {
                 contextTooLongPattern.test(errorsText) ||
                 contextTooLongPattern.test(streamResult.fullText))) {
                 // 上下文过长但无法 auto-compact（无 session ID 或 agent 不支持），显示友好提示
-                renderer.addNotice('⚠️ 上下文过长，请精简提问或使用 /compact 压缩上下文', 'warn', 'context-too-long', true);
+                renderer.addNotice('上下文过长，请精简提问或使用 /compact 压缩上下文', 'warn', 'context-too-long', true);
             }
             // 处理文件标记 - 支持 [SEND_FILE:path] 和 [SEND_FILE:channel:path]
             // 注意：始终扫描全部文本（含中间轮），因为文件标记可能出现在任意轮次
@@ -829,6 +829,7 @@ export class MessageProcessor {
                     finalText: streamResult.lastReplyText || undefined,
                     durationMs: Date.now() - startTime,
                     agentName: agentNameForStats,
+                    numTurns: streamResult.numTurns,
                     timestamp: Date.now()
                 });
                 // 记录处理完成
@@ -839,24 +840,8 @@ 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,
-                        numTurns: streamResult.numTurns,
-                        usage: streamResult.usage,
-                    }));
-                }
+                // 写入消息记录（出方向）已下沉到 aun.ts:deliverTextEntry，
+                // 所有 message.send 成功后统一写入 messages.jsonl，此处不再重复写入。
             }
             const isFinallyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
             if (isFinallyBackground && session.sessionMode !== 'autonomous') {
@@ -980,7 +965,13 @@ export class MessageProcessor {
             return { session, absoluteProjectPath };
         }
         const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, projectPath, message.threadId, metadata, undefined, message.peerId, undefined, undefined, undefined, undefined, message.peerType);
-        // 兜底纠正：旧 session 创建时没传 peerType（建为 interactive），后续非 human 消息进来时升级为 proactive。
+        // 兜底纠正1：群聊强制 proactive
+        if (message.chatType === 'group' && session.sessionMode !== 'proactive') {
+            logger.info(`[MessageProcessor] group proactive upgrade: sessionId=${session.id} ${session.sessionMode} -> proactive`);
+            session.sessionMode = 'proactive';
+            await this.sessionManager.updateSession(session.id, { sessionMode: 'proactive' });
+        }
+        // 兜底纠正2：旧 session 创建时没传 peerType（建为 interactive），后续非 human 消息进来时升级为 proactive。
         // 新建场景已由 getOrCreateSession 内部 resolveDefaultSessionMode 处理，这里只兜底历史会话。
         if (message.peerType && message.peerType !== 'human' && message.peerType !== 'unknown' && session.sessionMode !== 'proactive') {
             logger.info(`[MessageProcessor] proactive upgrade: sessionId=${session.id} ${session.sessionMode} -> proactive (peerType=${message.peerType})`);
@@ -1076,7 +1067,7 @@ export class MessageProcessor {
                         lastReplyText += event.text;
                         this.eventBus.publish({ type: 'message:text', sessionId: session.id, text: event.text, isFinal: false });
                         if (!shouldSuppress()) {
-                            renderer.addText(event.text);
+                            renderer.addText(event.text, event.outputTokens, event.turn);
                         }
                     }
                     // compact 完成
@@ -1118,7 +1109,7 @@ export class MessageProcessor {
                             if (event.callId) {
                                 toolDescByCallId.set(event.callId, desc);
                             }
-                            renderer.addToolCall(event.name, event.input, event.callId, desc);
+                            renderer.addToolCall(event.name, event.input, event.callId, desc, event.turn, event.outputTokens);
                         }
                     }
                     // 工具结果
@@ -1154,7 +1145,7 @@ export class MessageProcessor {
                         const isContextError = /prompt is too long|input is too long|上下文过长/i.test(event.error || '');
                         if (!isContextError && !hasErrorResult && !shouldSuppress()) {
                             hasErrorResult = true;
-                            renderer.addNotice(`\u274c ${event.error}`, 'warn', 'runtime-error', true);
+                            renderer.addNotice(`${event.error}`, 'warn', 'runtime-error', true);
                         }
                     }
                     // 完成事件
@@ -1169,6 +1160,8 @@ export class MessageProcessor {
                         }
                         // 记录完成状态 + 最后一轮回复文本（后续 complete 覆盖前序）
                         completeResult = { isError: !!event.isError, subtype: event.subtype, errors: event.errors, terminalReason: event.terminalReason, lastReplyText, fullText: event.result || '', hasReceivedText, numTurns: event.numTurns, usage: event.usage };
+                        // thought jsonl 写入已下沉到 aun.ts:sendThought 成功后，
+                        // 由那里按 LLM 输出的每个 text item 单独写一条，此处不再写。
                         // 失败且无前置错误输出：显示 errors 摘要
                         // 但用户主动中断（新消息打断 或 /stop 命令）时不显示错误提示
                         // 上下文过长的错误留给外层 isPromptTooLong 触发 auto-compact，不在此处输出
@@ -1178,11 +1171,11 @@ export class MessageProcessor {
                             || /prompt is too long|input is too long|上下文过长/i.test(event.errors?.join(' ') || '')
                             || /prompt is too long|input is too long|上下文过长/i.test(lastReplyText);
                         if (event.isError && !hasErrorResult && !shouldSuppress() && !isUserInterrupt && !isContextTooLong) {
-                            const errorSummary = event.errors?.join('; ') || '\u4efb\u52a1\u6267\u884c\u5931\u8d25';
-                            // 使用 terminalReason 提供更友好的错误提示
+                            const errorSummary = event.errors?.join('; ') || '任务执行失败';
+                            // 使用 terminalReason 提供更友好的错误提示（不带 emoji，由 formatter 统一加）
                             const userFriendlyMessage = event.terminalReason
-                                ? getErrorMessage(null, event.terminalReason)
-                                : `\u274c ${errorSummary}`;
+                                ? getErrorMessage(null, event.terminalReason, false)
+                                : errorSummary;
                             renderer.addNotice(userFriendlyMessage, 'warn', 'task-error', true);
                         }
                         // 中间 complete：flush 掉已有 activities（不带 isFinal），让中间结果及时显示
@@ -1229,6 +1222,7 @@ export class MessageProcessor {
                         finalText: lastReplyText || event.result || undefined,
                         durationMs: event.durationMs,
                         agentName: agentNameForStats,
+                        numTurns: event.numTurns,
                         timestamp: Date.now()
                     });
                 }
@@ -1282,7 +1276,7 @@ export class MessageProcessor {
                 logger.error('[MessageProcessor] Stream processing error:', error);
             }
             if (error instanceof Error && error.message.includes('process exited')) {
-                renderer.addNotice('\u274c Claude Code \u8fdb\u7a0b\u5f02\u5e38\u9000\u51fa\uff0c\u8bf7\u91cd\u8bd5', 'warn', 'process-exit', true);
+                renderer.addNotice('Claude Code 进程异常退出，请重试', '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

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

@@ -0,0 +1,161 @@
+/**
+ * PeerIdentityCache - 对端身份缓存管理
+ *
+ * 职责：
+ * 1. 从对端的 agent.md 确定身份（human / agent）
+ * 2. 缓存到关系层文件（30天时效）
+ * 3. 支持入站和出站消息的身份查询
+ *
+ * 信源：对端的 agent.md（通过 AUN SDK 下载并验签）
+ * 判定规则：type !== 'human' → agent
+ * 缓存位置：$AGENT_DIR/relations/<channel>#<urlEncode(peerId)>/peer-identity.json
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { logger } from '../../utils/logger.js';
+/**
+ * 对端身份缓存管理器
+ */
+export class PeerIdentityCache {
+    /** 缓存最大时效：30 天 */
+    static CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+    /**
+     * 获取 peer-identity.json 文件路径
+     */
+    static getFilePath(channel, peerId, agentDir) {
+        const peerKey = `${channel}#${encodeURIComponent(peerId)}`;
+        return path.join(agentDir, 'relations', peerKey, 'peer-identity.json');
+    }
+    /**
+     * 从文件读取缓存
+     * @returns PeerIdentity | null（缓存不存在）
+     */
+    static get(channel, peerId, agentDir) {
+        const filePath = this.getFilePath(channel, peerId, agentDir);
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 检查缓存是否需要刷新
+     * @param maxAgeMs 最大缓存时间（默认 30 天）
+     * @returns true=需要刷新
+     */
+    static needsRefresh(channel, peerId, agentDir, maxAgeMs = this.CACHE_MAX_AGE_MS) {
+        const cached = this.get(channel, peerId, agentDir);
+        if (!cached)
+            return true;
+        return Date.now() - cached.lastCheckedAt > maxAgeMs;
+    }
+    /**
+     * 从 agent.md 更新身份信息
+     * @param agentMd 已验签的 agent.md 内容
+     */
+    static updateFromAgentMd(channel, peerId, agentDir, agentMd, verifiedAt) {
+        // 解析 type 和 name
+        const typeMatch = agentMd.match(/^type:\s*["']?(\w+)["']?/m);
+        const nameMatch = agentMd.match(/^name:\s*["']?(.+?)["']?\s*$/m);
+        const type = typeMatch?.[1] || 'unknown';
+        const isAgent = type !== 'human';
+        const name = nameMatch?.[1]?.trim();
+        // 计算 hash
+        const agentMdHash = 'sha256:' + crypto.createHash('sha256').update(agentMd, 'utf-8').digest('hex');
+        // 构建身份信息
+        const identity = {
+            aid: peerId,
+            type,
+            isAgent,
+            name,
+            agentMdHash,
+            verifiedAt,
+            lastCheckedAt: Date.now(),
+            source: 'agentmd',
+        };
+        // 写入文件
+        const filePath = this.getFilePath(channel, peerId, agentDir);
+        try {
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.writeFileSync(filePath, JSON.stringify(identity, null, 2), 'utf-8');
+            logger.debug(`[PeerIdentityCache] Updated: ${channel}#${peerId} type=${type} isAgent=${isAgent}`);
+        }
+        catch (err) {
+            logger.warn(`[PeerIdentityCache] Failed to write cache: ${filePath} err=${err}`);
+        }
+        return identity;
+    }
+    /**
+     * 标记为 unknown（验签失败或无 agent.md）
+     */
+    static markUnknown(channel, peerId, agentDir) {
+        const identity = {
+            aid: peerId,
+            type: 'unknown',
+            isAgent: true, // 验签失败 → 当做 agent（安全策略）
+            agentMdHash: '',
+            verifiedAt: 0,
+            lastCheckedAt: Date.now(),
+            source: 'unknown',
+        };
+        const filePath = this.getFilePath(channel, peerId, agentDir);
+        try {
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.writeFileSync(filePath, JSON.stringify(identity, null, 2), 'utf-8');
+            logger.debug(`[PeerIdentityCache] Marked unknown: ${channel}#${peerId}`);
+        }
+        catch (err) {
+            logger.warn(`[PeerIdentityCache] Failed to write unknown cache: ${filePath} err=${err}`);
+        }
+        return identity;
+    }
+    /**
+     * 完整流程：检查缓存 → 需要刷新则下载 agent.md → 更新缓存
+     *
+     * @param channel 渠道类型（如 'aun'）
+     * @param peerId 对端 ID（AUN 是 AID）
+     * @param agentDir agent 数据根目录
+     * @param aunClient AUN SDK client（需要有 fetchAgentMd 方法）
+     * @param forceRefresh 强制刷新（忽略缓存时效）
+     * @returns PeerIdentity
+     */
+    static async resolve(channel, peerId, agentDir, aunClient, forceRefresh = false) {
+        // 1. 检查缓存
+        if (!forceRefresh && !this.needsRefresh(channel, peerId, agentDir)) {
+            const cached = this.get(channel, peerId, agentDir);
+            if (cached) {
+                logger.debug(`[PeerIdentityCache] Cache hit: ${channel}#${peerId} type=${cached.type} age=${Math.floor((Date.now() - cached.lastCheckedAt) / 1000 / 60 / 60 / 24)}d`);
+                return cached;
+            }
+        }
+        // 2. 下载并验签 agent.md（SDK 自动验签）
+        try {
+            logger.debug(`[PeerIdentityCache] Fetching agent.md: ${channel}#${peerId}`);
+            const result = await aunClient.fetchAgentMd(peerId);
+            const agentMd = result.content;
+            // 3. 更新缓存
+            return this.updateFromAgentMd(channel, peerId, agentDir, agentMd, Date.now());
+        }
+        catch (err) {
+            // 验签失败或下载失败 → 标记为 unknown，当做 agent
+            logger.warn(`[PeerIdentityCache] Failed to fetch agent.md: ${channel}#${peerId} err=${err instanceof Error ? err.message : String(err)}`);
+            return this.markUnknown(channel, peerId, agentDir);
+        }
+    }
+    /**
+     * 清除指定对端的缓存
+     */
+    static clear(channel, peerId, agentDir) {
+        const filePath = this.getFilePath(channel, peerId, agentDir);
+        try {
+            fs.unlinkSync(filePath);
+            logger.debug(`[PeerIdentityCache] Cleared: ${channel}#${peerId}`);
+        }
+        catch {
+            // 文件不存在，忽略
+        }
+    }
+}

package/dist/core/session/session-fs-store.js

@@ -146,6 +146,29 @@ export function scanChatDirs(sessionsDir) {
         if (!typeEntry.isDirectory())
             continue;
         const channelType = typeEntry.name;
+        // 包含 '#' 的目录是旧 channelKey 格式（如 'aun#dddd.agentid.pub#main'），
+        // 按通用 channel 布局扫描（sessionsDir/{channelKey}/{encodedChannelId}/），保持兼容
+        if (channelType.includes('#')) {
+            const typeDir = path.join(sessionsDir, channelType);
+            let chatEntries;
+            try {
+                chatEntries = fs.readdirSync(typeDir, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const chatEntry of chatEntries) {
+                if (!chatEntry.isDirectory())
+                    continue;
+                results.push({
+                    channelType,
+                    selfId: null,
+                    channelId: decodeSegment(chatEntry.name),
+                    dirPath: path.join(typeDir, chatEntry.name),
+                });
+            }
+            continue;
+        }
         const typeDir = path.join(sessionsDir, channelType);
         if (channelType === 'aun') {
             // aun 下还有一层 selfId

package/dist/core/session/session-manager.js

@@ -32,11 +32,15 @@ export class SessionManager {
         this.sessionModeResolver = resolver;
     }
     resolveDefaultSessionMode(channel, chatType, peerType) {
-        // 非 human 对端（ai/bot）强制 proactive，无视 agent 的默认 chatmode 配置
+        const ct = chatType || 'private';
+        // 来源2：群聊强制 proactive
+        if (ct === 'group')
+            return 'proactive';
+        // 来源3：非 human 对端（ai/bot）强制 proactive，无视 agent 的默认 chatmode 配置
         if (peerType && peerType !== 'human' && peerType !== 'unknown')
             return 'proactive';
-        const ct = chatType || 'private';
-        const resolved = this.sessionModeResolver?.(channel, ct);
+        // 来源1：agent 配置默认值
+        const resolved = this.sessionModeResolver?.(channel, ct, peerType);
         return resolved || 'interactive';
     }
     registerFileAdapter(adapter) {
@@ -536,7 +540,10 @@ export class SessionManager {
         this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
     }
     getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfId, channelType, peerType) {
-        const chatDir = this.ensureResolvedChatDir(channel, channelId);
+        // 优先使用精确路径（channelType + selfId），避免 fallback 到错误目录
+        const chatDir = (channelType && selfId)
+            ? (() => { const d = chatDirPath(this.sessionsDir, channelType, channelId, selfId); fs.mkdirSync(d, { recursive: true }); fs.mkdirSync(path.join(d, '_threads'), { recursive: true }); return d; })()
+            : this.ensureResolvedChatDir(channelType || channel, channelId);
         const threadIndex = readThreadIndex(chatDir);
         const existingMetaId = threadIndex[threadId];
         if (existingMetaId) {

package/dist/core/trigger/manager.js

@@ -92,6 +92,22 @@ export class TriggerManager {
         }
         return { active, history };
     }
+    update(id, patch) {
+        const t = this.triggers.get(id);
+        if (!t)
+            throw new Error(`触发器不存在：${id}`);
+        // Check name uniqueness if name is being changed
+        if (patch.name && patch.name !== t.name) {
+            for (const other of this.triggers.values()) {
+                if (other.id !== id && other.name === patch.name) {
+                    throw new Error(`触发器名称已存在：${patch.name}`);
+                }
+            }
+        }
+        Object.assign(t, patch, { updatedAt: Date.now() });
+        this.save();
+        return t;
+    }
     updateFireStats(id, firedAt) {
         const t = this.triggers.get(id);
         if (!t)

package/dist/core/trigger/parser.js

@@ -43,6 +43,116 @@ export function validateCronExpr(expr) {
         return false;
     }
 }
+export function parseTriggerUpdate(args) {
+    // First token is the trigger name/id, rest is flags
+    const trimmed = args.trim();
+    if (!trimmed) {
+        return { ok: false, error: '用法：/trigger update <名称|ID> [--参数...]' };
+    }
+    // Extract nameOrId: first non-flag token (could be quoted)
+    let nameOrId;
+    let rest;
+    if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
+        const quote = trimmed[0];
+        const end = trimmed.indexOf(quote, 1);
+        if (end === -1) {
+            return { ok: false, error: '名称引号未闭合' };
+        }
+        nameOrId = trimmed.slice(1, end);
+        rest = trimmed.slice(end + 1).trim();
+    }
+    else {
+        const spaceIdx = trimmed.indexOf(' ');
+        if (spaceIdx === -1) {
+            return { ok: false, error: '至少需要指定一个修改参数（如 --prompt、--delay 等）' };
+        }
+        nameOrId = trimmed.slice(0, spaceIdx);
+        rest = trimmed.slice(spaceIdx + 1).trim();
+    }
+    if (!rest) {
+        return { ok: false, error: '至少需要指定一个修改参数（如 --prompt、--delay 等）' };
+    }
+    const flags = parseFlags(rest);
+    if (flags.size === 0) {
+        return { ok: false, error: '至少需要指定一个修改参数（如 --prompt、--delay 等）' };
+    }
+    const result = {};
+    // Parse schedule if provided (only one allowed)
+    const hasDelay = flags.has('delay');
+    const hasAt = flags.has('at');
+    const hasCron = flags.has('cron');
+    const timeCount = [hasDelay, hasAt, hasCron].filter(Boolean).length;
+    if (timeCount > 1) {
+        return { ok: false, error: '--delay、--at、--cron 互斥，只能指定一个' };
+    }
+    if (hasDelay) {
+        const raw = flags.get('delay');
+        const ms = parseDuration(raw);
+        if (ms === null)
+            return { ok: false, error: `无法解析 --delay "${raw}"，支持格式：30m、2h、1d、2h30m` };
+        result.scheduleType = 'delay';
+        result.scheduleValue = String(ms);
+    }
+    else if (hasAt) {
+        const raw = flags.get('at');
+        const ts = parseIsoDate(raw);
+        if (ts === null)
+            return { ok: false, error: `无法解析 --at "${raw}"，请使用 ISO 格式，如 2026-05-15T09:00` };
+        if (ts <= Date.now())
+            return { ok: false, error: `--at 时间已过期：${raw}` };
+        result.scheduleType = 'at';
+        result.scheduleValue = new Date(ts).toISOString();
+    }
+    else if (hasCron) {
+        const raw = flags.get('cron');
+        if (!validateCronExpr(raw))
+            return { ok: false, error: `无效的 cron 表达式："${raw}"` };
+        result.scheduleType = 'cron';
+        result.scheduleValue = raw;
+    }
+    // Parse optional fields
+    if (flags.has('prompt')) {
+        const prompt = flags.get('prompt');
+        if (!prompt || prompt === true)
+            return { ok: false, error: '--prompt 不能为空' };
+        if (typeof prompt === 'string' && prompt.length > 4096)
+            return { ok: false, error: '--prompt 超过 4096 字符限制' };
+        result.prompt = prompt;
+    }
+    if (flags.has('name')) {
+        const name = flags.get('name');
+        if (!name || name === true)
+            return { ok: false, error: '--name 不能为空' };
+        result.name = name;
+    }
+    if (flags.has('session')) {
+        const sv = flags.get('session');
+        if (sv !== 'latest' && sv !== 'silent')
+            return { ok: false, error: '--session 只接受 latest 或 silent' };
+        result.targetSessionStrategy = sv;
+    }
+    if (flags.has('agent')) {
+        const agent = flags.get('agent');
+        if (!agent || agent === true)
+            return { ok: false, error: '--agent 不能为空' };
+        result.agentId = agent;
+    }
+    const hasChannel = flags.has('channel');
+    const hasChannelId = flags.has('channelid');
+    if (hasChannel !== hasChannelId) {
+        return { ok: false, error: '--channel 与 --channelid 必须同时指定或同时省略' };
+    }
+    if (hasChannel) {
+        result.targetChannel = flags.get('channel');
+        result.targetChannelId = flags.get('channelid');
+    }
+    if (flags.has('thread')) {
+        if (flags.has('session'))
+            return { ok: false, error: '--thread 与 --session 互斥' };
+        result.targetThreadId = flags.get('thread');
+    }
+    return { ok: true, nameOrId, value: result };
+}
 export function parseTriggerSet(args) {
     const flags = parseFlags(args);
     const hasDelay = flags.has('delay');

package/dist/core/trigger/scheduler.js

@@ -137,6 +137,12 @@ export class TriggerScheduler {
         this.inflightCron.delete(id);
         this.resetTimer();
     }
+    update(trigger) {
+        this.heap.remove(trigger.id);
+        this.heap.push(trigger);
+        this.resetTimer();
+        this.eventBus.publish({ type: 'trigger:updated', triggerId: trigger.id, name: trigger.name, peerId: trigger.createdByPeerId });
+    }
     stop() {
         if (this.timer) {
             clearTimeout(this.timer);