evolclaw 3.0.0 → 3.1.0

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

@@ -31,7 +31,10 @@ export class SessionManager {
     setSessionModeResolver(resolver) {
         this.sessionModeResolver = resolver;
     }
-    resolveDefaultSessionMode(channel, chatType) {
+    resolveDefaultSessionMode(channel, chatType, peerType) {
+        // 非 human 对端（ai/bot）强制 proactive，无视 agent 的默认 chatmode 配置
+        if (peerType && peerType !== 'human' && peerType !== 'unknown')
+            return 'proactive';
         const ct = chatType || 'private';
         const resolved = this.sessionModeResolver?.(channel, ct);
         return resolved || 'interactive';
@@ -176,12 +179,75 @@ export class SessionManager {
         const metaPath = this.metaFilePath(targetDir, session.id);
         appendJsonl(metaPath, file);
     }
+    /**
+     * 比较两个 SessionFile 是否在内容上相等（忽略 updatedAt / updatedAtStr）。
+     * 用于跳过"没真变化"的写入，避免 jsonl 写放大。
+     */
+    sessionFilesEqual(a, b) {
+        const stripVolatile = ({ updatedAt, updatedAtStr, ...rest }) => rest;
+        return JSON.stringify(stripVolatile(a)) === JSON.stringify(stripVolatile(b));
+    }
+    /**
+     * Append meta + write active.json，但只在 session 内容（除 updatedAt 外）真正变化时才写。
+     * prev 是修改前的快照（用于 diff），next 是修改后的 session。
+     * 返回是否发生了写入。
+     */
+    writeSessionIfChanged(channel, channelId, prev, next) {
+        if (prev) {
+            const prevFile = sessionToFile(prev);
+            const nextFile = sessionToFile(next);
+            if (this.sessionFilesEqual(prevFile, nextFile))
+                return false;
+        }
+        next.updatedAt = Date.now();
+        this.appendMeta(channel, channelId, next);
+        const active = this.readActive(channel, channelId);
+        if (active && active.id === next.id) {
+            // 保留 active.json 中已有的 activeTask（markProcessing 写入的处理状态）
+            if (active.processingState && !next.processingState) {
+                next.processingState = active.processingState;
+            }
+            this.writeActive(channel, channelId, next);
+        }
+        return true;
+    }
     readMetaLatest(metaFilePath) {
         const file = readLastJsonlLine(metaFilePath);
         if (!file)
             return undefined;
         return fileToSession(file);
     }
+    /**
+     * 为 by-sessionId 改方法加载"当前 session 状态"。
+     *
+     * 设计契约（docs/refactor/01-db-to-fs.md）：
+     *   active.json 是热路径权威源。.jsonl 是历史档案。
+     *
+     * 读取策略：
+     *   1. 先按 sessionId 定位 .jsonl 文件（确认 session 存在 + 拿到 channel/channelId）
+     *   2. 优先读 active.json（如果 active.id === sessionId）—— 当前状态
+     *   3. 否则 fallback 到 .jsonl 末行 —— 非活跃 session 的更新（如多 session 并存时改非 active 那个）
+     *
+     * 返回 { current, prev }：
+     *   - current 用于 caller 修改后写回
+     *   - prev 是 current 的初始快照（用于 writeSessionIfChanged 的 diff 检查）
+     */
+    loadSessionForUpdate(sessionId) {
+        const found = this.findSessionFileById(sessionId);
+        if (!found)
+            return undefined;
+        // 先读 .jsonl 末行拿 channel/channelId（active.json 文件路径需要这两个）
+        const fromJsonl = this.readMetaLatest(found.metaPath);
+        if (!fromJsonl)
+            return undefined;
+        // 优先用 active.json 的当前状态（如果它就是这个 sessionId）
+        const active = this.readActive(fromJsonl.channel, fromJsonl.channelId);
+        const base = (active && active.id === sessionId) ? active : fromJsonl;
+        // 深拷贝避免 caller 改 current 时污染 prev
+        const current = JSON.parse(JSON.stringify(base));
+        const prev = JSON.parse(JSON.stringify(base));
+        return { current, prev };
+    }
     validateSessionFile(session) {
         const agentSessionId = session.agentSessionId;
         if (!agentSessionId)
@@ -193,12 +259,9 @@ export class SessionManager {
         if (adapter.checkExists(session.projectPath, agentSessionId))
             return agentSessionId;
         logger.warn(`Session file not found for ${agentId}: ${agentSessionId}, clearing session ID`);
+        const prev = JSON.parse(JSON.stringify(session));
         session.agentSessionId = undefined;
-        this.appendMeta(session.channel, session.channelId, session);
-        const active = this.readActive(session.channel, session.channelId);
-        if (active && active.id === session.id) {
-            this.writeActive(session.channel, session.channelId, session);
-        }
+        this.writeSessionIfChanged(session.channel, session.channelId, prev, session);
         return undefined;
     }
     getActiveChatType(channel, channelId) {
@@ -332,9 +395,9 @@ export class SessionManager {
         return result;
     }
     // ─── Session lifecycle ───
-    async getOrCreateSession(channel, channelId, defaultProjectPath, threadId, metadata, name, userId, chatType, agentId, selfId, channelType) {
+    async getOrCreateSession(channel, channelId, defaultProjectPath, threadId, metadata, name, userId, chatType, agentId, selfId, channelType, peerType) {
         if (threadId) {
-            const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfId, channelType);
+            const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfId, channelType, peerType);
             session.identity = this.resolveIdentity(channel, userId);
             if (session.metadata && !session.metadata.permissionMode) {
                 session.metadata.permissionMode = DEFAULT_PERMISSION_MODE;
@@ -399,6 +462,7 @@ export class SessionManager {
             .sort((a, b) => b.updatedAt - a.updatedAt)[0];
         if (existing) {
             const validSessionId = this.validateSessionFile(existing);
+            const prev = JSON.parse(JSON.stringify({ ...existing, agentSessionId: validSessionId }));
             const session = { ...existing, agentSessionId: validSessionId };
             session.identity = this.resolveIdentity(channel, userId);
             if (!session.metadata)
@@ -416,9 +480,7 @@ export class SessionManager {
             if (chatType === 'private' && metadata?.peerName && !session.metadata.peerName) {
                 session.metadata.peerName = metadata.peerName;
             }
-            session.updatedAt = Date.now();
-            this.appendMeta(channel, channelId, session);
-            this.writeActive(channel, channelId, session);
+            this.writeSessionIfChanged(channel, channelId, prev, session);
             return session;
         }
         // Create new session
@@ -435,7 +497,7 @@ export class SessionManager {
             threadId: '',
             agentId: agentId || 'claude',
             chatType: chatType || 'private',
-            sessionMode: this.resolveDefaultSessionMode(channel, chatType || 'private'),
+            sessionMode: this.resolveDefaultSessionMode(channel, chatType || 'private', peerType),
             metadata: sessionMetadata,
             name: name || '默认会话',
             createdAt: Date.now(),
@@ -457,12 +519,10 @@ export class SessionManager {
         return session;
     }
     async updateSession(sessionId, updates) {
-        const found = this.findSessionFileById(sessionId);
-        if (!found)
-            return;
-        const current = this.readMetaLatest(found.metaPath);
-        if (!current)
+        const loaded = this.loadSessionForUpdate(sessionId);
+        if (!loaded)
             return;
+        const { current, prev } = loaded;
         if (updates.chatType !== undefined)
             current.chatType = updates.chatType;
         if (updates.name !== undefined)
@@ -473,14 +533,9 @@ export class SessionManager {
             current.metadata = updates.metadata;
         if ('agentSessionId' in updates)
             current.agentSessionId = updates.agentSessionId ?? undefined;
-        current.updatedAt = Date.now();
-        this.appendMeta(current.channel, current.channelId, current);
-        const active = this.readActive(current.channel, current.channelId);
-        if (active && active.id === sessionId) {
-            this.writeActive(current.channel, current.channelId, current);
-        }
+        this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
     }
-    getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfId, channelType) {
+    getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfId, channelType, peerType) {
         const chatDir = this.ensureResolvedChatDir(channel, channelId);
         const threadIndex = readThreadIndex(chatDir);
         const existingMetaId = threadIndex[threadId];
@@ -511,7 +566,7 @@ export class SessionManager {
             threadId,
             agentId: agentId || 'claude',
             chatType: inheritedChatType,
-            sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType),
+            sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType, peerType),
             metadata,
             name: name || '话题会话',
             createdAt: Date.now(),
@@ -581,25 +636,19 @@ export class SessionManager {
         const active = this.readActive(channel, channelId);
         if (!active)
             return;
+        const prev = JSON.parse(JSON.stringify(active));
         active.agentSessionId = agentSessionId;
-        active.updatedAt = Date.now();
-        this.appendMeta(channel, channelId, active);
-        this.writeActive(channel, channelId, active);
+        this.writeSessionIfChanged(channel, channelId, prev, active);
     }
     async updateAgentSessionIdBySessionId(sessionId, agentSessionId) {
-        logger.info(`[SessionManager] Updating agent_session_id: sessionId=${sessionId}, agentSessionId=${agentSessionId}`);
-        const found = this.findSessionFileById(sessionId);
-        if (!found)
-            return;
-        const current = this.readMetaLatest(found.metaPath);
-        if (!current)
+        const loaded = this.loadSessionForUpdate(sessionId);
+        if (!loaded)
             return;
+        const { current, prev } = loaded;
         current.agentSessionId = agentSessionId;
-        current.updatedAt = Date.now();
-        this.appendMeta(current.channel, current.channelId, current);
-        const active = this.readActive(current.channel, current.channelId);
-        if (active && active.id === sessionId) {
-            this.writeActive(current.channel, current.channelId, current);
+        const wrote = this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
+        if (wrote) {
+            logger.info(`[SessionManager] Updating agent_session_id: sessionId=${sessionId}, agentSessionId=${agentSessionId}`);
         }
     }
     async switchAgent(channel, channelId, projectPath, newAgentId) {
@@ -650,10 +699,9 @@ export class SessionManager {
         const active = this.readActive(channel, channelId);
         if (!active)
             return;
+        const prev = JSON.parse(JSON.stringify(active));
         active.agentSessionId = undefined;
-        active.updatedAt = Date.now();
-        this.appendMeta(channel, channelId, active);
-        this.writeActive(channel, channelId, active);
+        this.writeSessionIfChanged(channel, channelId, prev, active);
     }
     getOwnerChatId(targetChannel, ownerPeerId) {
         const chatDirs = scanChatDirs(this.sessionsDir);
@@ -742,34 +790,20 @@ export class SessionManager {
         return target;
     }
     updateMetadata(sessionId, metadata) {
-        const found = this.findSessionFileById(sessionId);
-        if (!found)
-            return;
-        const current = this.readMetaLatest(found.metaPath);
-        if (!current)
+        const loaded = this.loadSessionForUpdate(sessionId);
+        if (!loaded)
             return;
+        const { current, prev } = loaded;
         current.metadata = metadata;
-        current.updatedAt = Date.now();
-        this.appendMeta(current.channel, current.channelId, current);
-        const active = this.readActive(current.channel, current.channelId);
-        if (active && active.id === sessionId) {
-            this.writeActive(current.channel, current.channelId, current);
-        }
+        this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
     }
     async renameSession(sessionId, newName) {
-        const found = this.findSessionFileById(sessionId);
-        if (!found)
-            return false;
-        const current = this.readMetaLatest(found.metaPath);
-        if (!current)
+        const loaded = this.loadSessionForUpdate(sessionId);
+        if (!loaded)
             return false;
+        const { current, prev } = loaded;
         current.name = newName;
-        current.updatedAt = Date.now();
-        this.appendMeta(current.channel, current.channelId, current);
-        const active = this.readActive(current.channel, current.channelId);
-        if (active && active.id === sessionId) {
-            this.writeActive(current.channel, current.channelId, current);
-        }
+        this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
         return true;
     }
     async unbindSession(sessionId) {

package/dist/core/trigger/scheduler.js

@@ -153,7 +153,7 @@ export class TriggerScheduler {
         if (!top)
             return;
         const delay = Math.max(0, top.nextFireAt - Date.now());
-        this.timer = setTimeout(() => this.onFire(), delay);
+        this.timer = setTimeout(() => this.onFire(), delay).unref();
     }
     onFire() {
         this.timer = null;

package/dist/data/error-dict.json

@@ -0,0 +1,118 @@
+{
+  "rules": [
+    {
+      "id": "context-too-long-cn",
+      "match": "上下文过长",
+      "action": "stop",
+      "type": "context_too_long",
+      "message": "⚠️ 上下文过长，请手动输入 /compact 压缩上下文"
+    },
+    {
+      "id": "context-too-long-en",
+      "match": "context too long",
+      "action": "stop",
+      "type": "context_too_long",
+      "message": "⚠️ 上下文过长，请手动输入 /compact 压缩上下文"
+    },
+    {
+      "id": "prompt-too-long",
+      "match": "prompt is too long",
+      "action": "stop",
+      "type": "context_too_long",
+      "message": "⚠️ 输入过长，请精简提问或使用 /compact 压缩上下文"
+    },
+    {
+      "id": "invalid-api-key",
+      "match": "invalid api key",
+      "action": "stop",
+      "type": "auth_error",
+      "message": "❌ API Key 无效，请检查密钥配置。使用 /status 查看当前配置"
+    },
+    {
+      "id": "key-not-found",
+      "match": "key_not_found",
+      "action": "stop",
+      "type": "auth_error",
+      "message": "❌ API Key 未找到，请检查密钥配置"
+    },
+    {
+      "id": "credit-query-timeout",
+      "match": "积分查询超时",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ 积分查询超时，正在重试..."
+    },
+    {
+      "id": "api-error-400",
+      "match": "api error: 400",
+      "action": "stop",
+      "type": "api_error",
+      "message": "❌ 请求格式错误，请检查输入内容"
+    },
+    {
+      "id": "api-error-403",
+      "match": "api error: 403",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 访问受限，正在重试..."
+    },
+    {
+      "id": "api-error-429",
+      "match": "api error: 429",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ 请求过于频繁，正在重试..."
+    },
+    {
+      "id": "api-error-500",
+      "match": "api error: 500",
+      "action": "retry",
+      "type": "api_error",
+      "message": "❌ API 服务暂时不可用，正在重试..."
+    },
+    {
+      "id": "api-error-502",
+      "match": "api error: 502",
+      "action": "retry",
+      "type": "api_error"
+    },
+    {
+      "id": "api-error-503",
+      "match": "api error: 503",
+      "action": "retry",
+      "type": "api_error"
+    },
+    {
+      "id": "api-error-504",
+      "match": "api error: 504",
+      "action": "retry",
+      "type": "api_error"
+    },
+    {
+      "id": "not-valid-json",
+      "match": "is not valid json",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 返回异常响应，正在重试..."
+    },
+    {
+      "id": "feishu-permission",
+      "match": "im:resource",
+      "action": "stop",
+      "type": "unknown",
+      "message": "❌ 权限不足，请联系管理员配置应用权限"
+    },
+    {
+      "id": "stream-error",
+      "match": "stream",
+      "action": "retry",
+      "type": "stream_error"
+    },
+    {
+      "id": "request-aborted",
+      "match": "request was aborted",
+      "action": "ignore",
+      "type": "stream_error"
+    }
+  ]
+}

package/dist/eck/baseagent-caps.js

@@ -0,0 +1,18 @@
+export const BASEAGENT_CAPS = {
+    'claude-code': {
+        autoLoadsRules: true,
+        supportsSystemPrompt: true,
+    },
+    'claude': {
+        autoLoadsRules: true,
+        supportsSystemPrompt: true,
+    },
+    'codex': {
+        autoLoadsRules: false,
+        supportsSystemPrompt: true,
+    },
+    'gemini': {
+        autoLoadsRules: false,
+        supportsSystemPrompt: true,
+    },
+};

package/dist/eck/detect.js

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import path from 'path';
+import { BASEAGENT_CAPS } from './baseagent-caps.js';
+const MAX_DEPTH = 5;
+export function resolveEckInjection(agentConfig, projectPath, kitsRulesPath) {
+    const caps = BASEAGENT_CAPS[agentConfig.baseAgent]
+        ?? { autoLoadsRules: false, supportsSystemPrompt: true };
+    if (!caps.autoLoadsRules) {
+        return { shouldInject: true, reason: 'baseagent-no-autoload' };
+    }
+    const symlinkActive = detectEckSymlink(projectPath, kitsRulesPath);
+    if (symlinkActive) {
+        return { shouldInject: false, reason: 'symlink-active' };
+    }
+    return { shouldInject: true, reason: 'symlink-not-found' };
+}
+export function detectEckSymlink(projectPath, kitsRulesPath) {
+    let dir = projectPath;
+    let depth = 0;
+    while (depth < MAX_DEPTH) {
+        const eckDir = path.join(dir, '.claude', 'rules', 'eck');
+        if (fs.existsSync(eckDir)) {
+            try {
+                const realPath = fs.realpathSync(eckDir);
+                const kitsRulesReal = fs.realpathSync(kitsRulesPath);
+                if (pathEquals(realPath, kitsRulesReal)) {
+                    return true;
+                }
+            }
+            catch {
+                // detection failure → conservatively assume not loaded
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+        depth++;
+    }
+    return false;
+}
+function pathEquals(a, b) {
+    if (process.platform === 'win32') {
+        return path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase();
+    }
+    return path.resolve(a) === path.resolve(b);
+}

package/dist/eck/init.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths, kitsDocsDir, agentDir, getPackageRoot } from '../paths.js';
+import { atomicWriteText } from '../utils/atomic-write.js';
+import { logger } from '../utils/logger.js';
+export function initEck() {
+    const p = resolvePaths();
+    const eckDir = p.eckDir;
+    fs.mkdirSync(eckDir, { recursive: true });
+    initEckRuntime(eckDir);
+    initEckPathRegistry(eckDir);
+}
+export function initAgentIndex(aid) {
+    const indexDir = path.join(agentDir(aid), 'index');
+    fs.mkdirSync(indexDir, { recursive: true });
+    const indexFile = path.join(indexDir, 'INDEX.md');
+    const guideFile = path.join(indexDir, 'GUIDE.md');
+    if (!fs.existsSync(indexFile)) {
+        const template = loadTemplate('INDEX.template.md');
+        if (template) {
+            atomicWriteText(indexFile, renderTemplate(template, { AID: aid }));
+            logger.info(`[eck] Created ${indexFile}`);
+        }
+    }
+    if (!fs.existsSync(guideFile)) {
+        const template = loadTemplate('GUIDE.template.md');
+        if (template) {
+            atomicWriteText(guideFile, renderTemplate(template, { AID: aid }));
+            logger.info(`[eck] Created ${guideFile}`);
+        }
+    }
+}
+function initEckRuntime(eckDir) {
+    const runtimeFile = path.join(eckDir, 'runtime.md');
+    if (fs.existsSync(runtimeFile))
+        return;
+    const template = loadTemplate('runtime.template.md');
+    if (!template)
+        return;
+    const vars = {
+        EVOLCLAW_HOME: resolvePaths().root,
+        PACKAGE_ROOT: getPackageRoot(),
+    };
+    atomicWriteText(runtimeFile, renderTemplate(template, vars));
+    logger.info(`[eck] Created ${runtimeFile}`);
+}
+function initEckPathRegistry(eckDir) {
+    const registryFile = path.join(eckDir, 'path-registry.md');
+    if (fs.existsSync(registryFile))
+        return;
+    const template = loadTemplate('path-registry.template.md');
+    if (!template)
+        return;
+    const vars = {
+        EVOLCLAW_HOME: resolvePaths().root,
+        PACKAGE_ROOT: getPackageRoot(),
+    };
+    atomicWriteText(registryFile, renderTemplate(template, vars));
+    logger.info(`[eck] Created ${registryFile}`);
+}
+function loadTemplate(filename) {
+    const templatePath = path.join(kitsDocsDir(), 'eck_templates', filename);
+    try {
+        return fs.readFileSync(templatePath, 'utf-8');
+    }
+    catch {
+        logger.warn(`[eck] Template not found: ${templatePath}`);
+        return null;
+    }
+}
+function renderTemplate(template, vars) {
+    let result = template;
+    for (const [key, value] of Object.entries(vars)) {
+        result = result.replaceAll(`{{${key}}}`, value);
+    }
+    return result;
+}

package/dist/eck/rules-loader.js

@@ -0,0 +1,28 @@
+import fs from 'fs';
+import path from 'path';
+import { kitsRulesDir } from '../paths.js';
+let _cachedRules = null;
+export function loadRulesForInjection() {
+    if (_cachedRules !== null)
+        return _cachedRules;
+    const rulesDir = kitsRulesDir();
+    if (!fs.existsSync(rulesDir)) {
+        _cachedRules = '';
+        return '';
+    }
+    const files = fs.readdirSync(rulesDir)
+        .filter(f => f.endsWith('.md'))
+        .sort();
+    const parts = [];
+    for (const file of files) {
+        try {
+            parts.push(fs.readFileSync(path.join(rulesDir, file), 'utf-8'));
+        }
+        catch { /* skip unreadable files */ }
+    }
+    _cachedRules = parts.join('\n\n');
+    return _cachedRules;
+}
+export function invalidateRulesCache() {
+    _cachedRules = null;
+}