evolcore 0.0.38 → 0.0.40

package/CHANGELOG.md

@@ -5,6 +5,70 @@
 
 ## Unreleased
 
+## 0.0.40 (2026-10-26)
+
+### Ownership 与绑定
+
+- 改进 AUN `/bind` 发起前的状态检查，已绑定、已有待处理请求或状态未确认时避免重复提交。
+- 升级 AUN SDK 最低兼容版本至 `0.5.25`，并使用 SDK 恢复和管理 Ownership 请求状态。
+- 支持宿主 CLI 通过短连接查询、接受和拒绝 Ownership 邀约，并完善本机双身份绑定与共识校验。
+- 修复 Agent 初始化期间 Owner 绑定竞态，并在初始化运行时补充 Owner 授权校验。
+- Owner 状态暂时无法刷新时按暂态故障处理；绑定类敏感操作继续要求严格共识校验并提供刷新诊断。
+
+### 会话权限与交互
+
+- 新增当前 EC 会话 Fullaccess 状态查询和开关，主会话与话题会话分别保存授权状态。
+- 增加 Fullaccess 会话授权复核和审计，并支持通过 Menu 管理当前会话设置。
+- 无人值守会话不再代替用户回答交互问题；阻塞式问题等待用户选择期间暂停回合超时计时。
+- 交互卡片可展示模型建议选项，同时保留用户最终选择；拒绝空白回答并支持显式取消。
+- 主动模式熔断后阻止新的工具调用，待当前工具调用收尾后再中断任务。
+
+### 记忆整理
+
+- 记忆整理支持按关系空闲时触发，并通过兜底扫描推进待整理任务。
+- 增加整理任务租约恢复和 SDK 超时任务恢复，减少异常中断后任务滞留。
+- 按关系范围拆分记忆泛化任务，并完善整理过程状态与审计上下文。
+
+### 状态与运维
+
+- 新增 `ec status --format json` 状态快照，汇总 daemon activity、Agent 用量、Trigger、实时队列和渠道状态。
+- 补充主机、操作系统、硬件和 baseagent 信息；文本状态输出兼容 build ID，并修正 task activity 的 Agent AID 归属。
+- 统一启动与重启流程的自动升级开关，使 `ec start`、`ec restart` 和 restart-monitor 遵循一致策略。
+
+### 错误诊断与安全
+
+- 改进受管工具调用诊断和 Codex 命令参数提取，保留原始错误原因并限制递归读取。
+- 修复受控输出过滤器对短选项连写的处理，并禁止 `grep -d` 递归读取。
+- 保留 ecagent 中断失败的底层原因，避免 AUN 错误消息重复展示诊断。
+- 修正 AUN 原始消息 payload 的话题路由传递。
+
+### AUN 与 EC Web
+
+- 修正 AUN 私聊出站模式解析，并为托管 AUN 文本、链接、图片、视频、语音和文件消息写入当前任务 ID。
+- EC Web 与 daemon 启动时协商服务协议，并改进 daemon 不可用或协议不兼容时的处理。
+- 将 EC Web Provider 管理和基础设置改由 daemon IPC 服务处理。
+- EC Web 状态页显示实时 Channels，并在受限时提供 EvolAgents 运行汇总。
+- 统一 EC Web 项目路径编码与运行时规则，迁移旧会话项目选择，修复会话页可能显示空白的问题。
+- 修复会话详情自动刷新时的滚动位置跳动。
+- 用量探索器支持按 Agent 或对端筛选，并切换查看 Token 或费用趋势；模型筛选仅展示有数据的模型。
+- 修正 EC Web 未就绪时的日志路径提示。
+- 修复 ecagent 错误或中断时持久化无效 assistant 消息的问题，并增强 OpenAI assistant 数组消息转换。
+
+## 0.0.39 (2026-10-24)
+
+### Ownership 与 Agent 初始化
+
+- 支持通过 `ec aid bind status` 查看经 SDK 验证的 Ownership 邀约，并按具体操作 ID 接受或拒绝。
+- 按绑定任务上下文校验审批结果，避免处理不相关或已失效的邀约。
+- Bootstrap 会验证本地 `agent.md`；已验签的名片不再重复发布，无效或未签名内容会阻止不安全的重发。
+- 更新 AUN Owner 欢迎文案，更清晰地介绍 Agent 可提供的帮助与个性化设置。
+
+### 权限与兼容性
+
+- 优化 Codex 在 Linux 上的文件权限规则，减少被父目录拒绝规则覆盖的冗余子规则，同时保留必要的读写例外。
+- 将 AUN SDK 最低兼容版本提升至 `0.5.23`，以支持 Ownership 邀约审批。
+- 改进 daemon IPC 连接失败诊断，相关命令现在会保留具体的连接错误信息。
+
 ## 0.0.38 (2026-10-24)
 
 ### npm 升级稳定性

