evolclaw 2.2.0 → 2.3.0

package/README.md

@@ -1,8 +1,8 @@
 # EvolClaw
 
-> 把 Claude Code 装进飞书和微信 —— 随时随地，接力开发
+> AI Agent 统一网关 —— 连接 IM、终端、Agent 网络
 
-EvolClaw 是一个轻量级 AI Agent 网关，基于 Claude Agent SDK 构建。它将终端中的 Claude Code 能力延伸到飞书、微信等即时通讯工具，让你在手机上也能review 代码、调试问题、管理项目，真正实现多终端无缝接力开发。
+EvolClaw 是一个轻量级 AI Agent 网关系统。它为 Claude Code / Codex 等 AI Agent 提供统一接入层，支持飞书、微信、AUN Mesh 网络和终端 TUI 四种通道。人类可以通过手机 IM 随时接力开发，其他 Agent 也可以通过 AUN 网络直接调用你的 Agent —— 不只是人机交互，也是 Agent 间协作的基础设施。
 
 ## 核心特性
 
@@ -11,9 +11,11 @@ EvolClaw 是一个轻量级 AI Agent 网关，基于 Claude Agent SDK 构建。
 - 🚀 **轻量化设计**：进程模式运行，CLI 命令行管理，无端口开放，无容器依赖，无 UI 界面
 - 📁 **多项目支持**：每个项目独立会话，支持动态切换
 - 👥 **双模式会话**：多用户私聊会话隔离，群聊会话共享，满足不同协作场景
-- 🌐 **多渠道接入**：Channel Adapter 模式，飞书 + 微信扫码一键接入
+- 🌐 **多渠道接入**：Channel Adapter 模式，飞书 + 微信 + AUN Mesh 网络，扫码一键接入
+- 🤖 **Agent 间互联**：通过 AUN 网络，你的 Agent 可被其他 Agent 发现和调用
+- 🖥️ **终端 TUI 客户端**：`evolclaw tui` 直接在终端与远程 Agent 对话，无需 IM
 - 🔐 **分层权限**：用户级/管理员级命令分离，多用户安全隔离
-- 📊 **统一消息处理**：消息处理与渠道解耦，新增渠道仅需 ~15 行代码
+- 📦 **项目搬家**：`evolclaw mv` 一键迁移项目目录，保留 Claude/Codex/EvolClaw 全部会话历史
 - 💾 **会话持久化**：会话数据与 CLI 工具共享，不额外存储，服务重启不丢失
 - ⚡ **执行中插入**：任务执行中可发送新消息，自动中断当前任务并处理新请求
 - 🔕 **消息智能发送**：前台任务动态聚合批量发送，后台任务静默完成后通知
@@ -23,7 +25,8 @@ EvolClaw 是一个轻量级 AI Agent 网关，基于 Claude Agent SDK 构建。
 
 - **通勤路上**：手机打开飞书，继续昨晚的代码 review，到公司无缝切回终端
 - **会议间隙**：微信快速问一句「这个接口的返回格式是什么」，Agent 直接查代码回复
-- **下班之后**：躺在沙发上用手机跟进 CI 报错，让 Agent 定位问题并修复
+- **终端直连**：`evolclaw tui` 在任意终端直接与远程 Agent 对话，无需打开 IM
+- **Agent 协作**：通过 AUN 网络，让你的 Agent 被其他 Agent 调用，组成分布式协作
 - **外出离开工位**：不带电脑也能通过 IM 给 Agent 下达任务，回来看结果
 - **团队协作**：拉个飞书群，成员共享同一个 Agent 会话，一起讨论和调试
 
@@ -36,11 +39,12 @@ EvolClaw 是一个轻量级 AI Agent 网关，基于 Claude Agent SDK 构建。
 ### 核心组件
 
 1. **消息渠道层** (`src/channels/`) - Feishu WebSocket + WeChat HTTP 长轮询 + AUN Mesh 网络
