evolclaw 3.1.11 → 3.3.0

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

@@ -40,16 +40,22 @@ export class MessageQueue {
     }
     /**
      * 检查消息是否应该处理（去重）
+     *
+     * 去重 key = `${sessionKey}:${messageId}`，而非裸 messageId。
+     * MessageQueue 是进程级单例，被所有 evolagent 共享。AUN 群广播时同一条群消息
+     * 会投递给群里每个 evolagent，它们 messageId 相同但 session 不同，必须各处理一次。
+     * 裸 messageId 去重会让先入队的 agent 吞掉其他 agent 的消息。
      */
-    shouldProcess(message) {
+    shouldProcess(sessionKey, message) {
         if (!message.messageId)
             return true; // 无 ID 的消息不去重
-        if (this.recentMessageIds.has(message.messageId)) {
-            logger.debug(`[Queue] Duplicate message ${message.messageId}, skipping`);
+        const dedupKey = `${sessionKey}:${message.messageId}`;
+        if (this.recentMessageIds.has(dedupKey)) {
+            logger.debug(`[Queue] Duplicate message ${dedupKey}, skipping`);
             return false;
         }
-        this.recentMessageIds.add(message.messageId);
-        setTimeout(() => this.recentMessageIds.delete(message.messageId), this.DEDUP_WINDOW);
+        this.recentMessageIds.add(dedupKey);
+        setTimeout(() => this.recentMessageIds.delete(dedupKey), this.DEDUP_WINDOW);
         return true;
     }
     /**
@@ -67,7 +73,7 @@ export class MessageQueue {
     }
     async enqueue(sessionKey, message, projectPath, options) {
         // 消息去重检查
-        if (!this.shouldProcess(message)) {
+        if (!this.shouldProcess(sessionKey, message)) {
             return Promise.resolve();
         }
         // 拦截器检查：AskUserQuestion 等场景的一次性消息拦截
@@ -86,8 +92,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) {
                     // 单聊：保留中断行为
@@ -212,6 +218,7 @@ export class MessageQueue {
                     sameDevice: m.sameDevice, sameNetwork: m.sameNetwork, sameEgressIp: m.sameEgressIp,
                     content: m.content, timestamp: m.timestamp,
                     images: m.images && m.images.length > 0 ? m.images : undefined,
+                    mentionAids: m.mentionAids && m.mentionAids.length > 0 ? m.mentionAids : undefined,
                 });
             }
         }

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/message/response-depth.js

@@ -0,0 +1,56 @@
+import crypto from 'crypto';
+/**
+ * 计算消息内容的话题指纹（前 20 字符的 md5 前 8 位）。
+ */
+export function computeTopicHash(content) {
+    const slice = content.trim().slice(0, 20);
+    return crypto.createHash('md5').update(slice).digest('hex').slice(0, 8);
+}
+/**
+ * 群聊响应深度决策（纯函数，无 I/O）。
+ *
+ * 根据 dispatch 模式、消息特征（长度/是否问句/是否被@）、话题轮次综合判断。
+ * 返回 depth 枚举 + 更新后的话题追踪状态（调用方负责持久化）。
+ */
+export function resolveResponseDepth(input) {
+    const { chatType, content, selfAid, mentionAids, dispatch, topicRounds: prevRounds, lastTopicHash } = input;
+    // 仅群聊走深度决策；私聊一律 standard
+    if (chatType !== 'group') {
+        return { depth: 'standard', topicRounds: prevRounds, topicHash: lastTopicHash || '' };
+    }
+    const trimmed = content.trim();
+    // ── 话题追踪：更新 topicRounds ──
+    const topicHash = computeTopicHash(trimmed);
+    let topicRounds;
+    if (lastTopicHash && lastTopicHash === topicHash) {
+        topicRounds = prevRounds + 1;
+    }
+    else {
+        topicRounds = 1;
+    }
+    // ── 判断因子 ──
+    const isMentioned = !!(selfAid && mentionAids?.includes(selfAid));
+    const isQuestion = /[？?]\s*$/.test(trimmed) || /^(what|how|why|when|where|who|which|请问|怎么|为什么|什么|如何|能不能|可以)/i.test(trimmed);
+    const isShort = trimmed.length <= 30;
+    // ── 决策逻辑 ──
+    // 被@：至少 standard；话题深入则升 deep
+    if (isMentioned) {
+        const depth = topicRounds >= 3 ? 'deep' : 'standard';
+        return { depth, topicRounds, topicHash };
+    }
+    // broadcast 模式：短消息 + 非问句 → lightweight
+    if (dispatch === 'broadcast') {
+        let depth;
+        if (topicRounds >= 3)
+            depth = 'deep';
+        else if (isShort && !isQuestion)
+            depth = 'lightweight';
+        else
+            depth = 'standard';
+        return { depth, topicRounds, topicHash };
+    }
+    // mention 模式下到达这里说明已通过 dispatch 过滤（被@才入队），
+    // 等同于 isMentioned === true 的分支。兜底 standard。
+    const depth = topicRounds >= 3 ? 'deep' : 'standard';
+    return { depth, topicRounds, topicHash };
+}

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

@@ -16,9 +16,42 @@
  */
 import fs from 'fs';
 import path from 'path';
-import { agentRelationsDir } from '../../paths.js';
+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 { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
+import { fileCache } from '../daemon-file-cache.js';
+// ── mtime 门控缓存（统一走 FileCache）─────────────────────────────────────
+//
+// resolveEffectiveModel 每条消息按 关系>agent>全局 解析，原本每次都
+// loadAgent()/loadDefaults()/读 preferences.json —— 一条消息最多读盘 5 次。
+//
+// model-scope 被 CLI 子进程与 daemon 共用，CLI 改文件后 daemon 无失效通知，
+// 故靠 mtime 门控：每次只 statSync 比对 mtime，未变用缓存，变了才真正重读 +
+// 重解析。跨进程天然正确（文件 mtime 变即感知），改配置即时生效不变；
+// statSync 远比 read+JSON.parse 便宜。CLI 进程的 fileCache 是独立空实例、随进程
+// 退出，等同直读最新盘值，安全。
+//
+// config/defaults 与 relation-prefs 三者统一走 daemon 单例 FileCache（消除原先
+// 第二套 makeMtimeCache），读取计数一并进监控。config/defaults 的实际读盘 + 解析
+// 仍委托原 loadAgent/loadDefaults（保留 atomicRead 崩溃恢复 + expandEnvRefs/校验），
+// 故传 noopRead 让 FileCache 只做 mtime 门控、不重复读盘（loader 忽略 raw）。
+/** FileCache 的 read 钩子占位：config/defaults 的真实读盘在 loader 里（loadAgent/
+ *  loadDefaults，含崩溃恢复），此处返回 null 避免 FileCache 再读一遍。 */
+const noopRead = () => null;
+// agent config.json：mtime 门控，per-agent 分组（config:<aid>）便于 per-agent 监控视图。
+const loadAgentCached = (self) => fileCache.get(agentConfigPath(self), () => loadAgent(self), { policy: 'mtime', group: `config:${self}`, read: noopRead });
+// defaults.json：单文件，mtime 门控。
+const loadDefaultsCached = () => fileCache.get(resolvePaths().defaultsConfig, () => loadDefaults(), { policy: 'mtime', group: 'config', read: noopRead });
+// 关系级 preferences.json —— 走统一 FileCache（mtime 门控，带外改 + 不 reload）。
+const readPrefsCached = (file) => fileCache.get(file, (raw) => (raw === null ? null : safeParsePrefs(raw)), { policy: 'mtime', group: 'relation-prefs' });
+function safeParsePrefs(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
 export class ModelScopeError extends Error {
     code;
     constructor(code, message) {
@@ -76,11 +109,11 @@ export function determineScope(sel) {
 export function activeBaseagent(self) {
     try {
         if (self) {
-            const cfg = loadAgent(self);
+            const cfg = loadAgentCached(self);
             if (cfg?.active_baseagent)
                 return cfg.active_baseagent;
         }
-        const d = loadDefaults();
+        const d = loadDefaultsCached();
         if (d?.active_baseagent)
             return d.active_baseagent;
     }
@@ -114,17 +147,17 @@ function writeJsonAtomic(file, data) {
 export function readScope(scope, sel, ba) {
     switch (scope) {
         case 'global': {
-            const block = (loadDefaults()?.baseagents || {});
+            const block = (loadDefaultsCached()?.baseagents || {});
             const c = block[ba] || {};
             return { model: c.model, effort: c[effortField(ba)] };
         }
         case 'agent': {
-            const cfg = sel.self ? loadAgent(sel.self) : null;
+            const cfg = sel.self ? loadAgentCached(sel.self) : null;
             const c = (cfg?.baseagents || {})[ba] || {};
             return { model: c.model, effort: c[effortField(ba)] };
         }
         case 'relation': {
-            const p = readJsonSafe(relationPrefsPath(sel.self, sel.peerKey));
+            const p = readPrefsCached(relationPrefsPath(sel.self, sel.peerKey));
             return { model: p?.model, effort: p?.effort };
         }
     }

package/dist/core/permission.js

@@ -217,7 +217,6 @@ function formatEditSummary(input) {
 }
 export class PermissionGateway {
     pending = new Map();
-    timeout = 5 * 60 * 1000;
     eventBus;
     /** 始终允许的工具缓存：toolName → Set<pattern> */
     alwaysAllow = new Map();
@@ -283,6 +282,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 +313,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 +326,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 +339,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/claude-session-file-adapter.js

@@ -95,24 +95,67 @@ export class ClaudeSessionFileAdapter {
         }
         return null;
     }
+    // CLI 会话白名单：只有真正由人手发起的终端会话才值得导入。
+    // 其它 entrypoint（sdk-ts=EvolClaw 自身、sdk-py=security-guidance 等插件的后台 SDK 会话）
+    // 同样把 JSONL 写进项目目录，但不是用户会话，导入它们没有意义。
+    static CLI_ENTRYPOINTS = new Set(['cli', 'sdk-cli']);
+    // entrypoint 不可变，进程内缓存 filePath→entrypoint，避免重复读文件头部
+    entrypointCache = new Map();
+    // entrypoint 字段位于首个 user 事件行（实测恒在前 4 行内，cli 会话首次出现 < 8KB）。
+    // 插件会话首行 queue-operation 可能携带巨大 diff（数百 KB），把 entrypoint 推到很后面，
+    // 因此读取上限设为 32KB：cli 会话必命中，插件会话要么命中 sdk-py、要么读不到 → 一律排除。
+    static ENTRYPOINT_SCAN_BYTES = 32 * 1024;
+    /** 读取会话文件的 entrypoint，结果缓存在实例内（entrypoint 不可变，无需失效）。 */
+    readEntrypoint(filePath) {
+        if (this.entrypointCache.has(filePath))
+            return this.entrypointCache.get(filePath);
+        let fd;
+        let result = null;
+        try {
+            fd = fs.openSync(filePath, 'r');
+            const buf = Buffer.allocUnsafe(ClaudeSessionFileAdapter.ENTRYPOINT_SCAN_BYTES);
+            const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+            const head = buf.toString('utf-8', 0, bytesRead);
+            const m = head.match(/"entrypoint":"([^"]*)"/);
+            result = m ? m[1] : null;
+        }
+        catch {
+            // keep null
+        }
+        finally {
+            if (fd !== undefined)
+                fs.closeSync(fd);
+        }
+        this.entrypointCache.set(filePath, result);
+        return result;
+    }
     scanCliSessions(projectPath) {
         const homeDir = os.homedir();
         const encodedPath = encodePath(projectPath);
         const sessionDir = path.join(homeDir, '.claude', 'projects', encodedPath);
         if (!fs.existsSync(sessionDir))
             return [];
-        const files = fs.readdirSync(sessionDir)
+        const candidates = fs.readdirSync(sessionDir)
             .filter(f => f.endsWith('.jsonl'))
             .filter(f => !f.startsWith('agent-'))
             .map(f => {
             const filePath = path.join(sessionDir, f);
             const stat = fs.statSync(filePath);
-            return { uuid: f.replace('.jsonl', ''), mtime: stat.mtimeMs, size: stat.size };
+            return { uuid: f.replace('.jsonl', ''), filePath, mtime: stat.mtimeMs, size: stat.size };
         })
             .filter(f => f.size > 0)
-            .sort((a, b) => b.mtime - a.mtime)
-            .slice(0, 10);
-        return files.map(f => ({ uuid: f.uuid, mtime: f.mtime }));
+            .sort((a, b) => b.mtime - a.mtime);
+        // 按 mtime 降序惰性判定 entrypoint，凑够 10 个白名单会话即停，避免读取全部文件。
+        const result = [];
+        for (const f of candidates) {
+            const entrypoint = this.readEntrypoint(f.filePath);
+            if (entrypoint && ClaudeSessionFileAdapter.CLI_ENTRYPOINTS.has(entrypoint)) {
+                result.push({ uuid: f.uuid, mtime: f.mtime });
+                if (result.length >= 10)
+                    break;
+            }
+        }
+        return result;
     }
     async listSdkSessions(projectPath) {
         try {

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) {