package/README.md

@@ -20,7 +20,7 @@ EvolCore 是一个轻量级 AI Agent 网关系统。它为 Claude Code / Codex
 - 🧩 **Agent 多实例**：一个 JSON 文件定义一个 Agent，多 Agent 并发运行，Agent 运行时隔离 + 热重载无需重启
 - ⏰ **Trigger 自主任务**：Agent 可设置延迟/定时/周期任务，cron 表达式支持，独立 silent session 执行，支持脚本模式和 prompt 模式
 - 🔧 **Daemon 模块**：系统级后台服务，管理升级检查、全局触发器等跨 Agent 任务
-- 🎯 **Agent 启动引导**：首次启动自动引导配置 AID、owners、channels，降低上手门槛
+- 🎯 **Agent 启动引导**：首次启动自动引导配置 AID、owner、channels，降低上手门槛
 - 🎭 **主动模式策略**：proactive 模式下智能判断响应时机，群聊支持静默策略，避免无效打扰
 - 🎴 **交互卡片体系**：CommandCard + ActionInteraction，Feishu 与 AUN 统一支持
 
@@ -157,7 +157,7 @@ ec init aun
 - 渠道选择（飞书 / 微信 / 钉钉 / QQ 频道 / 企业微信 / AUN）并扫码登录
 - 默认项目路径
 - 模型选择（sonnet/opus/haiku）
-- owner 配置：默认走 **Evol App 扫码绑定**，若无 Evol App 可手工录入 AID 兜底。扫码流程只追加 owner；移除 owner 请直接编辑对应 JSON 配置。
+- AUN 协议 Owner 绑定：使用统一命令 `ec aid bind <ownerAid> [--subject <subjectAid>]`；托管会话默认当前 Agent，独立 CLI 默认 daemon Control AID。Owner 通过其 SDK 明确审批，Evol App 绑定留待二期。协议 Owner 不从 daemon/Agent 配置读取或回写；非 AUN 渠道配置保持现状。
 - 自动写入 `EVOLCORE_HOME` 到 shell profile（Unix）或用户环境变量（Windows）
 
 配置文件生成在 `{EVOLCORE_HOME}/data/daemon.json`（默认 `~/.evolcore/data/daemon.json`）。
@@ -234,8 +234,11 @@ Claude、Codex 或 EC Agent 兼容网关需要额外请求头或查询参数时
 ### Baseagent 模型与备用链
 
 Session Renew 的辅助模型配置与主模型、推理强度放在同一个
-`baseagents.<baseagent>` 块中，与 `responseMode` 正交。主模型故障备用链
-`fallbackModels` 只在 `agents/defaults.json` 中配置：
+`baseagents.<baseagent>` 块中，与 `responseMode` 正交。主模型故障备用链使用 `fallback`，
+只在 `agents/defaults.json` 中配置；每个候选可单独指定 Provider，省略时沿用主模型 Provider：
+
+示例中的 Provider ID 需先在 `providers.json` 定义；备用 Provider 必须提供与主模型相同的
+`serviceType`，例如 `backup-codex` 提供 `codex` 服务、`backup-text` 提供 `text` 服务。
 
 ```jsonc
 {
@@ -245,18 +248,28 @@ Session Renew 的辅助模型配置与主模型、推理强度放在同一个
       "effort": "medium",
       "auxiliaryModel": "claude-haiku-4-5-20251001",
       "auxiliaryEffort": "low",
-      "fallbackModels": [
+      "fallback": [
         { "model": "claude-sonnet-4-5", "effort": "medium" },
         { "model": "claude-haiku-4-5", "effort": "low" }
       ]
     },
     "codex": {
+      "provider": "company-codex",
       "model": "gpt-5.6",
       "effort": "high",
       "auxiliaryModel": "gpt-5.6-sol",
       "auxiliaryEffort": "medium",
-      "fallbackModels": [
-        { "model": "gpt-5.4", "effort": "medium" }
+      "fallback": [
+        { "provider": "backup-codex", "model": "gpt-5.4", "effort": "medium" }
+      ]
+    }
+  },
+  "Services": {
+    "auxiliary": {
+      "provider": "company-text",
+      "model": "text-primary",
+      "fallback": [
+        { "provider": "backup-text", "model": "text-backup" }
       ]
     }
   }
@@ -264,7 +277,10 @@ Session Renew 的辅助模型配置与主模型、推理强度放在同一个
 ```
 
 `auxiliaryEffort` 必须与同一 baseagent 块中的 `auxiliaryModel` 一起配置；未配置辅助模型时，