-2. **消息队列层** (`src/core/message-queue.ts`) - 会话级串行处理 + 中断支持
+2. **消息队列层** (`src/core/message/message-queue.ts`) - 会话级串行处理 + 中断支持
 3. **命令处理层** (`src/core/command-handler.ts`) - 斜杠命令处理（CommandHandler 类）
-4. **消息处理层** (`src/core/message-processor.ts`) - 统一事件处理引擎
-5. **会话管理层** (`src/core/session-manager.ts`) - 多项目会话管理
-6. **会话存储层** - JSONL 文件（CLI 共用）+ SQLite 元数据
+4. **消息处理层** (`src/core/message/message-processor.ts`) - 统一事件处理引擎
+5. **会话管理层** (`src/core/session/session-manager.ts`) - 多项目会话管理
+6. **交互路由层** (`src/core/interaction-router.ts`) - 卡片交互回调注册与路由
+7. **会话存储层** - JSONL 文件（CLI 共用）+ SQLite 元数据
 
 ### 消息流转
 
@@ -153,6 +157,9 @@ evolclaw stop       # 停止服务
 evolclaw restart    # 重启服务
 evolclaw status     # 查看状态
 evolclaw logs       # 查看日志（tail -f）
+evolclaw tui        # 启动 AUN TUI 终端客户端
+evolclaw mv <old> <new>  # 项目搬家（保留全部会话）
+evolclaw diagnose   # 诊断启动环境
 
 # 开发模式（热重载）
 npm run dev
@@ -166,14 +173,23 @@ npm test
 ```
 evolclaw/
 ├── src/
+│   ├── agents/
+│   │   ├── claude-runner.ts        # Claude Agent SDK 封装
+│   │   ├── codex-runner.ts         # Codex Agent 封装
+│   │   └── gemini-runner.ts        # Gemini CLI 封装
 │   ├── core/
-│   │   ├── command-handler.ts       # 斜杠命令处理
-│   │   ├── session-manager.ts       # 会话管理（多项目支持）
-│   │   ├── message-queue.ts         # 消息队列（串行+中断）
-│   │   ├── message-processor.ts     # 统一消息处理引擎
-│   │   ├── stream-flusher.ts        # 批量发送（3秒窗口）
-│   │   ├── agent-runner.ts          # Claude Agent SDK 封装
-│   │   └── message-cache.ts         # 消息缓存
+│   │   ├── message/
+│   │   │   ├── message-bridge.ts   # 渠道 ↔ 核心消息桥
+│   │   │   ├── message-processor.ts # 统一消息处理引擎
+│   │   │   ├── message-queue.ts    # 消息队列（串行+中断）
+│   │   │   ├── message-cache.ts    # 消息缓存
+│   │   │   └── stream-flusher.ts   # 批量发送（3秒窗口）
+│   │   ├── session/
+│   │   │   ├── adapters/           # 各后端会话文件适配器
+│   │   │   └── session-manager.ts  # 会话管理（多项目支持）
+│   │   ├── command-handler.ts      # 斜杠命令处理
+│   │   ├── interaction-router.ts   # 卡片交互回调路由
+│   │   └── permission.ts           # 权限网关
 │   ├── channels/
 │   │   ├── feishu.ts               # 飞书 WebSocket 渠道
 │   │   ├── wechat.ts               # 微信 ClawBot 渠道
@@ -182,8 +198,11 @@ evolclaw/
 │   ├── types.ts                    # 类型定义
 │   ├── config.ts                   # 配置加载
 │   ├── paths.ts                    # 路径解析
-│   ├── cli.ts                      # CLI 命令（init/start/stop/...）
+│   ├── cli.ts                      # CLI 命令（init/start/stop/tui/mv/...）
 │   └── index.ts                    # 主入口
+├── aun/
+│   ├── aun_cli.py                  # AUN TUI 客户端（Python）
+│   └── pyproject.toml              # AUN CLI 依赖声明
 └── data/
     └── evolclaw.sample.json        # 配置模板
 ```
