evolclaw 2.4.0 → 2.5.0

package/README.md

@@ -2,7 +2,7 @@
 
 > AI Agent 统一网关 —— 连接 IM、终端、Agent 网络
 
-EvolClaw 是一个轻量级 AI Agent 网关系统。它为 Claude Code / Codex 等 AI Agent 提供统一接入层，支持飞书、微信、AUN Mesh 网络和终端 TUI 四种通道。人类可以通过手机 IM 随时接力开发，其他 Agent 也可以通过 AUN 网络直接调用你的 Agent —— 不只是人机交互，也是 Agent 间协作的基础设施。
+EvolClaw 是一个轻量级 AI Agent 网关系统。它为 Claude Code / Codex 等 Coding Agent 提供统一接入层，使其作为通用基座 Agent，接入到飞书、微信、钉钉、QQ频道、企业微信等多种 IM 通道，以及 AUN 多智能体网络。人类可以通过手机 IM 随时接力开发，其他 Agent 也可以通过 AUN 网络直接调用你的 Agent —— 不只是人机交互，也是 Agent 间协作的基础设施。
 
 ## 核心特性
 
@@ -11,10 +11,11 @@ EvolClaw 是一个轻量级 AI Agent 网关系统。它为 Claude Code / Codex
 - 🚀 **轻量化设计**：进程模式运行，CLI 命令行管理，无端口开放，无容器依赖，无 UI 界面
 - 📁 **多项目支持**：每个项目独立会话，支持动态切换
 - 👥 **双模式会话**：多用户私聊会话隔离，群聊会话共享，满足不同协作场景
-- 🌐 **多渠道接入**：Channel Adapter 模式，飞书 + 微信 + AUN Mesh 网络，扫码一键接入
+- 🌐 **多渠道接入**：Channel Adapter 模式，飞书 + 微信 + 钉钉 + QQ频道 + 企业微信 + AUN 网络
 - 🤖 **Agent 间互联**：通过 AUN 网络，你的 Agent 可被其他 Agent 发现和调用
 - 🖥️ **终端 TUI 客户端**：`evolclaw tui` 直接在终端与远程 Agent 对话，无需 IM
-- 🔐 **分层权限**：用户级/管理员级命令分离，多用户安全隔离
+- 🔐 **分层权限**：三级权限体系（user/admin/owner），多用户安全隔离
+- 🛠️ **Agent 自管理**：Agent 可通过 CLI 命令自主管理运行时（查看状态、切换模型、调整配置等）
 - 📦 **项目搬家**：`evolclaw mv` 一键迁移项目目录，保留 Claude/Codex/EvolClaw 全部会话历史
 - 💾 **会话持久化**：会话数据与 CLI 工具共享，不额外存储，服务重启不丢失
 - ⚡ **执行中插入**：任务执行中可发送新消息，自动中断当前任务并处理新请求
@@ -38,7 +39,7 @@ EvolClaw 是一个轻量级 AI Agent 网关系统。它为 Claude Code / Codex
 
 ### 核心组件
 
-1. **消息渠道层** (`src/channels/`) - Feishu WebSocket + WeChat HTTP 长轮询 + AUN Mesh 网络
+1. **消息渠道层** (`src/channels/`) - Feishu + WeChat + DingTalk + QQBot + WeCom + AUN 网络
 2. **消息队列层** (`src/core/message/message-queue.ts`) - 会话级串行处理 + 中断支持
 3. **命令处理层** (`src/core/command-handler.ts`) - 斜杠命令处理（CommandHandler 类）
 4. **消息处理层** (`src/core/message/message-processor.ts`) - 统一事件处理引擎
@@ -111,6 +112,15 @@ evolclaw init feishu
 # 单独配置微信（扫码登录）
 evolclaw init wechat
 