-Session Renew 按 `session_renew.fallback_action` 处理。`fallbackModels` 不会被辅助推理使用。
+Session Renew 按 `session_renew.fallback_action` 处理。`baseagents.<baseagent>.fallback` 只用于
+该 Baseagent 的主模型，不会被 Session Renew 使用。`Services.<purpose>.fallback` 则只用于该用途；
+备用项可跨 Provider，但必须使用相同的 `serviceType`。例如 `Services.auxiliary` 使用 Provider
+的 `services.text` 模型目录，Provider 不配置 `services.auxiliary`。
 
 升级旧版本时，daemon 启动前会自动把模式桶中的辅助字段迁移到对应的 baseagent 块并创建备份。
 迁移逻辑集中在 `src/config/schema-migration.ts`，运行时不会回退读取旧字段。
@@ -413,21 +429,16 @@ evolcore/
 
 ### ⚠️ 进程级 menu 操作鉴权（v3.2 Breaking）
 
-进程级 menu 操作（`/system restart/upgrade`、`/agent` agent 生命周期管理）的鉴权已迁移到
-`daemon.json` 顶层 `owners` 字段（v3.2 起，不再读 `agents/defaults.json`）。
-升级后**必须**在 `daemon.json` 配置 `owners`，否则这些操作一律返回 `FORBIDDEN`（daemon 启动时也会 warn 提示）。
+进程级管理操作的 Owner 权限来自 Control AID 的 Ownership 2.1 新鲜共识，不使用 daemon 配置中的手工 `owner/owners[]`。
 