@@ -195,7 +214,8 @@ evolclaw/
 **会话管理**：
 - `/new [名称]` - 创建新会话
 - `/slist` - 列出当前项目的所有会话
-- `/s <名称>` - 切换到指定会话
+- `/slist cli` - 列出未导入的 CLI 会话
+- `/s <名称|序号|uuid>` - 切换到指定会话
 - `/name <新名称>` - 重命名当前会话
 - `/del <名称>` - 删除指定会话（仅解绑，不删除文件）
 - `/status` - 显示会话状态
@@ -209,6 +229,12 @@ evolclaw/
 - `/p <name|path>` - 切换项目（保留会话历史）
 - `/bind <path>` - 绑定新项目目录
 
+**Agent 与模型**：
+- `/agent [name]` - 查看或切换 Agent 后端（claude / codex / gemini）
+- `/model [model]` - 查看或切换模型
+- `/effort [level]` - 查看或切换推理强度（low / medium / high / max / auto）
+- `/perm [mode]` - 查看或切换权限模式（auto / edit / default / readonly）
+
 **系统管理**：
 - `/clear` - 清空对话历史
 - `/compact` - 压缩会话上下文
@@ -219,17 +245,10 @@ evolclaw/
 - `/repair` - 检查并修复会话
 - `/safe` - 进入安全模式
 
-**模型管理**：
-- `/model` - 显示当前模型和推理强度
-- `/model <model>` - 切换模型
-- `/model <effort>` - 切换推理强度（low / medium / high / max）
-- `/model <model> <effort>` - 同时切换模型和推理强度
-- `/model auto` - 恢复 SDK 默认推理强度
-
 ## 技术栈
 
 - **运行时**：Node.js >= 22 + TypeScript（ES modules）
-- **AI SDK**：@anthropic-ai/claude-agent-sdk >= 0.2.75
+- **AI SDK**：@anthropic-ai/claude-agent-sdk >= 0.2.75、@openai/codex-sdk、Gemini CLI
 - **消息渠道**：飞书（@larksuiteoapi/node-sdk）、微信（ClawBot ilink API）、AUN Mesh 网络
 - **数据存储**：node:sqlite（内置模块）+ JSONL（CLI 共用）
 - **测试框架**：Vitest
@@ -239,8 +258,11 @@ evolclaw/
 - [x] Windows 系统 CLI 命令支持
 - [x] 微信插件支持图片/文件的收发
 - [x] AUN Mesh 网络通道接入
+- [x] TUI 终端客户端（`evolclaw tui`）
+- [x] 项目搬家工具（`evolclaw mv`）
 - [ ] 自动授权可配置（自动放行/自动拒绝）
-- [ ] 手动授权支持（飞书卡片/文本回复）
+- [x] 手动授权支持（文本回复）
+- [x] 手动授权支持（飞书卡片）
 - [ ] ACP 协议支持（接入 Codex / Gemini CLI）
 
 

package/data/evolclaw.sample.json

@@ -9,6 +9,9 @@
       "model": "gpt-5.2-codex",
       "effort": "medium"
     },
