evolclaw 3.2.0 → 3.4.0

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

@@ -16,6 +16,7 @@ export class MessageQueue {
     recentMessageIds = new Set();
     DEDUP_WINDOW = 60_000; // 1 分钟窗口
     interceptors = new Map();
+    mutedAgents = new Set(); // 禁言的 agent：消息照常入队，但不取出给大模型
     constructor(handler) {
         this.handler = handler;
     }
@@ -92,8 +93,8 @@ export class MessageQueue {
             if (!this.queues.has(queueKey)) {
                 this.queues.set(queueKey, []);
             }
-            this.queues.get(queueKey).push({ message, projectPath, agentName, resolve, reject });
-            // 根据 interruptible 选项决定是否触发中断
+            const queue = this.queues.get(queueKey);
+            queue.push({ message, projectPath, agentName, resolve, reject });
             if (this.processing.has(queueKey)) {
                 if (options?.interruptible !== false) {
                     // 单聊：保留中断行为
@@ -145,6 +146,14 @@ export class MessageQueue {
                 this.activeMessageIds.clear();
                 return;
             }
+            // 禁言：消息留在队列里，暂停消费（解禁后由 unmuteAgent 重新触发 processNext）
+            const headAgent = queue[0].agentName || DEFAULT_AGENT_NAME;
+            if (this.mutedAgents.has(headAgent)) {
+                logger.info(`[Queue] processNext: agent ${headAgent} muted, pausing key=${queueKey} (${queue.length} queued)`);
+                this.processing.delete(queueKey);
+                this.processingAgent.delete(queueKey);
+                return;
+            }
             // FIFO 贪心合并：弹出队首连续同 peerId 的消息
             const items = this.dequeueGreedy(queue);
             const merged = items.length === 1 ? items[0] : this.mergeItems(items);
@@ -377,4 +386,63 @@ export class MessageQueue {
         }
         return total;
     }
+    /**
+     * 清空指定 agent 的待处理消息（不影响正在处理中的消息）。
+     * 被移除的消息直接 resolve（与 cancel 一致），让 enqueue 的等待方正常解除阻塞。
+     * @returns 被清除的消息数量
+     */
+    clearByAgent(agentName) {
+        let cleared = 0;
+        for (const queue of this.queues.values()) {
+            for (let i = queue.length - 1; i >= 0; i--) {
+                if ((queue[i].agentName || DEFAULT_AGENT_NAME) === agentName) {
+                    const [removed] = queue.splice(i, 1);
+                    removed.resolve();
+                    cleared++;
+                }
+            }
+        }
+        if (cleared > 0)
+            logger.info(`[Queue] Cleared ${cleared} pending message(s) for agent ${agentName}`);
+        return cleared;
+    }
+    /** 禁言 agent：后续消息照常入队，但 processNext 不再取出处理。 */
+    muteAgent(agentName) {
+        this.mutedAgents.add(agentName);
+        logger.info(`[Queue] Muted agent ${agentName}`);
+    }
+    /** 解除禁言：重新触发该 agent 已积压、且当前未在处理的队列。 */
+    unmuteAgent(agentName) {
+        if (!this.mutedAgents.delete(agentName))
+            return;
+        logger.info(`[Queue] Unmuted agent ${agentName}, resuming queued messages`);
+        for (const [key, queue] of this.queues) {
+            if (queue.length > 0 && !this.processing.has(key)) {
+                const headAgent = queue[0].agentName || DEFAULT_AGENT_NAME;
+                if (headAgent === agentName)
+                    this.processNext(key);
+            }
+        }
+    }
+    isAgentMuted(agentName) {
+        return this.mutedAgents.has(agentName);
+    }
+    /** 中断指定 agent 所有正在处理中的会话（停止 agent 时调用）。 */
+    interruptByAgent(agentName) {
+        for (const [queueKey, name] of this.processingAgent) {
+            if ((name || DEFAULT_AGENT_NAME) === agentName) {
+                const sessionKey = queueKey.split('::')[0];
+                logger.info(`[Queue] Interrupting session ${sessionKey} for stopped agent ${agentName}`);
+                this.eventBus?.publish({
+                    type: 'task:interrupted',
+                    sessionId: sessionKey,
+                    reason: 'new_message',
+                    agentName: name,
+                });
+                if (this.interruptCallback) {
+                    this.interruptCallback(sessionKey, this.currentAgentId, name).catch(() => { });
+                }
+            }
+        }
+    }
 }

package/dist/core/message/pending-hints.js

@@ -0,0 +1,232 @@
+// 观察者插话：待用提示（pending-hints）存储。
+//
+// owner 经 observer.inject 给「agent↔对端」会话预埋的提示，落盘为 append-only jsonl，
+// 在下一条对端消息到达、渲染该轮 prompt 时一次性消费、注入渲染层。
+// 详见 docs/observer-insert-design.md 第一部分（§1.3 文件生命周期 / §1.4 thread 作用域）。
+//
+// 文件：sessions/<channelType>/<selfAID>/<对端>/pending-hints.jsonl（与 messages.jsonl 同级）
+// 每行一个事件：
+//   { action:'add',    id, text, threadId, ownerAid, ts }
+//   { action:'remove', targetId?, threadId, ts }   // 无 targetId = 撤该 thread 全部
+//
+// 生命周期 = 一个消费周期（按 (对端,thread) 维度）：
+//   - add/remove 追加行（append-only，处理「加了又撤」的竞态：按时间序回放抵消）
+//   - consume（对端消息到达触发）：回放算「该 thread」有效集 → 返回 → 清掉该 thread 的事件。
+//     · 若文件里其它 thread 仍有未消费提示 → 重写文件只留它们（不误删别的 thread）。
+//     · 否则（无其它 thread 残留）→ 删整个文件。
+//   - 因为 consume 一次性用掉该 thread 的全部有效提示，消费后该 thread 有效集必然归零，
+//     未来状态不依赖消费前历史，故消费即清安全，无需 consume 事件行。
+//   - 任何让「整文件」有效集归零的操作都删文件：consume 后无残留即删；remove 把提示全撤光也删。
+import fs from 'fs';
+import path from 'path';
+import { chatDirPath, appendJsonl, readAllJsonlLines } from '../session/session-fs-store.js';
+import { logger } from '../../utils/logger.js';
+const PENDING_HINTS_FILE = 'pending-hints.jsonl';
+function hintsPath(sessionsDir, channelType, channelId, selfAID) {
+    return path.join(chatDirPath(sessionsDir, channelType, channelId, selfAID), PENDING_HINTS_FILE);
+}
+/** 归一 threadId：undefined/null → ''（主线程）。 */
+function normThread(threadId) {
+    return threadId || '';
+}
+/**
+ * 追加一条 add 事件。返回是否写盘成功（供 ack 判定）。
+ * 写盘成功后才回 ack(accepted)——accepted 真正代表"已持久保存"。
+ */
+export function appendHintAdd(sessionsDir, channelType, channelId, selfAID, hint) {
+    try {
+        const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        const ev = {
+            action: 'add', id: hint.id, text: hint.text,
+            threadId: normThread(hint.threadId), ownerAid: hint.ownerAid, ts: hint.ts,
+        };
+        appendJsonl(fp, ev);
+        return true;
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] appendHintAdd failed: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
+}
+/**
+ * 追加一条 remove 事件。若该操作使 (对端,thread) 有效集归零，则删除整个文件。
+ * 返回是否写盘成功（供 ack 判定）。
+ */
+export function appendHintRemove(sessionsDir, channelType, channelId, selfAID, rm) {
+    try {
+        const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+        if (!fs.existsSync(fp))
+            return true; // 无文件 = 无可撤，幂等成功
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        const ev = {
+            action: 'remove', threadId: normThread(rm.threadId), ts: rm.ts,
+            ...(rm.targetId ? { targetId: rm.targetId } : {}),
+        };
+        appendJsonl(fp, ev);
+        // 撤销后：若全部 thread 的有效集都归零，删文件（不堆死文件）。
+        if (!hasAnyEffective(fp))
+            deleteFile(fp);
+        return true;
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] appendHintRemove failed: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
+}
+/** 回放整个文件，返回是否还存在任意 thread 的有效提示。 */
+function hasAnyEffective(fp) {
+    const events = readAllJsonlLines(fp);
+    // 按 thread 分组回放
+    const byThread = new Map();
+    for (const ev of events) {
+        const t = normThread(ev.threadId);
+        (byThread.get(t) ?? byThread.set(t, []).get(t)).push(ev);
+    }
+    for (const [, evs] of byThread) {
+        if (replayEffective(evs).length > 0)
+            return true;
+    }
+    return false;
+}
+/** 对单个 thread 的事件序列回放，算出有效提示集（已 add、未被 remove，按 ts 升序）。 */
+function replayEffective(events) {
+    const sorted = events.slice().sort((a, b) => a.ts - b.ts);
+    const active = new Map(); // id → hint，保插入序
+    for (const ev of sorted) {
+        if (ev.action === 'add') {
+            active.set(ev.id, { id: ev.id, text: ev.text, ownerAid: ev.ownerAid, ts: ev.ts });
+        }
+        else {
+            if (ev.targetId)
+                active.delete(ev.targetId);
+            else
+                active.clear(); // 无 targetId = 撤该 thread 全部
+        }
+    }
+    return [...active.values()].sort((a, b) => a.ts - b.ts);
+}
+/**
+ * 消费 (对端, thread) 的有效提示：回放算「该 thread」有效集 → 返回 → 清掉该 thread。
+ *
+ * thread 隔离：只消费传入 threadId（归一后）的提示。若文件里其它 thread 仍有未消费提示，
+ * 重写文件保留它们；只有当整文件再无任何有效提示时才删除文件。
+ * 返回空数组表示该 thread 无有效提示（调用方据此决定是否注入）。
+ */
+export function consumeHints(sessionsDir, channelType, channelId, selfAID, threadId) {
+    const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+    if (!fs.existsSync(fp))
+        return [];
+    let all;
+    try {
+        all = readAllJsonlLines(fp);
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] consume read failed: ${e instanceof Error ? e.message : String(e)}`);
+        return [];
+    }
+    const wantThread = normThread(threadId);
+    const sameThread = all.filter(ev => normThread(ev.threadId) === wantThread);
+    const effective = replayEffective(sameThread);
+    // 其它 thread 仍有未消费提示？若有，重写文件只留它们；否则删整个文件。
+    const otherThreadEvents = all.filter(ev => normThread(ev.threadId) !== wantThread);
+    if (otherThreadEvents.length > 0 && hasEffectiveInEvents(otherThreadEvents)) {
+        rewriteFile(fp, otherThreadEvents);
+    }
+    else {
+        deleteFile(fp);
+    }
+    return effective;
+}
+/** events（可能跨多 thread）中是否存在任意有效提示。 */
+function hasEffectiveInEvents(events) {
+    const byThread = new Map();
+    for (const ev of events) {
+        const t = normThread(ev.threadId);
+        (byThread.get(t) ?? byThread.set(t, []).get(t)).push(ev);
+    }
+    for (const [, evs] of byThread) {
+        if (replayEffective(evs).length > 0)
+            return true;
+    }
+    return false;
+}
+function rewriteFile(fp, events) {
+    try {
+        const body = events.map(e => JSON.stringify(e)).join('\n') + '\n';
+        fs.writeFileSync(fp, body);
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] rewriteFile failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function deleteFile(fp) {
+    try {
+        if (fs.existsSync(fp))
+            fs.unlinkSync(fp);
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] deleteFile failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+/** 仅供 watch / 调试：读出当前 (对端,thread) 有效提示，不消费、不删文件。 */
+export function peekHints(sessionsDir, channelType, channelId, selfAID, threadId) {
+    const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+    if (!fs.existsSync(fp))
+        return [];
+    try {
+        const all = readAllJsonlLines(fp);
+        const wantThread = normThread(threadId);
+        return replayEffective(all.filter(ev => normThread(ev.threadId) === wantThread));
+    }
+    catch {
+        return [];
+    }
+}
+// ── 渲染接线纯函数（无 IO，便于单测） ──────────────────────────
+/** 把有效提示转成 owner-hint SubMessage（排在对端真实 item 之前，走 inject 渲染模式）。 */
+export function hintsToSubMessages(hints) {
+    return hints.map(h => ({
+        kind: 'owner-hint',
+        content: h.text,
+        ownerAid: h.ownerAid,
+        injectTime: h.ts,
+        timestamp: h.ts,
+    }));
+}
+/**
+ * 渲染失败兜底：把已消费的 owner-hint（提示已从 pending 删除、不可恢复）以纯文本前缀
+ * 拼到对端原文之前，避免提示被静默丢弃。仅在 renderMessageBody 抛错或产出空时使用。
+ */
+export function composeHintFallback(hintItems, content) {
+    if (!hintItems || hintItems.length === 0)
+        return content;
+    const lines = hintItems.map(h => `‹owner 提示·已验证›（仅你可见，对端无感）\n${h.content}`);
+    return [...lines, content].join('\n\n');
+}
+/**
+ * 解析 observer.inject payload：鉴权（from∈owners）+ 校验（add 需 channel_id+text；remove 需 channel_id）
+ * + 归一字段。纯函数，无副作用——落盘 / ack / watch 由调用方按结果执行。
+ * @param ts 用于 add 缺省 id（`inj-<ts>`）；由调用方传入便于测试确定性。
+ */
+export function parseInjectRequest(payload, fromAid, owners, ts) {
+    const p = (payload && typeof payload === 'object') ? payload : {};
+    const injectId = typeof p.id === 'string' ? p.id : undefined;
+    const action = p.action === 'remove' ? 'remove' : 'add';
+    if (!owners.includes(fromAid)) {
+        return { kind: 'reject', code: 'NOT_OWNER', message: '仅 owner 可插话', action, injectId };
+    }
+    const target = (p.target && typeof p.target === 'object') ? p.target : undefined;
+    const channelId = target && typeof target.channel_id === 'string' ? target.channel_id : undefined;
+    const text = typeof p.text === 'string' ? p.text : '';
+    if (!channelId || (action === 'add' && !text.trim())) {
+        return { kind: 'reject', code: 'INVALID_TARGET', message: 'target.channel_id 必填；add 还需 text', action, injectId };
+    }
+    const chatType = target?.chat_type === 'group' ? 'group' : 'private';
+    const threadId = typeof target?.thread_id === 'string' ? target.thread_id : undefined;
+    const targetId = typeof p.target_id === 'string' ? p.target_id : undefined;
+    if (action === 'remove') {
+        return { kind: 'remove', injectId, channelId, chatType, threadId, targetId };
+    }
+    return { kind: 'add', injectId, id: injectId || `inj-${ts}`, text, channelId, chatType, threadId, ownerAid: fromAid };
+}

package/dist/core/model/model-catalog.js

@@ -10,7 +10,7 @@
  * 详见 docs/model-command-design.md。
  */
 import { loadDefaults, loadAgent } from '../../config-store.js';
-import { resolveAnthropicConfig, resolveOpenaiConfig } from '../../agents/resolve.js';
+import { resolveAnthropicConfig, resolveOpenaiConfig } from '../../agents/baseagent.js';
 import { activeBaseagent } from './model-scope.js';
 /** 取指定 baseagent 的 baseUrl + apiKey（复用现有解析链）。 */
 function resolveCreds(self, ba) {

package/dist/core/model/model-scope.js

@@ -18,8 +18,8 @@ import fs from 'fs';
 import path from 'path';
 import { agentRelationsDir, agentConfig as agentConfigPath, resolvePaths } from '../../paths.js';
 import { loadDefaults, saveDefaultsSafe, loadAgent, saveAgent } from '../../config-store.js';
-import { formatPeerKey, parsePeerKey } from '../relation/peer-key.js';
-import { fileCache } from '../cache/file-cache.js';
+import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
+import { fileCache } from '../daemon-file-cache.js';
 // ── mtime 门控缓存（统一走 FileCache）─────────────────────────────────────
 //
 // resolveEffectiveModel 每条消息按 关系>agent>全局 解析，原本每次都

package/dist/core/permission.js

@@ -143,6 +143,12 @@ export function summarizeToolInput(toolName, input) {
 /** 为 Edit 工具生成 diff 风格摘要 */
 function formatEditSummary(input) {
     const filePath = input.file_path || '';
+    const protocolDiff = typeof input.unified_diff === 'string' ? input.unified_diff
+        : typeof input.unifiedDiff === 'string' ? input.unifiedDiff
+            : typeof input.diff === 'string' ? input.diff
+                : '';
+    if (protocolDiff)
+        return formatProtocolDiffSummary(filePath, protocolDiff);
     const oldStr = typeof input.old_string === 'string' ? input.old_string : '';
     const newStr = typeof input.new_string === 'string' ? input.new_string : '';
     if (!oldStr && !newStr)
@@ -215,9 +221,18 @@ function formatEditSummary(input) {
     }
     return `${filePath}\n\`\`\`\n${diffLines.join('\n')}\n\`\`\``;
 }
+/** 展示 runner/协议已返回的 unified diff；不在 EvolClaw 内重新计算 diff。 */
+function formatProtocolDiffSummary(filePath, diff) {
+    const MAX_DIFF_LINES = 32;
+    const lines = diff.trimEnd().split('\n');
+    const displayLines = lines.length > MAX_DIFF_LINES
+        ? [...lines.slice(0, MAX_DIFF_LINES), `...(省略 ${lines.length - MAX_DIFF_LINES} 行)`]
+        : lines;
+    const body = displayLines.join('\n');
+    return `${filePath}\n\`\`\`diff\n${body}\n\`\`\``;
+}
 export class PermissionGateway {
     pending = new Map();
-    timeout = 5 * 60 * 1000;
     eventBus;
     /** 始终允许的工具缓存：toolName → Set<pattern> */
     alwaysAllow = new Map();
@@ -283,6 +298,14 @@ export class PermissionGateway {
         };
         // 尝试富交互（走统一 adapter.send 入口）
         let interactionSent = false;
+        if (context?.flushPending) {
+            try {
+                await context.flushPending();
+            }
+            catch {
+                // flush 失败不应阻断权限请求发送
+            }
+        }
         if (context?.adapter && context.channelId) {
             try {
                 const envelope = buildEnvelope({
@@ -306,15 +329,7 @@ export class PermissionGateway {
             await sendPrompt(renderActionAsText(interaction));
         }
         return new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                const pending = this.pending.get(requestId);
-                if (!pending)
-                    return;
-                this.pending.delete(requestId);
-                this.eventBus?.publish({ type: 'permission:timeout', sessionId, requestId, toolName });
-                pending.resolve('deny');
-            }, this.timeout);
-            this.pending.set(requestId, { sessionId, toolName, resolve, timer });
+            this.pending.set(requestId, { sessionId, toolName, resolve });
             // 注册到 InteractionRouter（卡片和文本降级都注册，统一路由）
             if (context?.interactionRouter) {
                 context.interactionRouter.register(requestId, sessionId, (action) => {
@@ -327,7 +342,6 @@ export class PermissionGateway {
         const pending = this.pending.get(requestId);
         if (!pending || pending.sessionId !== sessionId)
             return false;
-        clearTimeout(pending.timer);
         // 如果是 always，缓存该工具
         if (decision === 'always') {
             this.addAlwaysAllow(pending.toolName);
@@ -341,7 +355,6 @@ export class PermissionGateway {
     cancelAll(sessionId) {
         for (const [requestId, pending] of this.pending.entries()) {
             if (pending.sessionId === sessionId) {
-                clearTimeout(pending.timer);
                 pending.resolve('deny');
                 this.pending.delete(requestId);
             }

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

@@ -15,7 +15,22 @@ import * as path from 'path';
 import * as crypto from 'crypto';
 import { logger } from '../../utils/logger.js';
 import { agentMdPath } from '../../paths.js';
-import { formatPeerKey } from './peer-key.js';
+/**
+ * peerKey: 关系层路由键，格式 `<channelType>#<urlEncode(channelId)>`。
+ * 群聊场景下 channelId = groupId，所有发言者共用同一个 peerKey。
+ */
+export function formatPeerKey(channelType, channelId) {
+    return `${channelType}#${encodeURIComponent(channelId)}`;
+}
+export function parsePeerKey(key) {
+    const idx = key.indexOf('#');
+    if (idx <= 0)
+        throw new Error(`Invalid peer key: ${key}`);
+    return {
+        channelType: key.slice(0, idx),
+        channelId: decodeURIComponent(key.slice(idx + 1)),
+    };
+}
 /**
  * 对端身份缓存管理器
  */

package/dist/core/session/adapters/codex-session-file-adapter.js

@@ -10,12 +10,14 @@
  * 会返回空数组。
  */
 import { createRequire } from 'module';
+import { sanitizeSessionTitle } from '../session-title.js';
 import { logger } from '../../../utils/logger.js';
 import path from 'path';
 import fs from 'fs';
 import os from 'os';
 const requireFromHere = createRequire(import.meta.url);
 let sqliteModule; // undefined = not tried, null = unavailable
+export const sanitizeCodexThreadTitle = sanitizeSessionTitle;
 function loadSqlite() {
     if (sqliteModule !== undefined)
         return sqliteModule;
@@ -127,7 +129,7 @@ export class CodexSessionFileAdapter {
                 if (row) {
                     return {
                         turns: this.countTurnsFromRollout(row.rollout_path),
-                        title: row.title || undefined,
+                        title: sanitizeCodexThreadTitle(row.title),
                     };
                 }
             }
@@ -210,7 +212,7 @@ export class CodexSessionFileAdapter {
             const rows = db.prepare('SELECT id, title FROM threads WHERE cwd = ? AND archived = 0 ORDER BY updated_at DESC').all(projectPath);
             return rows.map(r => ({
                 sessionId: r.id,
-                title: r.title || undefined,
+                title: sanitizeCodexThreadTitle(r.title),
             }));
         }
         catch (error) {