-```json
-{
-  "owners": ["eleans-2022.agentid.pub"]
-}
+```bash
+ec aid bind <ownerAid>                 # 默认绑定 daemon Control AID
+ec aid bind status                     # 核验 Owner 共识和运行态同步
+ec aid bind <ownerAid> --subject <aid> # 指定本机 Agent AID
 ```
 
-`ec init` 交互流程会在生成控制 AID 后提示录入 owners（可跳过后手动编辑）。
-
-- **`owners`**：进程级管理者 AID 名单。可执行 `/system`（重启/升级）与 `/agent`
-  （create / delete / enable / disable / list / show）。
-- 关系级的 `/trigger`（set / cancel / update / list）仍走 channel 角色（owner/admin）+ scoped 鉴权，**不**受 `owners` 影响。
+托管 Agent 会话默认以当前 `selfAid` 为绑定主体；每个 AID 的 Owner 独立核验，daemon 权限不自动继承给 Agent。`unavailable`、断线或过期共识不会授予 Owner 权限。Evol App 绑定与非 AUN 渠道的 owner 配置不在一期范围。
+- 关系级的 `/trigger`（set / cancel / update / list）仍走 channel 角色（owner/admin）+ scoped 鉴权，**不**受 daemon `owner` 影响。
 - `/agent create` 为「受理即返回」：立即回 `{ accepted: true, aid }`，后台跑完整创建流程并把各
   环节写入 `agents/<aid>/create-status.json`；客户端用 `menu.query name=agent args={aid}` 轮询
   `createProgress.status` 直到 `ready` / `failed`。

package/bin/ec-safe-output.js

@@ -36,7 +36,9 @@ const STDOUT_FILTER_SPECS = new Map([
   // `grep` takes either `-e`/`--regexp` or one leading pattern operand. With an
   // explicit pattern option the operand budget is zero, because a bare operand
   // would be a file to read. `-r`, `-R` and `-f` are absent, so recursion and
-  // pattern files stay out.
+  // pattern files stay out. `-d recurse` is the same recursion as `-r`, so
+  // `-d`/`--directories` are absent too, along with `--include`/`--exclude`/
+  // `--exclude-dir`, which only act on recursion.
   ['grep', {
     flags: new Set([
       '-i', '--ignore-case', '-v', '--invert-match', '-c', '--count',
@@ -50,7 +52,7 @@ const STDOUT_FILTER_SPECS = new Map([
     valueOptions: new Set([
       '-m', '--max-count', '-A', '--after-context', '-B', '--before-context',
       '-C', '--context', '--color', '--colour', '--binary-files', '--label',
-      '--group-separator', '-d', '--directories', '--include', '--exclude', '--exclude-dir',
+      '--group-separator',
     ]),
     patternValueOptions: new Set(['-e', '--regexp']),
     maxOperands: 1,
@@ -253,6 +255,16 @@ function resolveFilterArgv(filterArgv) {
       continue;
     }
     if (spec.numericShorthand && /^-\d+$/.test(arg)) continue;
+    // getopt reads the rest of a short option token as its value (`-A2`,
+    // `-n30`, `-ePATTERN`). Only the leading letter counts; `-iA2` is rejected.
+    if (!arg.startsWith('--') && arg.length > 2) {
+      const shortOption = arg.slice(0, 2);
+      if (spec.patternValueOptions?.has(shortOption)) {
+        sawPatternValue = true;
+        continue;
+      }
+      if (spec.valueOptions.has(shortOption)) continue;
+    }
     const option = arg.split('=', 1)[0];
     if (spec.patternValueOptions?.has(option)) {
       sawPatternValue = true;

package/dist/agents/baseagent-availability.js

@@ -119,6 +119,7 @@ export function buildBaseagentSnapshot(config, detections, loaded) {
             model: text(blocks.get(id)?.model),
             effort: text(blocks.get(id)?.effort ?? blocks.get(id)?.reasoning),
             version: probes.get(id)?.version ?? null,
+            detectionSource: probes.get(id)?.detectionSource ?? [],
         })),
     };
 }

package/dist/agents/claude-runner.js

@@ -941,19 +941,8 @@ export class AgentRunner {
         const questions = input.questions;
         // 没有交互上下文（无渠道适配器），回退到纯文本
         const permCtx = this.permissionContexts.get(sessionId);
-        if (usesUnattendedInteractions(permCtx)) {
-            logger.info(`[AgentRunner] interaction.auto_resolved kind=ask_user session=${sessionId}`);
-            const unattendedAnswer = '当前为无人值守 Trigger，请基于已有上下文选择最安全合理的方案并继续执行。';
-            const answers = {};
-            for (const question of questions ?? []) {
-                answers[question.question] = question.multiSelect ? [unattendedAnswer] : unattendedAnswer;
-            }
-            return {
-                behavior: 'allow',
-                updatedInput: { ...input, answers },
-                decisionClassification: 'user_temporary',
-            };
-        }
+        if (usesUnattendedInteractions(permCtx))
+            throw new Error('无人值守任务不能自动回答用户问题');
         if (!permCtx?.adapter || !permCtx?.channelId) {
             return this.handleAskUserQuestionFallback(sessionId, input, questions, options);
         }
@@ -990,11 +979,15 @@ export class AgentRunner {
                         buttons: [
                             { key: 'submit', label: '✅ 确认选择', style: 'primary' },
                         ],
+                        ...(typeof q.recommendedOption === 'string'
+                            ? { recommendedOption: q.options.find(opt => opt.label === q.recommendedOption)?.label }
+                            : {}),
                         allowCustomInput: true,
                     },
                     channelId: permCtx.channelId,
                     sessionId,
                     initiatorId: permCtx.userId,
+                    blocking: true,
                 };
             }
             else {
@@ -1018,11 +1011,15 @@ export class AgentRunner {
                             label: opt.label,
                             style: 'default',
                         })),
+                        ...(typeof q.recommendedOption === 'string'
+                            ? { recommendedOption: q.options.find(opt => opt.label === q.recommendedOption)?.label }
+                            : {}),
                         allowCustomInput: true,
                     },
                     channelId: permCtx.channelId,
                     sessionId,
                     initiatorId: permCtx.userId,
+                    blocking: true,
                 };
             }
             let cardSent = false;
@@ -1048,14 +1045,7 @@ export class AgentRunner {
                 logger.warn(`[AgentRunner] AskUserQuestion card send failed for q${i}:`, err);
             }
             if (!cardSent) {
-                await permCtx.flushPending?.();
-                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;
+                throw new Error(`AskUserQuestion 卡片投递失败：${q.question}`);
             }
             try {
                 await permCtx.turn?.onInteractionOpen?.({
@@ -1063,7 +1053,6 @@ export class AgentRunner {
                     kind: 'ask_user',
                     toolUseId: options.toolUseID,
                     requestId: options.requestId,
-                    expiresAt: Date.now() + 20 * 60 * 1000,
                 });
             }
             catch (error) {
@@ -1091,7 +1080,10 @@ export class AgentRunner {
                     }
                     else if (action === '_custom_input') {
                         const customText = values?.custom_text;
-                        finish({ kind: 'answered', value: typeof customText === 'string' && customText.trim() ? customText.trim() : null });
+                        const trimmed = typeof customText === 'string' ? customText.trim() : '';
+                        if (!trimmed)
+                            return false;
+                        finish({ kind: 'answered', value: trimmed });
                     }
                     else if (action === 'submit' && q.multiSelect && values) {
                         const selected = [];
@@ -1099,15 +1091,18 @@ export class AgentRunner {
                             if (values[`opt_${idx}`] === true)
                                 selected.push(opt.label);
                         });
-                        finish({ kind: 'answered', value: selected.length > 0 ? selected : null });
+                        if (selected.length === 0)
+                            return false;
+                        finish({ kind: 'answered', value: selected });
                     }
                     else {
                         finish({ kind: 'answered', value: action });
                     }
+                    return true;
                 }, {
                     initiatorId: permCtx.userId,
                     fallbackCommand: 'ask',
-                    timeoutMs: 20 * 60 * 1000,
+                    // User questions wait until an explicit answer or cancellation.
                     onCancel: async (reason) => {
                         finish({ kind: 'cancelled', reason });
                         await cancellationClosed;
@@ -1176,6 +1171,7 @@ export class AgentRunner {
                         channelId: permCtx.channelId || '',
                         sessionId,
                         initiatorId: permCtx.userId,
+                        blocking: true,
                         kind: {
                             kind: 'action',
                             title: `💬 ${q.question}`,
@@ -1198,7 +1194,6 @@ export class AgentRunner {
                             kind: 'ask_user',
                             toolUseId: options.toolUseID,
                             requestId: options.requestId,
-                            expiresAt: Date.now() + 20 * 60 * 1000,
                         });
                     }
                     catch (error) {
@@ -1221,6 +1216,8 @@ export class AgentRunner {
                         };
                         permCtx.interactionRouter.register(requestId, sessionId, (action) => {
                             const answer = action.trim();
+                            if (!answer)
+                                return false;
                             const selectionParts = answer.split(/[,，]/).map(part => part.trim());
                             const selectedIndexes = selectionParts.map(part => Number(part));
                             const hasValidNumericSelection = selectionParts.length > 0
@@ -1240,10 +1237,10 @@ export class AgentRunner {
                             else {
                                 finish({ kind: 'answered', value: answer });
                             }
+                            return true;
                         }, {
                             initiatorId: permCtx.userId,
                             fallbackCommand: 'ask',
-                            timeoutMs: 20 * 60 * 1000,
                             onCancel: async (reason) => {
                                 finish({ kind: 'cancelled', reason });
                                 await cancellationClosed;
@@ -1283,12 +1280,7 @@ export class AgentRunner {
                     }
                 }
                 else {
-                    const firstLabel = q.options[0]?.label || '';
-                    answers[q.question] = firstLabel;
-                    if (sendPrompt) {
-                        const optText = q.options.map((o, i) => `  ${i + 1}. ${o.label}${o.description ? ` — ${o.description}` : ''}`).join('\n');
-                        await sendPrompt(`💬 ${q.question}\n${optText}\n\n  → 自动选择：${firstLabel}`);
-                    }
+                    throw new Error(`AskUserQuestion 没有可用的交互路由：${q.question}`);
                 }
             }
         }
@@ -1300,17 +1292,14 @@ export class AgentRunner {
      */
     async handleExitPlanMode(sessionId, input, options) {
         const permCtx = this.permissionContexts.get(sessionId);
-        if (usesUnattendedInteractions(permCtx)) {
-            logger.info(`[AgentRunner] interaction.auto_resolved kind=plan_approval session=${sessionId}`);
-            return { behavior: 'allow', updatedInput: input, decisionClassification: 'user_temporary' };
-        }
+        if (usesUnattendedInteractions(permCtx))
+            throw new Error('无人值守任务不能自动批准计划');
         const sendPrompt = permCtx?.adapter && permCtx?.channelId
             ? async (text) => permCtx.adapter.send(buildEnvelope({ channel: permCtx.adapter.channelName, channelId: permCtx.channelId, replyContext: permCtx.replyContext }), { kind: 'result.text', text, isFinal: true })
             : this.sendPromptFn;
         // 无任何交互能力，直接 allow
-        if (!permCtx?.channelId || !sendPrompt) {
-            return { behavior: 'allow', updatedInput: input, decisionClassification: 'user_temporary' };
-        }
+        if (!permCtx?.channelId || !sendPrompt)
+            throw new Error('计划审批没有可用的交互路由');
         // 立即暂停 idle 监控，不等卡片发完再 register
         permCtx.interactionRouter?.markWaiting(sessionId);
         const waitForPlanDecision = async (requestId) => {
@@ -1321,7 +1310,6 @@ export class AgentRunner {
                     kind: 'plan_approval',
                     toolUseId: options.toolUseID,
                     requestId: options.requestId,
-                    expiresAt: Date.now() + 20 * 60 * 1000,
                 });
             }
             catch (error) {
@@ -1369,7 +1357,6 @@ export class AgentRunner {
                 }, {
                     initiatorId: permCtx.userId,
                     fallbackCommand: 'ask',
-                    timeoutMs: 20 * 60 * 1000,
                     onCancel: async (reason) => {
                         finish({ kind: 'cancelled', reason });
                         await cancellationClosed;
@@ -1446,6 +1433,7 @@ export class AgentRunner {
                 channelId: permCtx.channelId,
                 sessionId,
                 initiatorId: permCtx.userId,
+                blocking: true,
                 fallback: {
                     command: 'ask',
                     buttonArgMap: { approve: '1', reject: '2' },
@@ -1482,6 +1470,7 @@ export class AgentRunner {
                 channelId: permCtx.channelId || '',
                 sessionId,
                 initiatorId: permCtx.userId,
+                blocking: true,
                 kind: {
                     kind: 'action',
                     title: '📋 计划审批',
@@ -1501,11 +1490,8 @@ export class AgentRunner {
             permCtx.interactionRouter.unmarkWaiting(sessionId);
             return await waitForPlanDecision(fallbackRequestId);
         }
-        // 无交互能力，发提示后直接 allow
         permCtx?.interactionRouter?.unmarkWaiting(sessionId);
-        await permCtx.flushPending?.();
-        await sendPrompt('📋 计划审批\nAI 已完成规划，自动批准执行。');
-        return { behavior: 'allow', updatedInput: input, decisionClassification: 'user_temporary' };
+        throw new Error('计划审批没有可用的交互路由，已拒绝自动批准');
     }
     /**
      * SDK 原始事件 → 标准 AgentEvent 转换

package/dist/agents/codex-runner.js

@@ -6,7 +6,7 @@ import { requestDangerousCommandPermission } from '../core/permission/approval-g
 import { checkReadonly, checkDangerousCommand, evaluateToolPreflight } from '../core/permission/tool-policy.js';
 import { isShellToolName } from '../core/permission/tool-canonical.js';
 import { normalizeExecutionPermissionMode, normalizePermissionMode, resolvePhaseOneExecutionSandbox } from '../core/permission/mode.js';
-import { assertWindowsCodexFilesystemRuleBudget, buildCodexProtectedFilesystemRules, getExistingRelationAttachmentDirs, isSameOrDescendant, resolveProtectedCandidate, } from '../core/permission/protected-paths.js';
+import { assertWindowsCodexFilesystemRuleBudget, buildCodexProtectedFilesystemRules, compactCodexLinuxFilesystemRules, getExistingRelationAttachmentDirs, isSameOrDescendant, resolveProtectedCandidate, } from '../core/permission/protected-paths.js';
 import { CODEX_THREAD_ACTIVE_WRITER, CodexAppServerClient, } from './codex/app-server-client.js';
 import { resolveOpenaiConfig, resolveCodexCliPath, resolveCodexPowerShellShimPath, } from './baseagent.js';
 import { logger } from '../utils/logger.js';
@@ -781,8 +781,9 @@ export class CodexRunner {
             ...(expectedCredentialToken !== undefined ? { expectedCredentialToken } : {}),
         };
         const classification = classifyEvolcoreShellCommand(command, parseOptions);
-        if (classification.kind === 'bounded-output')
-            return { argv: classification.command.argv };
+        if (classification.kind === 'bounded-output') {
+            return { argv: canonicalizeEvolcoreCommandArgv(classification.command.argv) };
+        }
         // Keep the approval/delegation parser aligned with the preflight parser:
         // the session-managed `$TMPDIR` token is a permitted EC path reference.
         const parsed = executable
@@ -913,7 +914,20 @@ export class CodexRunner {
                 allowManagedTmpDir: true,
                 ...(managedTempDir ? { managedTempDir } : {}),
             });
-            return classification.kind === 'composite' ? { parseFailure: outer } : {};
+            if (classification.kind === 'bounded-output'
+                && normalizeEvolcoreCommandArgv(classification.command.argv)[0] === 'ec') {
+                const argv = classification.command.argv;
+                return containsLiteralManagedTmpDirOutsideSendContent(argv) || containsUnresolvedManagedTmpDirReference(argv)
+                    ? { parseFailure: {
+                            issue: 'unsafe-expansion',
+                            offset: 0,
+                            tokenIndex: 0,
+                            dialect: 'posix',
+                            inputLength: command.length,
+                        } }
+                    : { argv: canonicalizeEvolcoreCommandArgv(argv) };
+            }
+            return { parseFailure: outer };
         }
         return {};
     }
@@ -1428,7 +1442,7 @@ export class CodexRunner {
             onlyOtherAgents: true,
         }))
             relationAttachmentDenies[directory] = 'deny';
-        const filesystem = {
+        const filesystem = compactCodexLinuxFilesystemRules({
             ...buildCodexProtectedFilesystemRules(resolveRoot(), {
                 selfAid: this.resolvedConfig.agentAid,
                 denyLClassRead: mode === 'readonly',
@@ -1455,7 +1469,7 @@ export class CodexRunner {
                 [path.join(managedTempDir, 'locks')]: 'write',
                 [path.join(managedTempDir, 'locks') + '/**']: 'write',
             } : {}),
-        };
+        });
         // Codex resolves this complete profile before serializing the Windows
         // helper payload. Check after all runner-owned additions, not merely the
         // protected-path base projection, so Git and managed-temp rules cannot
@@ -1736,6 +1750,8 @@ export class CodexRunner {
                 const policyCode = result.policyCode ?? 'session_policy_hook';
                 const reason = result.reason ?? 'session policy denied this tool call';
                 await recordPreToolUseDenial(policyCode, reason);
+                if (policyCode === 'proactive_circuit_break')
+                    context.onProactiveCircuitBreak?.();
                 return { ok: true, applicable: true, decision: 'deny', reason };
             }
             return { ok: true, applicable: true, decision: 'allow' };
@@ -3373,6 +3389,8 @@ export class CodexRunner {
                 `reason=${policyResult.reason ?? 'policy denied'} executed=false`);
             const policyCode = policyResult.policyCode ?? 'session_policy_hook';
             const policyReason = policyResult.reason ?? 'session policy denied approval';
+            if (policyCode === 'proactive_circuit_break')
+                permissionContext?.onProactiveCircuitBreak?.();
             this.rememberToolDenial(request, params, {
                 decision: 'deny',
                 decisionSource: 'policy',
@@ -3857,25 +3875,9 @@ export class CodexRunner {
     }
     async collectUserInputAnswer(sessionKey, question) {
         const options = Array.isArray(question.options) ? question.options : [];
-        const fallback = options[0]?.label ? [String(options[0].label)] : [''];
         const context = this.permissionContexts.get(sessionKey);
         if (context?.approvalInteractionPolicy === 'deny') {
-            logger.info(`[CodexRunner] interaction.auto_resolved kind=ask_user session=${sessionKey}`);
-            const labels = options
-                .map((option) => typeof option?.label === 'string' ? option.label.trim() : '')
-                .filter(Boolean);
-            if (labels.length > 0) {
-                const prompt = `${String(question.header ?? '')} ${String(question.question ?? '')}`;
-                const isPlanApproval = /\bplan\b|计划|方案/i.test(prompt);
-                const affirmative = isPlanApproval
-                    ? labels.find(label => {
-                        const kind = this.classifyMcpApprovalLabel(label);
-                        return kind === 'allow_once' || kind === 'allow_persistent';
-                    })
-                    : undefined;
-                return [affirmative ?? labels[0]];
-            }
-            return ['当前为无人值守 Trigger，请基于已有上下文选择最安全合理的方案并继续执行。'];
+            throw new Error('无人值守任务不能自动回答用户问题');
         }
         const canFreeText = question.isOther !== false || options.length === 0;
         const sendPrompt = context?.adapter && context.channelId
@@ -3887,8 +3889,8 @@ export class CodexRunner {
             : this.sendPromptFn;
         if (!context?.interactionRouter || !sendPrompt) {
             if (sendPrompt)
-                await sendPrompt(this.formatUserInputFallback(question, fallback));
-            return fallback;
+                await sendPrompt(this.formatUserInputFallback(question));
+            throw new Error('用户问题没有可用的交互路由，已拒绝自动选择');
         }
         const requestId = `codex-ask-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         const buttonArgMap = {};