+    "google": {
+      "model": "gemini-2.5-flash"
+    },
     "defaultAgent": "claude"
   },
   "channels": {
@@ -24,9 +27,9 @@
       "token": ""
     },
     "aun": {
-      "enabled": true,
-      "domain": "your-aun-domain",
-      "agentName": "your-agent-name"
+      "enabled": false,
+      "aid": "your-agent.agentid.pub",
+      "gatewayPort": 443
     }
   },
   "projects": {

package/dist/agents/claude-runner.js

@@ -4,7 +4,7 @@ import path from 'path';
 import fs from 'fs';
 import os from 'os';
 import { logger } from '../utils/logger.js';
-import { checkBlacklist, summarizeToolInput } from '../utils/permission-utils.js';
+import { checkBlacklist, checkReadonly, summarizeToolInput } from '../core/permission.js';
 import { encodePath } from '../utils/cross-platform.js';
 class MessageStream {
     queue = [];
@@ -72,7 +72,7 @@ export class AgentRunner {
     apiKey;
     model;
     effort;
-    permissionMode = 'default'; // default = 全部自动放行
+    permissionMode = 'auto';
     baseUrl;
     config;
     activeSessions = new Map();
@@ -82,6 +82,7 @@ export class AgentRunner {
     onCompactStart;
     permissionGateway;
     sendPromptFn;
+    permissionContext;
     constructor(apiKey, model, onSessionIdUpdate, baseUrl, config) {
         this.apiKey = apiKey;
         this.model = model || 'sonnet';
@@ -123,11 +124,13 @@ export class AgentRunner {
     }
     listModes() {
         return [
-            { key: 'default', nameZh: '默认', description: '全部自动放行', available: true },
+            { key: 'auto', nameZh: '自动', description: 'AI 分类器自动判断', available: true },
+            { key: 'bypass', nameZh: '放行', description: '全部自动放行', available: true },
             { key: 'request', nameZh: '审批', description: '部分自动，部分询问', available: true },
             { key: 'edit', nameZh: '编辑', description: '自动接受编辑，其他询问', available: true },
             { key: 'plan', nameZh: '规划', description: '只规划不执行', available: true },
             { key: 'noask', nameZh: '静默', description: '未批准则拒绝', available: true },
+            { key: 'readonly', nameZh: '只读', description: '禁止修改项目文件，可在临时目录生成文件', available: true },
         ];
     }
     setPermissionGateway(gateway) {
@@ -136,15 +139,20 @@ export class AgentRunner {
     setSendPrompt(fn) {
         this.sendPromptFn = fn;
     }
+    setPermissionContext(context) {
+        this.permissionContext = context;
+    }
     toSdkPermissionMode() {
         const map = {
-            'default': 'default', // 全部自动放行，靠 canUseTool 一律 allow 实现
+            'auto': 'auto', // AI 分类器自动判断
+            'bypass': 'default', // 全部自动放行（通过 canUseTool 一律 allow，保留 hook 安全检查）
             'request': 'default', // 部分自动，部分询问
             'edit': 'acceptEdits',
             'plan': 'plan',
             'noask': 'dontAsk',
+            'readonly': 'default',
         };
-        return map[this.permissionMode] || 'default';
+        return map[this.permissionMode] || 'auto';
     }
     // ── Compactable 接口 ──
     async compact(sessionId, agentSessionId, projectPath) {
@@ -156,14 +164,19 @@ export class AgentRunner {
             if (!fs.existsSync(settingsPath))
                 return;
             const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-            if (settings.model && settings.model !== this.model) {
+            // evolclaw.json 显式配置优先，不被 settings.json 覆盖
+            const configModel = this.config?.agents?.anthropic?.model;
+            if (!configModel && settings.model && settings.model !== this.model) {
                 logger.info(`[AgentRunner] Synced model from ~/.claude/settings.json: ${settings.model}`);
                 this.model = settings.model;
             }
-            const newEffort = settings.effortLevel || undefined;
-            if (newEffort !== this.effort) {
-                logger.info(`[AgentRunner] Synced effort from ~/.claude/settings.json: ${newEffort ?? 'auto'}`);
-                this.effort = newEffort;
+            const configEffort = this.config?.agents?.anthropic?.effort;
+            if (!configEffort) {
+                const newEffort = settings.effortLevel || undefined;
+                if (newEffort !== this.effort) {
+                    logger.info(`[AgentRunner] Synced effort from ~/.claude/settings.json: ${newEffort ?? 'auto'}`);
+                    this.effort = newEffort;
+                }
             }
         }
         catch (error) {
@@ -207,6 +220,10 @@ export class AgentRunner {
                     durationMs: event.duration_ms,
                 };
             }
+            // system: session_state_changed → state_changed
+            if (event.type === 'system' && event.subtype === 'session_state_changed') {
+                yield { type: 'state_changed', state: event.state };
+            }
             // assistant: 提取 tool_use 和文本（仅无 text_delta 时提取文本）
             if (event.type === 'assistant' && event.message?.content) {
                 for (const content of event.message.content) {
@@ -262,6 +279,8 @@ export class AgentRunner {
                     errors: event.errors,
                     durationMs: event.duration_ms,
                     costUsd: event.total_cost_usd,
+                    terminalReason: event.terminal_reason,
+                    sessionTitle: event.session_title,
                 };
             }
         }
@@ -329,38 +348,100 @@ export class AgentRunner {
             }
             return {};
         };
-        // PreToolUse Hook - 黑名单检查（不可绕过，所有模式都走）
+        // PreToolUse Hook - 黑名单检查 + input 修正（不可绕过，所有模式都走）
         const preToolUseHook = async (input) => {
             const result = await checkBlacklist(input.tool_name, input.tool_input || {});
             if (result.behavior === 'deny') {
+                return { decision: 'block', reason: result.message };
+            }
+            if (this.permissionMode === 'readonly') {
+                const roResult = checkReadonly(input.tool_name, input.tool_input || {}, projectPath);
+                if (roResult.behavior === 'deny') {
+                    return { decision: 'block', reason: roResult.message };
+                }
+            }
+            // 修正 SDK schema 不兼容问题：部分工具被 system prompt 或 skills 指示传入
+            // SDK 未定义的参数（如 EnterPlanMode 的 reason），导致 InputValidationError
+            const toolInput = input.tool_input || {};
+            const sanitizeRules = {
+                'EnterPlanMode': ['reason'],
+                'ExitPlanMode': ['reason'],
+                'ExitWorktree': ['reason'],
+            };
+            const fieldsToRemove = sanitizeRules[input.tool_name];
+            if (fieldsToRemove && fieldsToRemove.some((f) => f in toolInput)) {
+                const cleaned = { ...toolInput };
+                for (const f of fieldsToRemove)
+                    delete cleaned[f];
                 return {
-                    decision: 'block',
-                    reason: result.message
+                    hookSpecificOutput: {
+                        hookEventName: 'PreToolUse',
+                        permissionDecision: 'allow',
+                        updatedInput: cleaned
+                    }
                 };
             }
             return {};
         };
+        // PermissionDenied Hook - auto 模式下 SDK 拒绝操作时通知用户
+        const permissionDeniedHook = async (input) => {
+            if (this.permissionMode === 'auto' && this.sendPromptFn) {
+                const toolName = input.tool_name || '未知工具';
+                const reason = input.reason || 'AI 判断此操作有风险';
+                const message = `⚠️ 操作已自动拦截\n工具: ${toolName}\n原因: ${reason}`;
+                try {
+                    await this.sendPromptFn(message);
+                }
+                catch (err) {
+                    logger.error('[PermissionDenied] Failed to send notification:', err);
+                }
+            }
+            return {};
+        };
         // SDK-level canUseTool 回调：接入 PermissionGateway 的用户审批入口
         // 只在 SDK 认为此工具需要用户确认时触发（黑名单已在 PreToolUse hook 拦截）
         const canUseToolCallback = async (toolName, input, options) => {
-            // default 模式：一律 allow（替代有缺陷的 bypassPermissions）
-            if (this.permissionMode === 'default') {
-                return { behavior: 'allow', updatedInput: input };
+            // bypass 模式：一律 allow
+            if (this.permissionMode === 'bypass') {
+                return { behavior: 'allow', updatedInput: input, decisionClassification: 'user_permanent' };
+            }
+            // readonly 模式：二次拦截（belt-and-suspenders）
+            if (this.permissionMode === 'readonly') {
+                const roResult = checkReadonly(toolName, input, projectPath);
+                if (roResult.behavior === 'deny') {
+                    return { behavior: 'deny', message: roResult.message, decisionClassification: 'user_reject' };
+                }
+                return { behavior: 'allow', updatedInput: input, decisionClassification: 'user_permanent' };
+            }
+            // auto 模式：SDK 内置分类器自动判断，正常情况下不会触发 canUseTool 回调。
+            // 防御性兜底：确保即使 SDK 边界场景或版本变化意外调用了此回调，也不会阻塞流程。
+            if (this.permissionMode === 'auto') {
+                return { behavior: 'allow', updatedInput: input, decisionClassification: 'user_permanent' };
             }
             // 如果 PermissionGateway 未设置（如测试环境），回退到一律 allow
             if (!this.permissionGateway || !this.sendPromptFn) {
-                return { behavior: 'allow', updatedInput: input };
+                return { behavior: 'allow', updatedInput: input, decisionClassification: 'user_permanent' };
+            }
+            // always-allow 缓存命中：直接放行
+            if (this.permissionGateway.isAlwaysAllowed(toolName)) {
+                return { behavior: 'allow', updatedInput: input, decisionClassification: 'user_permanent' };
             }
             const summary = options.title
                 || options.description
                 || summarizeToolInput(toolName, input);
-            const approved = await this.permissionGateway.requestPermission(sessionId, toolName, input, this.sendPromptFn, summary, options.decisionReason);
-            return approved
-                ? { behavior: 'allow', updatedInput: input }
-                : { behavior: 'deny', message: '用户拒绝或审批超时' };
+            const decision = await this.permissionGateway.requestPermission(sessionId, toolName, input, this.sendPromptFn, this.permissionContext, summary, options.decisionReason);
+            if (decision === 'deny') {
+                return { behavior: 'deny', message: '用户拒绝或审批超时', decisionClassification: 'user_reject' };
+            }
+            return {
+                behavior: 'allow',
+                updatedInput: input,
+                decisionClassification: decision === 'always' ? 'user_permanent' : 'user_temporary'
+            };
         };
         const useSettingSources = this.config?.agents?.anthropic?.useSettingSources !== false;
         const enableSummaries = this.config?.agents?.anthropic?.agentProgressSummaries !== false;
+        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}`);
@@ -368,12 +449,15 @@ export class AgentRunner {
             cwd: projectPath,
             model: this.model,
             ...(this.effort ? { effort: this.effort } : {}),
+            autoCompactWindow: 200000,
+            advisorModel: 'haiku',
             canUseTool: canUseToolCallback,
             permissionMode: sdkPermissionMode,
             persistSession: true,
             hooks: {
                 PreCompact: [{ matcher: '.*', hooks: [preCompactHook] }],
-                PreToolUse: [{ matcher: '.*', hooks: [preToolUseHook] }]
+                PreToolUse: [{ matcher: '.*', hooks: [preToolUseHook] }],
+                PermissionDenied: [{ matcher: '.*', hooks: [permissionDeniedHook] }]
             },
             ...(enableSummaries ? { agentProgressSummaries: true } : {}),
             stderr: (msg) => {
@@ -397,6 +481,7 @@ export class AgentRunner {
                         systemPrompt: {
                             type: 'preset',
                             preset: 'claude_code',
+                            ...(excludeDynamic ? { excludeDynamicSections: true } : {}),
                             ...(systemPromptAppend ? { append: systemPromptAppend } : {})
                         },
                         ...(resumeSessionId ? { resume: resumeSessionId } : {}),
@@ -455,37 +540,25 @@ export class AgentRunner {
                 });
             }
         };
-        let lastError;
-        for (let attempt = 0; attempt < 3; attempt++) {
-            try {
-                let sdkStream;
-                if (images && images.length > 0) {
-                    logger.debug('[AgentRunner] Creating query with images, images:', images.length);
-                    logger.debug('[AgentRunner] Skipping resume for image message to avoid history conflict');
-                    const stream = new MessageStream();
-                    stream.push(prompt, images);
-                    stream.end();
-                    sdkStream = createQuery(stream);
-                }
-                else {
-                    logger.debug('[AgentRunner] Creating query with text only, agentSessionId:', initialClaudeSessionId);
-                    sdkStream = createQuery(prompt, agentSessionId);
-                }
-                // 保存 interrupt 能力（不写 activeStreams，由 registerStream 管理活跃状态）
-                if ('interrupt' in sdkStream && typeof sdkStream.interrupt === 'function') {
-                    this.interruptFns.set(sessionId, () => sdkStream.interrupt());
-                }
-                // 返回标准 AgentEvent 流
-                return this.transformStream(sdkStream, sessionId);
-            }
-            catch (error) {
-                lastError = error;
-                if (attempt < 2) {
-                    await new Promise(resolve => setTimeout(resolve, (attempt + 1) * 1000));
-                }
-            }
+        let sdkStream;
+        if (images && images.length > 0) {
+            logger.debug('[AgentRunner] Creating query with images, images:', images.length);
+            logger.debug('[AgentRunner] Skipping resume for image message to avoid history conflict');
+            const stream = new MessageStream();
+            stream.push(prompt, images);
+            stream.end();
+            sdkStream = createQuery(stream);
+        }
+        else {
+            logger.debug('[AgentRunner] Creating query with text only, agentSessionId:', initialClaudeSessionId);
+            sdkStream = createQuery(prompt, agentSessionId);
+        }
+        // 保存 interrupt 能力（不写 activeStreams，由 registerStream 管理活跃状态）
+        if ('interrupt' in sdkStream && typeof sdkStream.interrupt === 'function') {
+            this.interruptFns.set(sessionId, () => sdkStream.interrupt());
         }
-        throw lastError;
+        // 返回标准 AgentEvent 流（重试由 MessageProcessor 层负责）
+        return this.transformStream(sdkStream, sessionId);
     }
     async interrupt(sessionId) {
         const fn = this.interruptFns.get(sessionId);

package/dist/agents/codex-runner.js

@@ -38,8 +38,8 @@ export class CodexRunner {
             baseUrl: resolved.baseUrl,
         });
         this.model = resolved.model;
-        if (resolved.reasoning)
-            this.effort = resolved.reasoning;
+        if (resolved.effort)
+            this.effort = resolved.effort;
         this.onSessionIdUpdate = callbacks.onSessionIdUpdate;
     }
     // ── ModelSwitcher ──
@@ -50,11 +50,12 @@ export class CodexRunner {
     setEffort(effort) { this.effort = effort; }
     getEffort() { return this.effort; }
     // ── Permission ──
-    currentMode = 'default';
+    currentMode = 'auto';
     approvalPolicy = 'never';
     setMode(mode) {
         const map = {
-            'default': 'never',
+            'auto': 'never',
+            'bypass': 'never',
             'request': 'on-request',
             'noask': 'untrusted',
         };
@@ -64,9 +65,11 @@ export class CodexRunner {
     getMode() { return this.currentMode; }
     listModes() {
         return [
-            { key: 'default', nameZh: '默认', description: '全部自动（受 sandbox 约束）', available: true },
+            { key: 'auto', nameZh: '自动', description: '全部自动（受 sandbox 约束）', available: true },
+            { key: 'bypass', nameZh: '放行', description: '全部自动（受 sandbox 约束）', available: true },
             { key: 'request', nameZh: '审批', description: '需要审批时询问', available: true },
             { key: 'noask', nameZh: '静默', description: '只执行已知安全操作', available: true },
+            { key: 'readonly', nameZh: '只读', description: '禁止修改项目文件，可在临时目录生成文件', available: true },
         ];
     }
     setSendPrompt(_fn) { }
@@ -193,6 +196,8 @@ export class CodexRunner {
     async *transformStream(events, sessionId, thread, tempFiles) {
         try {
             for await (const event of events) {
+                if (!this.activeAbortControllers.has(sessionId))
+                    break;
                 yield* this.mapEvent(event, sessionId, thread);
             }
         }