evolclaw 3.2.0 → 3.4.0

package/dist/core/evolagent-registry.js

@@ -1,5 +1,7 @@
+import fs from 'fs';
 import { EvolAgent } from './evolagent.js';
 import { logger } from '../utils/logger.js';
+import { agentMdPath } from '../paths.js';
 import { loadDefaults, loadAllAgents, mergeForAgent, ensureAgentDirSkeleton, loadAgent, validateAgentConfig, } from '../config-store.js';
 // ── Channel Fingerprint ────────────────────────────────────────────────────
 // 用于检测多 agent 之间复用同一外部凭证的冲突（appId、aid、token 等）。
@@ -333,6 +335,44 @@ export class EvolAgentRegistry {
             throw err;
         }
     }
+    // ── Stop / Start（运行时断连/重连，不改 config.enabled）──────────────────
+    async stopAgent(aidOrName, hooks) {
+        const agent = this.agents.get(aidOrName);
+        if (!agent)
+            throw new Error(`Agent "${aidOrName}" not found`);
+        if (agent.status === 'disabled')
+            throw new Error(`Agent is disabled; use enable/disable instead`);
+        if (agent.status === 'stopped')
+            return;
+        // 先断开 AID 连接（下线），让未送达的消息保留在云端；
+        // 然后中断正在执行的大模型调用（不等它跑完）。
+        for (const ch of agent.channelInstanceNames()) {
+            try {
+                await hooks.disconnectChannel(ch);
+            }
+            catch { }
+        }
+        agent.status = 'stopped';
+        this.channelIndex.clear();
+        this.buildChannelIndex();
+        logger.info(`[Registry] Stopped agent ${aidOrName}`);
+    }
+    async startAgent(aidOrName, hooks) {
+        const agent = this.agents.get(aidOrName);
+        if (!agent)
+            throw new Error(`Agent "${aidOrName}" not found`);
+        if (agent.status === 'disabled')
+            throw new Error(`Agent is disabled; use enable instead`);
+        if (agent.status === 'running')
+            return;
+        for (const ch of agent.channelInstanceNames()) {
+            await hooks.startChannel(agent, ch);
+        }
+        agent.status = 'running';
+        this.channelIndex.clear();
+        this.buildChannelIndex();
+        logger.info(`[Registry] Started agent ${aidOrName}`);
+    }
     checkConflictForReload(newRaw, excludeAid) {
         const newFps = new Set();
         for (const inst of newRaw.channels) {
@@ -353,9 +393,51 @@ export class EvolAgentRegistry {
         }
         return null;
     }
+    // ── 友好名缓存（从本地 agent.md 解析，缺失时异步从网络拉取）──
+    displayNameCache = new Map();
+    displayNamePending = new Set();
+    resolveDisplayName(aid) {
+        const cached = this.displayNameCache.get(aid);
+        if (cached)
+            return cached;
+        try {
+            const mdPath = agentMdPath(aid);
+            if (fs.existsSync(mdPath)) {
+                const content = fs.readFileSync(mdPath, 'utf-8');
+                const fm = content.match(/^---\n([\s\S]*?)\n---/);
+                if (fm) {
+                    const nm = fm[1].match(/^name:\s*["']?(.+?)["']?\s*$/m);
+                    if (nm?.[1]) {
+                        this.displayNameCache.set(aid, nm[1]);
+                        return nm[1];
+                    }
+                }
+            }
+        }
+        catch { /* ignore */ }
+        // 异步从网络拉取（仅一次，不阻塞）
+        if (!this.displayNamePending.has(aid)) {
+            this.displayNamePending.add(aid);
+            import('../aun/aid/index.js').then(({ agentmdGet }) => {
+                agentmdGet(aid).then(content => {
+                    if (typeof content === 'string') {
+                        const fm = content.match(/^---\n([\s\S]*?)\n---/);
+                        if (fm) {
+                            const nm = fm[1].match(/^name:\s*["']?(.+?)["']?\s*$/m);
+                            if (nm?.[1])
+                                this.displayNameCache.set(aid, nm[1]);
+                        }
+                    }
+                }).catch(() => { }).finally(() => this.displayNamePending.delete(aid));
+            }).catch(() => { this.displayNamePending.delete(aid); });
+        }
+        return undefined;
+    }
     toInfo(agent) {
         return {
             name: agent.name,
+            displayName: this.resolveDisplayName(agent.aid),
+            aid: agent.aid,
             status: agent.status,
             channels: agent.channelInstanceNames(),
             projectPath: agent.projectPath,

package/dist/core/evolagent.js

@@ -3,7 +3,7 @@ import { logger } from '../utils/logger.js';
 import { saveAgent } from '../config-store.js';
 import { formatChannelKey, tryParseChannelKey } from './channel-loader.js';
 import { agentPersonalDir } from '../paths.js';
-import { fileCache } from './cache/file-cache.js';
+import { fileCache } from './daemon-file-cache.js';
 /**
  * EvolAgent —— 一个 self-agent 的运行时表示。
  *
@@ -177,6 +177,14 @@ export class EvolAgent {
             delete block.model;
         else
             block.model = value;
+        // sync merged so getter reflects the change immediately
+        if (!this.merged.baseagents)
+            this.merged.baseagents = {};
+        const mBlock = ((this.merged.baseagents)[ba] ??= {});
+        if (value === undefined)
+            delete mBlock.model;
+        else
+            mBlock.model = value;
         this.persist();
     }
     setBaseagentEffort(value) {
@@ -189,6 +197,14 @@ export class EvolAgent {
             delete block[fieldName];
         else
             block[fieldName] = value;
+        // sync merged so getter reflects the change immediately
+        if (!this.merged.baseagents)
+            this.merged.baseagents = {};
+        const mBlock = ((this.merged.baseagents)[ba] ??= {});
+        if (value === undefined)
+            delete mBlock[fieldName];
+        else
+            mBlock[fieldName] = value;
         this.persist();
     }
     /** 设置私聊 chatmode（群聊/非 human 强制 proactive，无可写入项）。 */

package/dist/core/interaction-router.js

@@ -68,6 +68,14 @@ export class InteractionRouter {
         const handler = this.handlers.get(response.id);
         if (!handler)
             return false;
+        // Initiator 校验（集中式 backstop）：非发起者的操作直接丢弃，不消费 handler、不解除等待，
+        // 让真正的发起者仍可继续操作。身份只信渠道传入的已认证 operatorId（来自消息信封，非 payload 自报）。
+        // 渠道层若已自行校验（如飞书的 reject toast），此处不会重复命中（operatorId 已匹配）。
+        if (handler.initiatorId && response.operatorId
+            && response.operatorId !== handler.initiatorId) {
+            logger.info(`[InteractionRouter] rejected non-initiator: operator=${response.operatorId} initiator=${handler.initiatorId} id=${response.id}`);
+            return false;
+        }
         if (handler.timer)
             clearTimeout(handler.timer);
         this.handlers.delete(response.id);

package/dist/core/message/command-handler-agent-control.js

@@ -1,7 +1,8 @@
-import { agentCreateNonInteractive, agentDelete, agentEnable, agentDisable, agentList, agentShow, agentSet, } from '../../cli/agent.js';
+import { agentCreateNonInteractive, agentDelete, agentEnable, agentDisable, agentList, agentShow, agentSet, agentReload, } from '../../cli/agent.js';
 import { logger } from '../../utils/logger.js';
 import { resolvePaths } from '../../paths.js';
 import path from 'path';
+import { loadAgent, saveAgent } from '../../config-store.js';
 import { CreateStatusWriter, readCreateStatus } from './create-status.js';
 /** 把 cli/agent.ts 的 error 字符串映射为结构化错误码 */
 function classifyError(error) {
@@ -116,8 +117,69 @@ export async function execAgentAction(action, args, peerId) {
             return { error: res.error, code: classifyError(res.error) };
         return { data: { aid: res.aid, enabled: res.enabled, reloaded: res.reloaded } };
     }
+    if (action === 'reload') {
+        if (!a.aid)
+            return { error: '缺少 aid', code: 'INVALID_ARGS' };
+        const res = await agentReload(a.aid);
+        if (!('ok' in res) || res.ok !== true)
+            return { error: res.error, code: classifyError(res.error) };
+        return { data: { aid: a.aid, reloaded: true } };
+    }
+    if (action === 'update') {
+        return await execAgentUpdate(a);
+    }
     return { error: `不支持的 action: ${action}`, code: 'INVALID_ARGS' };
 }
+/** name=agent 的 menu.action=update：仅落盘 config patch，不触发 reload。
+ *  直接 loadAgent + saveAgent（不走 agentSet，避免其内部自动 evolagent.reload）——
+ *  重载由用户在 Agents 页操作列手动触发（带任务执行检查）。
+ *  AUN 渠道绑定 agent 顶层 aid，不可通过 patch 编辑：拒绝改 aid、拒绝 channels 数组里出现 aun 条目。
+ *  可写字段：baseagents / projects / owners / chatmode / channels（非 aun）。 */
+export async function execAgentUpdate(args) {
+    const a = args ?? {};
+    if (!a.aid)
+        return { error: '缺少 aid', code: 'INVALID_ARGS' };
+    const p = a.patch ?? {};
+    if (p.aid !== undefined) {
+        return { error: 'aid 不可修改（AUN 身份绑定，如需换 AID 请删除后重建）', code: 'INVALID_ARGS' };
+    }
+    if (Array.isArray(p.channels) && p.channels.some((c) => c?.type === 'aun')) {
+        return { error: 'AUN 渠道不可通过 patch 编辑（由 agent aid 隐式管理）', code: 'INVALID_ARGS' };
+    }
+    const config = loadAgent(a.aid);
+    if (!config)
+        return { error: `Agent "${a.aid}" not found`, code: 'NOT_FOUND' };
+    let touched = false;
+    if (p.baseagents !== undefined) {
+        config.baseagents = p.baseagents;
+        touched = true;
+    }
+    if (p.projects !== undefined) {
+        config.projects = p.projects;
+        touched = true;
+    }
+    if (p.owners !== undefined) {
+        config.owners = p.owners;
+        touched = true;
+    }
+    if (p.chatmode !== undefined) {
+        config.chatmode = p.chatmode;
+        touched = true;
+    }
+    if (p.channels !== undefined) {
+        config.channels = p.channels;
+        touched = true;
+    }
+    if (!touched)
+        return { error: 'patch 为空，无可写字段', code: 'INVALID_ARGS' };
+    try {
+        saveAgent(config);
+    }
+    catch (e) {
+        return { error: e?.message || String(e), code: classifyError(e?.message || String(e)) };
+    }
+    return { data: { aid: a.aid, saved: true } };
+}
 /** project 兜底：显式值 > rootPath 合成 > defaultPath > undefined */
 export function resolveProjectPath(explicit, aid, defaults) {
     if (explicit && explicit.trim())

package/dist/core/message/im-renderer.js

@@ -1,23 +1,9 @@
 import { logger } from '../../utils/logger.js';
 import { summarizeToolInput } from '../permission.js';
+import { CONTEXT_TOO_LONG_PATTERN, isContextTooLongText } from '../../utils/error-utils.js';
 import fs from 'fs';
 import path from 'path';
 import { resolvePaths } from '../../paths.js';
-/**
- * 检测是否为上下文过长错误
- * 统一的检测逻辑，覆盖所有已知的错误文本模式
- */
-function isContextTooLongError(text) {
-    if (!text)
-        return false;
-    const lower = text.toLowerCase();
-    return (lower.includes('prompt is too long') ||
-        lower.includes('input is too long') ||
-        lower.includes('context too long') ||
-        lower.includes('context limit') ||
-        lower.includes('context_length_exceeded') ||
-        text.includes('上下文过长'));
-}
 let diagStream = null;
 function getDiagStream() {
     if (!diagStream) {
@@ -107,11 +93,16 @@ export class IMRenderer {
             clearTimeout(this.timer);
             this.timer = undefined;
         }
-        const text = this.textBuffer;
+        // 文件标记过滤：tool_use 前的文本块也不能把 marker 暴露给用户
+        const rawText = this.opts.fileMarkerPattern
+            ? this.textBuffer.replace(this.opts.fileMarkerPattern, '')
+            : this.textBuffer;
         this.textBuffer = '';
+        if (!rawText)
+            return;
         // 清掉 itemsQueue 中的 text items（已发出）
         this.itemsQueue = this.itemsQueue.filter(it => it.kind !== 'text');
-        const payload = { kind: 'result.text', text, isFinal: false };
+        const payload = { kind: 'result.text', text: rawText, isFinal: false };
         this.sentContent = true;
         this.sendChain = this.sendChain
             .then(() => this.opts.send(payload))
@@ -135,9 +126,9 @@ export class IMRenderer {
     // ── 文本/活动注入（替代 StreamFlusher.addText/addActivity）──
     /** 添加文本片段（流式 text） */
     addText(text, outputTokens, turn) {
-        this.emitProgress('text', outputTokens, turn);
         if (this.opts.envelope.chatmode === 'proactive')
             return;
+        this.emitProgress('text', outputTokens, turn);
         if (!text)
             return;
         // 同一窗口内连续 text delta 合并到最后一个 text item
@@ -162,9 +153,9 @@ export class IMRenderer {
     }
     /** 添加工具调用 */
     addToolCall(name, input, callId, descText, turn, outputTokens) {
-        this.emitProgress('tool_call', outputTokens, turn, { toolName: name, callId });
         if (this.opts.envelope.chatmode === 'proactive')
             return;
+        this.emitProgress('tool_call', outputTokens, turn, { toolName: name, callId });
         if (this.opts.suppressActivities)
             return;
         this.itemsQueue.push({
@@ -181,9 +172,9 @@ export class IMRenderer {
     }
     /** 添加工具结果 */
     addToolResult(name, ok, result, error, callId, durationMs, descText) {
-        this.emitProgress('tool_result', undefined, undefined, { toolName: name, callId, ok, durationMs });
         if (this.opts.envelope.chatmode === 'proactive')
             return;
+        this.emitProgress('tool_result', undefined, undefined, { toolName: name, callId, ok, durationMs });
         if (this.opts.suppressActivities)
             return;
         this.itemsQueue.push({
@@ -207,20 +198,35 @@ export class IMRenderer {
             return;
         if (this.opts.suppressActivities)
             return;
-        this.itemsQueue.push({
-            kind: 'progress',
+        this.emitProgress('progress', undefined, undefined, {
             text,
             state: opts.state,
-            tool_uses: opts.toolUses,
-            duration_ms: opts.durationMs,
+            toolUses: opts.toolUses,
+            durationMs: opts.durationMs,
         });
-        this.messageTimestamps.push(Date.now());
-        this.scheduleFlush();
     }
+    /**
+     * proactive 下放行为 thought 的 notice subtype 白名单——仅"真·终态错误"：
+     * - context-too-long：上下文超限且无法 auto-compact，任务到此终止
+     * - process-exit：Agent 子进程异常崩溃（无 complete 事件，emit 完全覆盖不到）
+     * 二者都是用户必须知道、否则会困惑"任务为什么停了"的终态信号。
+     *
+     * 其余 subtype 一律不发：
+     * - compact / runtime-error / task-error：emit() 路径（mapEventToItem）已投影，重复
+     * - compact-start / compact-trigger / compact-retry / retry：内部机务噪音（压缩中/
+     *   重试中/压缩完成），proactive 下用户要的是工作产出而非流水账，压缩后 thought 会
+     *   继续输出，过程本身无需播报。
+     */
+    static PROACTIVE_NOTICE_ALLOW = new Set(['context-too-long', 'process-exit']);
     /** 添加系统提示 / 通知。force=true 时绕过 suppressActivities（用于 compact/retry/error 等操作反馈） */
     addNotice(text, severity, subtype, force = false) {
-        if (this.opts.envelope.chatmode === 'proactive')
+        // proactive 模式：只放行真·终态错误，机务噪音（压缩/重试）和 emit 已覆盖的 subtype 均不发。
+        if (this.opts.envelope.chatmode === 'proactive') {
+            if (subtype == null || !IMRenderer.PROACTIVE_NOTICE_ALLOW.has(subtype))
+                return;
+            this.emitProactiveItem({ kind: 'notice', text, severity, subtype });
             return;
+        }
         if (this.opts.suppressActivities && !force)
             return;
         this.itemsQueue.push({ kind: 'notice', text, severity, subtype });
@@ -308,23 +314,33 @@ export class IMRenderer {
             clearTimeout(this.timer);
             this.timer = undefined;
         }
-        // 上下文错误短语过滤：剔除错误关键词本身，保留前后内容
-        const ctxErrPattern = /prompt is too long|input is too long|context too long|context limit|context_length_exceeded|上下文过长/gi;
-        const stripCtxErr = (s) => s.replace(ctxErrPattern, '').trim();
-        this.textBuffer = stripCtxErr(this.textBuffer);
-        this.allText = stripCtxErr(this.allText);
-        for (const item of this.itemsQueue) {
-            if (item.kind === 'text')
-                item.text = stripCtxErr(item.text);
-        }
-        // 文件标记过滤
+        // 文件标记过滤：marker 任何时候都不该出现在用户文本里，必须在 *每次* flush
+        // （含非最终的定时 flush）执行。否则文本块若滞留 buffer 后被定时器触发，会走
+        // 下方非-final 的 result.text 路径，把 [SEND_FILE:...] 原样发给用户。
+        // 非最终 flush 不做 trim，避免 trim 掉 Markdown 块级换行。
         if (this.opts.fileMarkerPattern) {
-            this.textBuffer = this.textBuffer.replace(this.opts.fileMarkerPattern, '').trim();
+            const strip = (s) => {
+                const replaced = s.replace(this.opts.fileMarkerPattern, '');
+                return isFinal ? replaced.trim() : replaced;
+            };
+            this.textBuffer = strip(this.textBuffer);
             for (const item of this.itemsQueue) {
                 if (item.kind === 'text')
                     item.text = item.text.replace(this.opts.fileMarkerPattern, '');
             }
         }
+        if (isFinal) {
+            // 上下文错误短语过滤：剔除错误关键词本身，保留前后内容。
+            // 只在最终 flush 清理，避免中间定时 flush trim 掉 Markdown 块级换行。
+            const ctxErrPattern = new RegExp(CONTEXT_TOO_LONG_PATTERN.source, 'gi');
+            const stripCtxErr = (s) => s.replace(ctxErrPattern, '').trim();
+            this.textBuffer = stripCtxErr(this.textBuffer);
+            this.allText = stripCtxErr(this.allText);
+            for (const item of this.itemsQueue) {
+                if (item.kind === 'text')
+                    item.text = stripCtxErr(item.text);
+            }
+        }
         // 清掉空 text items
         const items = this.itemsQueue.filter(it => {
             if (it.kind === 'text')
@@ -356,6 +372,25 @@ export class IMRenderer {
             this.lastFlush = Date.now();
             this.flushCount++;
         }
+        // 1.5 非最终定时 flush：把已累积的文本块作为独立 result.text 发出。
+        //   每个 text 事件本身是完整语义块（runner 已合并流式 delta），工具调用前的
+        //   文本一向作为独立气泡发送（见 message-processor 的 flushText 调用）。
+        //   这里补上「文本块后面没有紧跟 tool_use」的情况——例如 readonly 拒绝写文件时
+        //   SDK 直接拒绝、不产生 tool_use 事件，文本会一直滞留 buffer，直到下一个
+        //   tool_use 才被 flushText 带出，并与其后的文本合并成一条（用户侧表现为：
+        //   第一条文本等待一分多钟后才和第二条凑成一条发出）。定时器到期即发，根除滞留。
+        if (!isFinal && this.textBuffer.length > 0) {
+            const text = this.textBuffer;
+            this.textBuffer = '';
+            const payload = { kind: 'result.text', text, isFinal: false };
+            this.sentContent = true;
+            this.sendChain = this.sendChain
+                .then(() => this.opts.send(payload))
+                .catch(e => logger.warn('[IMRenderer] timed result.text send failed:', e));
+            await this.sendChain;
+            this.lastFlush = Date.now();
+            this.flushCount++;
+        }
         // 2. isFinal=true 时单独发最终回复文本
         if (isFinal && finalText.length > 0) {
             const payload = { kind: 'result.text', text: finalText, isFinal: true };
@@ -380,6 +415,9 @@ export class IMRenderer {
                 ...(extra?.callId != null && { callId: extra.callId }),
                 ...(extra?.ok != null && { ok: extra.ok }),
                 ...(extra?.durationMs != null && { durationMs: extra.durationMs }),
+                ...(extra?.text != null && { text: extra.text }),
+                ...(extra?.state != null && { state: extra.state }),
+                ...(extra?.toolUses != null && { toolUses: extra.toolUses }),
             },
         };
         this.opts.send(payload).catch(() => { });
@@ -400,17 +438,19 @@ export class IMRenderer {
             this.hasEmittedText = true;
             this.allText += item.text;
         }
-        const outputTokens = event.outputTokens;
-        const turn = event.turn;
-        const activityType = item.kind === 'text' ? 'text' : item.kind === 'tool_call' ? 'tool_call' : 'tool_result';
-        const extra = item.kind === 'tool_call'
-            ? { toolName: item.name, callId: item.call_id }
-            : item.kind === 'tool_result'
-                ? { toolName: item.name, callId: item.call_id, ok: item.ok, durationMs: item.duration_ms }
-                : undefined;
-        this.emitProgress(activityType, outputTokens, turn, extra);
+        // proactive 模式：status.progress 是 interactive 的处理状态指示器，proactive 下
+        // 过程由 thought（activity.batch）表达，不再发 status.progress（与 addProgress 在
+        // proactive 下的拦截保持一致）。progress-kind item 若进 activity.batch 会被 aun 侧
+        // 回转成 status.progress（见 aun.ts 'activity.batch' 分支），故直接丢弃。
+        // 终态 status（started/completed/interrupted/error）由 message-processor 发送，不受影响。
+        if (item.kind === 'progress') {
+            return;
+        }
+        this.emitProactiveItem(item);
+    }
+    /** proactive 模式逐条投影：单个 ThoughtItem 包成 activity.batch[1] 发出（fire-and-forget）。 */
+    emitProactiveItem(item) {
         const payload = { kind: 'activity.batch', items: [item] };
-        // fire-and-forget
         this.opts.send(payload).catch(err => {
             logger.debug(`[IMRenderer] proactive send failed: ${err.message}`);
         });
@@ -474,15 +514,15 @@ export class IMRenderer {
             }
             case 'error': {
                 // 上下文过长错误不输出（留给外层 auto-compact 处理）
-                if (isContextTooLongError(event.error || ''))
+                if (isContextTooLongText(event.error || ''))
                     return null;
                 return { kind: 'notice', text: event.error, severity: 'warn' };
             }
             case 'complete': {
                 // 上下文过长错误不输出（留给外层 auto-compact 处理）
                 const hasContextError = event.terminalReason === 'prompt_too_long'
-                    || isContextTooLongError(event.errors?.join(' ') || '')
-                    || isContextTooLongError(event.result || '');
+                    || isContextTooLongText(event.errors?.join(' ') || '')
+                    || isContextTooLongText(event.result || '');
                 if (event.isError && hasContextError) {
                     return null;
                 }

package/dist/core/message/items-formatter.js

@@ -34,7 +34,7 @@ function formatItem(item) {
         case 'tool_result': {
             if (!item.ok) {
                 const errMsg = item.error || (typeof item.result === 'string' ? item.result : '执行失败');
-                return `⚠️ ${item.name}: ${errMsg}`;
+                return `⚠️ ${item.name}: ${capLines(errMsg, 5)}`;
             }
             return item.text ? `✓ ${item.name}: ${item.text}` : `✓ ${item.name}`;
         }
@@ -48,6 +48,14 @@ function formatItem(item) {
             return '';
     }
 }
+/** 把多行文本截断到最多 maxLines 行，超出部分用省略提示替代。用于工具报错输出，避免刷屏。 */
+function capLines(text, maxLines) {
+    const lines = text.split('\n');
+    if (lines.length <= maxLines)
+        return text;
+    const omitted = lines.length - maxLines;
+    return lines.slice(0, maxLines).join('\n') + `\n…(省略 ${omitted} 行)`;
+}
 function summarizeArgs(args) {
     if (!args || typeof args !== 'object')
         return '';