@@ -3914,6 +3916,9 @@ export class CodexRunner {
                 title: String(question.header || '问题'),
                 body: bodyLines.join('\n'),
                 buttons,
+                ...(typeof question.recommendedOption === 'string'
+                    ? { recommendedOption: buttons.find(button => button.label === question.recommendedOption)?.key }
+                    : {}),
                 allowCustomInput: canFreeText,
             },
             fallback: {
@@ -3951,14 +3956,19 @@ export class CodexRunner {
         }
         if (!sent) {
             router.unmarkWaiting(sessionKey);
-            return fallback;
+            throw new Error('用户问题卡片投递失败，已拒绝自动选择');
         }
         return new Promise((resolve) => {
             router.register(requestId, sessionKey, (action, values) => {
-                resolve(this.parseUserInputAction(action, values, options, fallback));
+                const answer = this.parseUserInputAction(action, values, options, []);
+                if (answer.length === 0 || answer.every(item => !item.trim()))
+                    return false;
+                resolve(answer);
+                return true;
             }, {
                 initiatorId: context.userId,
                 fallbackCommand: 'ask',
+                retainOnRejected: true,
             });
             if (waitMarked) {
                 router.unmarkWaiting(sessionKey);
@@ -3986,13 +3996,13 @@ export class CodexRunner {
         }
         return action.trim() ? [action.trim()] : fallback;
     }
-    formatUserInputFallback(question, fallback) {
+    formatUserInputFallback(question) {
         const options = Array.isArray(question.options) ? question.options : [];
         const lines = [String(question.header || '问题'), String(question.question || '')].filter(Boolean);
         if (options.length > 0) {
             lines.push('', ...options.map((option, index) => `${index + 1}. ${String(option.label || `选项 ${index + 1}`)}${option.description ? ` — ${option.description}` : ''}`));
         }
-        lines.push('', `自动选择：${fallback.join(', ')}`);
+        lines.push('', '等待用户选择后继续。');
         return lines.join('\n');
     }
     findSessionKeyByThread(threadId, conversationId) {
@@ -5402,10 +5412,24 @@ export class CodexRunner {
                     const isError = exitCode !== undefined
                         ? exitCode !== 0
                         : item.status === 'failed' || item.status === 'declined';
+                    const rawOutput = item.aggregatedOutput ?? '';
+                    const commandStr = Array.isArray(item.command)
+                        ? item.command.join(' ')
+                        : typeof item.command === 'string' ? item.command : '';
+                    const isApplyPatchFailure = isError
+                        && /apply_patch/i.test(commandStr)
+                        && /The last line of the patch must be|Invalid patch/i.test(rawOutput);
+                    const isApplyPatchArgFailure = isError
+                        && /--codex-run-as-apply-patch requires a UTF-8 PATCH argument/i.test(rawOutput);
+                    const applyPatchHint = isApplyPatchFailure
+                        ? '\n[EvolCore 提示] apply_patch 在 Windows 上通过 .bat shim 调用时会截断多行参数，补丁末尾 *** End Patch 被丢弃。正确做法：改用 FileChange 工具直接写文件，或绕过 .bat 直接调用 codex.exe --codex-run-as-apply-patch。不要继续用 here-string 变体重试。'
+                        : isApplyPatchArgFailure
+                            ? '\n[EvolCore 提示] --codex-run-as-apply-patch 要求补丁内容通过命令行参数传入，不接受 PowerShell here-string 直接输出到 stdout 的方式。正确做法：改用 FileChange 工具直接写文件。'
+                            : '';
                     yield {
                         type: 'tool_result',
                         name: 'Shell',
-                        result: item.aggregatedOutput ?? '',
+                        result: rawOutput + applyPatchHint,
                         ...(item.aggregatedOutput != null ? { outputKind: 'combined' } : {}),
                         ...(blockedFields ?? {
                             isError,