+# 单独配置钉钉（扫码登录）
+evolclaw init dingtalk
+
+# 单独配置 QQ 频道（扫码登录）
+evolclaw init qqbot
+
+# 单独配置企业微信（手动输入 Bot ID + Secret）
+evolclaw init wecom
+
 # 单独配置 AUN（Mesh 网络通道）
 evolclaw init aun
 ```
@@ -193,6 +203,9 @@ evolclaw/
 │   ├── channels/
 │   │   ├── feishu.ts               # 飞书 WebSocket 渠道
 │   │   ├── wechat.ts               # 微信 ClawBot 渠道
+│   │   ├── dingtalk.ts             # 钉钉 Stream 渠道
+│   │   ├── qqbot.ts                # QQ 频道渠道
+│   │   ├── wecom.ts                # 企业微信 AI Bot 渠道
 │   │   └── aun.ts                  # AUN Mesh 网络渠道
 │   ├── utils/                      # 工具函数
 │   ├── types.ts                    # 类型定义
@@ -219,9 +232,10 @@ evolclaw/
 - `/name <新名称>` - 重命名当前会话
 - `/del <名称>` - 删除指定会话（仅解绑，不删除文件）
 - `/status` - 显示会话状态
+- `/check` - 系统健康检查（摘要）
 - `/help` - 显示所有命令
 
-### 管理员级命令（仅 Owner 可用）
+### 管理员级命令（Admin+ 可用）
 
 **项目管理**：
 - `/pwd` - 显示当前项目路径
@@ -238,32 +252,37 @@ evolclaw/
 **系统管理**：
 - `/clear` - 清空对话历史
 - `/compact` - 压缩会话上下文
+- `/rewind <turn>` - 回退会话到指定轮次
 - `/stop` - 中断当前任务
+- `/check` - 系统健康检查（详情）
+- `/activity [all|dm|owner|none]` - 查看/控制中间输出显示模式
+- `/restart <channel>` - 重连指定渠道
+
+### Owner 专属命令
+
 - `/send <文件路径>` - 发送文件给用户
-- `/check` - 系统健康检查面板
 - `/restart` - 重启服务（自愈机制）
 - `/repair` - 检查并修复会话
-- `/safe` - 进入安全模式
+- `/agentmd [put|set]` - 管理 AUN agent.md（仅 AUN 渠道）
 
 ## 技术栈
 
 - **运行时**：Node.js >= 22 + TypeScript（ES modules）
 - **AI SDK**：@anthropic-ai/claude-agent-sdk >= 0.2.75、@openai/codex-sdk、Gemini CLI
-- **消息渠道**：飞书（@larksuiteoapi/node-sdk）、微信（ClawBot ilink API）、AUN Mesh 网络
+- **消息渠道**：飞书（@larksuiteoapi/node-sdk）、微信（ClawBot ilink API）、钉钉（dingtalk-stream）、QQ频道（pure-qqbot）、企业微信（AI Bot API）、AUN 网络
 - **数据存储**：node:sqlite（内置模块）+ JSONL（CLI 共用）
 - **测试框架**：Vitest
 
 ## TODO
 
-- [x] Windows 系统 CLI 命令支持
-- [x] 微信插件支持图片/文件的收发
 - [x] AUN Mesh 网络通道接入
 - [x] TUI 终端客户端（`evolclaw tui`）
 - [x] 项目搬家工具（`evolclaw mv`）
-- [ ] 自动授权可配置（自动放行/自动拒绝）
-- [x] 手动授权支持（文本回复）
-- [x] 手动授权支持（飞书卡片）
-- [ ] ACP 协议支持（接入 Codex / Gemini CLI）
+- [x] 手动授权支持（文本回复 + 飞书卡片）
+- [x] 自动授权可配置（自动放行/自动拒绝）
+- [ ] AUN 群组扩展功能支持
+- [ ] 触发器支持
+- [ ] 统计/状态监控 WebHook
 
 
 ## 许可证

package/dist/agents/claude-runner.js

@@ -1,4 +1,4 @@
-import { query, forkSession as sdkForkSession } from '@anthropic-ai/claude-agent-sdk';
+import { query, forkSession as sdkForkSession, getSessionMessages as sdkGetSessionMessages } from '@anthropic-ai/claude-agent-sdk';
 import { ensureDir, resolveAnthropicConfig } from '../config.js';
 import path from 'path';
 import fs from 'fs';
@@ -82,7 +82,8 @@ export class AgentRunner {
     onCompactStart;
     permissionGateway;
     sendPromptFn;
-    permissionContext;
+    permissionContexts = new Map();
+    currentEvolclawSessionId;
     constructor(apiKey, model, onSessionIdUpdate, baseUrl, config) {
         this.apiKey = apiKey;
         this.model = model || 'sonnet';
@@ -97,7 +98,8 @@ export class AgentRunner {
             ANTHROPIC_AUTH_TOKEN: this.apiKey,
             PATH: process.env.PATH,
             DISABLE_AUTOUPDATER: '1',
-            ...(this.baseUrl ? { ANTHROPIC_BASE_URL: this.baseUrl } : {})
+            ...(this.baseUrl ? { ANTHROPIC_BASE_URL: this.baseUrl } : {}),
+            ...(this.currentEvolclawSessionId ? { EVOLCLAW_SESSION_ID: this.currentEvolclawSessionId } : {}),
         };
     }
     setModel(model) {
@@ -139,8 +141,8 @@ export class AgentRunner {
     setSendPrompt(fn) {
         this.sendPromptFn = fn;
     }
-    setPermissionContext(context) {
-        this.permissionContext = context;
+    setPermissionContext(sessionId, context) {
+        this.permissionContexts.set(sessionId, context);
     }
     toSdkPermissionMode() {
         const map = {
@@ -186,6 +188,141 @@ export class AgentRunner {
     setCompactStartCallback(callback) {
         this.onCompactStart = callback;
     }
+    /**
+     * 处理 AskUserQuestion 工具调用：将 SDK 问题转换为飞书 action 卡片，逐个收集用户答案
+     * SDK 期望返回 updatedInput 中包含 answers 字段：{ [questionText]: selectedLabel | selectedLabel[] }
+     */
+    async handleAskUserQuestion(sessionId, input, options) {
+        const questions = input.questions;
+        // 没有交互上下文（无渠道适配器），回退到纯文本
+        const permCtx = this.permissionContexts.get(sessionId);
+        if (!permCtx?.adapter?.sendInteraction || !permCtx?.channelId) {
+            return this.handleAskUserQuestionFallback(input, questions);
+        }
+        const answers = {};
+        // 闭包捕获当前 sendPromptFn，避免异步等待期间被其他会话覆盖
+        const sendPrompt = this.sendPromptFn;
+        // 逐个 question 发送卡片并等待用户选择
+        for (let i = 0; i < questions.length; i++) {
+            const q = questions[i];
+            const requestId = `ask-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const cardTitle = q.header ? `💬 ${q.header}` : `💬 问题 ${i + 1}/${questions.length}`;
+            // 统一使用 action 按钮卡片（单选 / 多选均用按钮）
+            const bodyLines = [q.question];
+            if (q.options.some(opt => opt.description)) {
+                bodyLines.push('');
+                q.options.forEach((opt, idx) => {
+                    bodyLines.push(`${idx + 1}. **${opt.label}**${opt.description ? ` — ${opt.description}` : ''}`);
+                });
+            }
+            const interaction = {
+                type: 'interaction',
+                id: requestId,
+                kind: {
+                    kind: 'action',
+                    title: cardTitle,
+                    body: bodyLines.join('\n'),
+                    buttons: [
+                        ...q.options.map(opt => ({
+                            key: opt.label,
+                            label: opt.label,
+                            style: 'default',
+                        })),
+                        ...(permCtx.interceptNextMessage ? [{
+                                key: '_custom_input',
+                                label: '✏️ 手动输入',
+                                style: 'default',
+                            }] : []),
+                    ],
+                },
+                channelId: permCtx.channelId,
+                sessionId,
+                expiresAt: Date.now() + 5 * 60 * 1000,
+            };
+            let cardSent = false;
+            try {
+                const result = await permCtx.adapter.sendInteraction(permCtx.channelId, interaction, permCtx.replyContext);
+                cardSent = !!result;
+            }
+            catch (err) {
+                logger.warn(`[AgentRunner] AskUserQuestion card send failed for q${i}:`, err);
+            }
+            if (!cardSent) {
+                // 卡片发送失败，以纯文本展示选项并自动选推荐项
+                const firstLabel = q.options[0]?.label || '';
+                answers[q.question] = q.multiSelect ? [firstLabel] : firstLabel;
+                if (sendPrompt) {
+                    const optText = q.options.map((o, idx) => `  ${idx + 1}. ${o.label}${o.description ? ` — ${o.description}` : ''}`).join('\n');
+                    await sendPrompt(`💬 ${q.header || q.question}\n${q.header ? q.question + '\n' : ''}${optText}\n  → 自动选择：${firstLabel}`);
+                }
+                continue;
+            }
+            // 等待用户交互
+            const answer = await new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    permCtx?.interactionRouter?.cancel(requestId);
+                    permCtx?.cancelIntercept?.(sessionId);
+                    logger.info(`[AgentRunner] AskUserQuestion timeout for ${requestId}`);
+                    resolve(null);
+                }, 5 * 60 * 1000);
+                permCtx?.interactionRouter?.register(requestId, sessionId, (action, values) => {
+                    clearTimeout(timer);
+                    if (action === 'cancel') {
+                        resolve(null);
+                    }
+                    else if (action === '_custom_input' && permCtx.interceptNextMessage) {
+                        // "手动输入"：发提示，拦截下一条消息
+                        const sendHint = async () => {
+                            if (sendPrompt) {
+                                await sendPrompt('✏️ 请输入你的想法，回复后继续……');
+                            }
+                        };
+                        sendHint().catch(() => { });
+                        permCtx.interceptNextMessage(sessionId, (msg) => {
+                            resolve(msg.content || null);
+                        });
+                    }
+                    else if (q.multiSelect) {
+                        // multiSelect 按钮点击：包装为数组
+                        resolve([action]);
+                    }
+                    else {
+                        resolve(action); // action = button key = option label
+                    }
+                });
+            });
+            if (answer === null) {
+                // 超时或取消，自动选第一项
+                const firstLabel = q.options[0]?.label || '';
+                answers[q.question] = q.multiSelect ? [firstLabel] : firstLabel;
+            }
+            else {
+                answers[q.question] = answer;
+            }
+        }
+        const updatedInput = { ...input, answers };
+        return { behavior: 'allow', updatedInput, decisionClassification: 'user_temporary' };
+    }
+    /**
+     * AskUserQuestion 纯文本 fallback：发送文本格式的问题，直接 allow
+     */
+    async handleAskUserQuestionFallback(input, questions) {
+        // 自动选择每个问题的第一个选项
+        const answers = {};
+        if (questions?.length) {
+            const lines = questions.map(q => {
+                const firstLabel = q.options[0]?.label || '';
+                answers[q.question] = firstLabel;
+                const optText = q.options.map((o, i) => `  ${i + 1}. ${o.label}${o.description ? ` — ${o.description}` : ''}`).join('\n');
+                return `${q.question}\n${optText}\n  → 自动选择：${firstLabel}`;
+            });
+            if (this.sendPromptFn) {
+                await this.sendPromptFn(`💬 以下问题已自动选择第一项：\n\n${lines.join('\n\n')}`);
+            }
+        }
+        const updatedInput = { ...input, answers };
+        return { behavior: 'allow', updatedInput, decisionClassification: 'user_temporary' };
+    }
     /**
      * SDK 原始事件 → 标准 AgentEvent 转换
      * 所有 SDK 特有的事件类型引用封装在此方法内
@@ -271,9 +408,13 @@ export class AgentRunner {
                         };
                     }
                 }
+                // 剥离 SDK result 中混入的 <thinking>...</thinking> 块
+                const cleanResult = typeof event.result === 'string'
+                    ? event.result.replace(/<thinking>[\s\S]*?<\/thinking>\s*/g, '').trim()
+                    : event.result;
                 yield {
                     type: 'complete',
-                    result: event.result,
+                    result: cleanResult,
                     subtype: event.subtype,
                     isError: event.is_error,
                     errors: event.errors,
@@ -286,25 +427,16 @@ export class AgentRunner {
         }
     }
     async runQuery(sessionId, prompt, projectPath, initialClaudeSessionId, images, systemPromptAppend, sessionManager) {
+        // 记录当前 evolclaw session ID，用于 Agent ctl 环境变量注入
+        this.currentEvolclawSessionId = sessionId;
         // 同步用户级配置到内存
         this.syncFromUserSettings();
         ensureDir(projectPath);
         ensureDir(path.join(projectPath, '.claude'));
         // 优先使用传入的 agentSessionId（从数据库恢复），否则使用内存中的
         let agentSessionId = initialClaudeSessionId || this.activeSessions.get(sessionId);
-        // 检查是否在安全模式
-        let skipResume = false;
-        if (sessionManager) {
-            const health = await sessionManager.getHealthStatus(sessionId);
-            if (health.safeMode) {
-                // 安全模式：不使用 resume，每次都是新对话
-                agentSessionId = undefined;
-                skipResume = true;
-                logger.warn(`[AgentRunner] Safe mode enabled for ${sessionId}, not resuming session`);
-            }
-        }
-        // 验证会话文件是否存在且有效（仅在非安全模式且有 agentSessionId 时）
-        if (agentSessionId && !skipResume) {
+        // 验证会话文件是否存在且有效（仅在有 agentSessionId 时）
+        if (agentSessionId) {
             const homeDir = os.homedir();
             const encodedProjectPath = encodePath(projectPath);
             const sessionFile = path.join(homeDir, '.claude', 'projects', encodedProjectPath, `${agentSessionId}.jsonl`);
@@ -401,6 +533,11 @@ export class AgentRunner {
         // SDK-level canUseTool 回调：接入 PermissionGateway 的用户审批入口
         // 只在 SDK 认为此工具需要用户确认时触发（黑名单已在 PreToolUse hook 拦截）
         const canUseToolCallback = async (toolName, input, options) => {
+            // 特殊处理：AskUserQuestion 工具（SDK 内置的用户交互工具）
+            // 这不是权限审批，而是收集用户答案，需要构造表单卡片
+            if (toolName === 'AskUserQuestion') {
+                return await this.handleAskUserQuestion(sessionId, input, options);
+            }
             // bypass 模式：一律 allow
             if (this.permissionMode === 'bypass') {
                 return { behavior: 'allow', updatedInput: input, decisionClassification: 'user_permanent' };
@@ -429,7 +566,7 @@ export class AgentRunner {
             const summary = options.title
                 || options.description
                 || summarizeToolInput(toolName, input);
-            const decision = await this.permissionGateway.requestPermission(sessionId, toolName, input, this.sendPromptFn, this.permissionContext, summary, options.decisionReason);
+            const decision = await this.permissionGateway.requestPermission(sessionId, toolName, input, this.sendPromptFn, this.permissionContexts.get(sessionId), summary, options.decisionReason);
             if (decision === 'deny') {
                 return { behavior: 'deny', message: '用户拒绝或审批超时', decisionClassification: 'user_reject' };
             }
@@ -444,7 +581,7 @@ export class AgentRunner {
         const excludeDynamic = this.config?.agents?.anthropic?.excludeDynamicSections === true;
         // 公共 options（新旧模式共用）
         const sdkPermissionMode = this.toSdkPermissionMode();
-        logger.info(`[AgentRunner] runQuery model=${this.model} effort=${this.effort ?? 'auto'} permMode=${this.permissionMode} sdkMode=${sdkPermissionMode}`);
+        logger.info(`[AgentRunner] runQuery model=${this.model} effort=${this.effort ?? 'auto'} permMode=${this.permissionMode} sdkMode=${sdkPermissionMode} systemPromptAppend=${systemPromptAppend ? systemPromptAppend.substring(0, 100) + '...' : 'none'}`);
         const commonOptions = {
             cwd: projectPath,
             model: this.model,
@@ -454,6 +591,7 @@ export class AgentRunner {
             canUseTool: canUseToolCallback,
             permissionMode: sdkPermissionMode,
             persistSession: true,
+            enableFileCheckpointing: true,
             hooks: {
                 PreCompact: [{ matcher: '.*', hooks: [preCompactHook] }],
                 PreToolUse: [{ matcher: '.*', hooks: [preToolUseHook] }],
@@ -470,7 +608,7 @@ export class AgentRunner {
             },
             env: this.getAgentEnv()
         };
-        const createQuery = (promptInput, resumeSessionId) => {
+        const createQuery = (promptInput, resumeSessionId, resumeAt) => {
             if (useSettingSources) {
                 // 新方式：SDK 自动加载 CLAUDE.md 和 MCP 配置
                 return query({
@@ -485,6 +623,7 @@ export class AgentRunner {
                             ...(systemPromptAppend ? { append: systemPromptAppend } : {})
                         },
                         ...(resumeSessionId ? { resume: resumeSessionId } : {}),
+                        ...(resumeAt ? { resumeSessionAt: resumeAt } : {}),
                     }
                 });
             }
@@ -528,6 +667,7 @@ export class AgentRunner {
                     options: {
                         ...commonOptions,
                         ...(resumeSessionId ? { resume: resumeSessionId } : {}),
+                        ...(resumeAt ? { resumeSessionAt: resumeAt } : {}),
                         ...(Object.keys(globalMcpServers).length > 0 ? { mcpServers: globalMcpServers } : {}),
                         ...(fullAppend ? {
                             systemPrompt: {
@@ -540,6 +680,23 @@ export class AgentRunner {
                 });
             }
         };
+        // 检查待处理的 resumeAt（由 /rewind N chat 设置）
+        let resumeAt;
+        if (sessionManager && agentSessionId) {
+            try {
+                const currentSession = await sessionManager.getSessionById?.(sessionId);
+                if (currentSession?.metadata?.resumeAt) {
+                    resumeAt = currentSession.metadata.resumeAt;
+                    const newMeta = { ...currentSession.metadata };
+                    delete newMeta.resumeAt;
+                    await sessionManager.updateSession(sessionId, { metadata: newMeta });
+                    logger.info(`[AgentRunner] Consuming resumeAt: ${resumeAt}`);
+                }
+            }
+            catch (err) {
+                logger.warn('[AgentRunner] Failed to check resumeAt:', err);
+            }
+        }
         let sdkStream;
         if (images && images.length > 0) {
             logger.debug('[AgentRunner] Creating query with images, images:', images.length);
@@ -551,7 +708,7 @@ export class AgentRunner {
         }
         else {
             logger.debug('[AgentRunner] Creating query with text only, agentSessionId:', initialClaudeSessionId);
-            sdkStream = createQuery(prompt, agentSessionId);
+            sdkStream = createQuery(prompt, agentSessionId, resumeAt);
         }
         // 保存 interrupt 能力（不写 activeStreams，由 registerStream 管理活跃状态）
         if ('interrupt' in sdkStream && typeof sdkStream.interrupt === 'function') {
@@ -657,6 +814,7 @@ export class AgentRunner {
         this.activeSessions.delete(sessionId);
         this.activeStreams.delete(sessionId);
         this.interruptFns.delete(sessionId);
+        this.permissionContexts.delete(sessionId);
     }
     resolveSessionFile(agentSessionId, projectPath) {
         const encodedProjectPath = encodePath(projectPath);
@@ -667,6 +825,49 @@ export class AgentRunner {
         const result = await sdkForkSession(agentSessionId, { dir: projectPath, title });
         return result.sessionId;
     }
+    async getSessionMessages(agentSessionId, projectPath) {
+        return sdkGetSessionMessages(agentSessionId, { dir: projectPath });
+    }
+    async rewindFiles(agentSessionId, projectPath, userMessageId) {
+        logger.info(`[RewindFiles] agentSessionId=${agentSessionId} userMessageId=${userMessageId}`);
+        const stderrChunks = [];
+        const tempQuery = query({
+            prompt: '',
+            options: {
+                cwd: projectPath,
+                resume: agentSessionId,
+                enableFileCheckpointing: true,
+                permissionMode: this.toSdkPermissionMode(),
+                stderr: (data) => { stderrChunks.push(data); },
+            }
+        });
+        try {
+            for await (const _msg of tempQuery) {
+                const dryResult = await tempQuery.rewindFiles(userMessageId, { dryRun: true });
+                logger.info('[RewindFiles] dryRun result:', JSON.stringify(dryResult));
+                if (!dryResult.canRewind)
+                    return dryResult;
+                const result = await tempQuery.rewindFiles(userMessageId);
+                logger.info('[RewindFiles] rewind result:', JSON.stringify(result));
+                return {
+                    ...result,
+                    filesChanged: dryResult.filesChanged ?? result.filesChanged,
+                    insertions: dryResult.insertions ?? result.insertions,
+                    deletions: dryResult.deletions ?? result.deletions,
+                };
+            }
+            throw new Error('Query stream ended before rewindFiles could be called');
+        }
+        catch (error) {
+            if (stderrChunks.length > 0) {
+                logger.error('[RewindFiles] subprocess stderr:', stderrChunks.join(''));
+            }
+            throw error;
+        }
+        finally {
+            tempQuery.close();
+        }
+    }
 }
 // Plugin implementation
 export class ClaudeAgentPlugin {

package/dist/agents/codex-runner.js

@@ -87,15 +87,9 @@ export class CodexRunner {
     }
     // ── Core: runQuery ──
     async runQuery(sessionId, prompt, projectPath, initialAgentSessionId, images, systemPromptAppend, sessionManager) {
+        // Agent ctl: 注入 EVOLCLAW_SESSION_ID 供子进程使用
+        process.env.EVOLCLAW_SESSION_ID = sessionId;
         let agentSessionId = initialAgentSessionId || this.activeSessions.get(sessionId);
-        // 安全模式：跳过 resume，创建新 thread
-        if (agentSessionId && sessionManager) {
-            const health = await sessionManager.getHealthStatus(sessionId);
-            if (health.safeMode) {
-                agentSessionId = undefined;
-                logger.warn(`[CodexRunner] Safe mode enabled for ${sessionId}, not resuming thread`);
-            }
-        }
         const threadOptions = {
             workingDirectory: projectPath,
             model: this.model,

package/dist/agents/gemini-runner.js

@@ -89,14 +89,6 @@ export class GeminiRunner {
     // ── Core: runQuery ──
     async runQuery(sessionId, prompt, projectPath, initialAgentSessionId, images, systemPromptAppend, sessionManager) {
         let geminiSessionId = initialAgentSessionId || this.activeSessions.get(sessionId);
-        // Safe mode: skip resume
-        if (geminiSessionId && sessionManager) {
-            const health = await sessionManager.getHealthStatus(sessionId);
-            if (health.safeMode) {
-                geminiSessionId = undefined;
-                logger.warn(`[GeminiRunner] Safe mode enabled for ${sessionId}, not resuming session`);
-            }
-        }
         // Build CLI args
         const args = [];
         // Only inject system context on first turn (no resume).
@@ -139,6 +131,7 @@ export class GeminiRunner {
         // Spawn subprocess
         const env = {
             ...process.env,
+            EVOLCLAW_SESSION_ID: sessionId,
         };
         if (this.resolved.apiKey) {
             env.GOOGLE_API_KEY = this.resolved.apiKey;