evolcore 0.0.3 → 0.0.5

package/CHANGELOG.md

@@ -3,6 +3,89 @@
 本文件记录 EvolCore 的重要变更。EvolClaw 版本线的历史记录已归档至
 [`docs/_archive/CHANGELOG-evolclaw.md`](docs/_archive/CHANGELOG-evolclaw.md)。
 
+## 0.0.5 (2026-07-31)
+
+### 消息准入
+
+- 群聊准入统一为开放、联系人、Owner 三种行为，移除额外的渠道白名单配置。
+- 访问策略的修改权限收归 Agent Owner。
+- 完善联系人准入、拉黑与 Owner 权限边界的判定。
+- Connect 群组入口展示实时群组数量。
+
+### 运行可靠性
+
+- 修复旧版本遗留的 AUN 会话目录身份恢复：可唯一判定身份时安全迁移，无法判定时保持原样并告警。
+- 修正 Linux 容器内进程启动时间与运行时长的计算偏差。
+
+### 初始化体验
+
+- 优化初始化向导的目录输入，支持家目录简写、错误重试与显式跳过。
+- 未完成初始化时自动运行向导，完成后继续启动服务。
+- 未配置 self-agent 时按实际可用入口给出创建提示。
+
+## 0.0.4 (2026-07-30)
+
+### 联系人身份与消息准入
+
+- 联系人身份绑定统一扩展到飞书、微信、钉钉、QQ 和企业微信渠道，收敛为显式 `/bind` 命令。
+- 支持通过 AUN 私聊自助申请绑定码，并可在保留机器人配置时单独重绑渠道联系人。
+- 新增私聊入站消息准入链路，覆盖联系人申请、审批、拦截与过期处理。
+- 新增联系人请求服务，申请与状态流转改为原子操作，避免并发请求产生不一致。
+- 限制单实例和进程级待绑定请求数量，并限制无效绑定码的连续尝试次数。
+- 拒绝对不存在的联系人执行身份绑定和状态变更。
+- 群聊准入按 `access.policyMode` 分级：`open` 对所有已配置渠道开放，`contacts` 将 Agent 已加入并接收到的
+  群聊视为授权，`owners` 仅 Owner 消息开放。
+
+### 菜单与授权
+
+- 新增群组菜单协议，支持群列表查询、群级 @ 提及和群规则加载策略的查询与更新。
+- 群操作纳入权限目录、角色能力判定和审计约束，菜单与斜杠命令的可见性统一走运行时授权检查。
+- 群级策略通过版本比对和原子写入避免并发覆盖。
+- AUN 菜单增加 Evol 最低版本门禁和加密访问令牌校验。
+- 菜单令牌改为持久化哈希存储并按空闲时间失效，且不再进入追踪日志和观察转发。
+- Connect 菜单准入策略的校验与写入收敛为原子操作，补齐策略域、操作目录和内置角色的授权边界。
+
+### 跨会话协作
+
+- 跨会话消息必须显式声明 `return none` 或 `required`，Trigger 禁止使用 `required` 等待回流。
+- 聚合同一目标会话的待处理请求和同一来源身份的返回结果，避免重复触发模型轮次。
+- `ec handoff list` 输出新增 `RETURN_POLICY` 列。
+- Trigger 创建必须显式指定 `--exec script|trigger-session|target-session`，不再隐式推断。
+- 新增 `--prompt-file <path>` 承载多行或超长 prompt，与 `--prompt`、`--file` 互斥。
+
+### 安全边界
+
+- AUN keystore `encryptionSeed` 收口为内置常量，发现自定义配置立即失败关闭。
+- 为 Codex 受控命令绑定一次性委托票据，任务或会话撤销时同步清理。
+- 收紧 EC 字面量解析，按空命令、控制字符、未转义展开、引号错误和命令组合分类失败关闭。
+- Agent 角色目录从不可读 H 类调整为只读 L 类，RoleService 为唯一修改入口。
+- L-class 扩展对 `grep`、`rg`、`find`、`sed` 的安全只读支持。
+
+### 运行可靠性
+
+- 守护进程退出时冻结消息队列、关闭任务终态、等待中断屏障并保留可恢复主消息。
+- Trigger 持久化执行检查点与会话绑定，支持重启续跑、期限继承及启动并发去重。
+- 微信渠道区分连接、断开和重新认证状态，令牌刷新后重试待发送消息。
+- API 重试增加单次无事件超时，中断卡住的 runner 后继续退避重试。
+- Session Renew 判定模型改由响应模式桶的 `auxiliaryModel`/`auxiliaryEffort` 决定。
+- 直连推理凭据改为整对解析，`apiKey` 与 `baseUrl` 必须来自同一来源。
+- 入队前写入最终会话 ID 与已解析身份，执行阶段不再重新计算角色。
+- Claude Agent SDK 固定到 `0.3.220`，Codex 自动压缩阈值调整为 185000 token。
+
+### 管理界面
+
+- 会话列表新增类型徽标与筛选，消息视图展示 Agent 显示名。
+- 用量视图的模型与粒度筛选改为变更即查询，模型访问明细默认停留在“全部”。
+- 补全联系人及 AUN 群名、渠道色彩、Runner 子任务展示和 Trigger 模型归属提示。
+
+### 修复
+
+- 规范 Group Menu 非法请求的协议错误码映射。
+- 保留私聊和群聊 menu 请求的加密状态、话题信息与传输回复上下文。
+- 关联文件统一发送为标准 file 载荷，先返回 `menu.response` 再执行文件发送。
+- 统一 `agent.md` 展示名称解析与缓存，`identity` fragment 仅在名称存在时渲染 `selfName`。
+- 飞书私聊出站补齐 `replyContext.peerId` 与 `routeId` 关联。
+
 ## 0.0.3 (2026-07-25)
 
 ### 多渠道交互

package/README.md

@@ -43,7 +43,7 @@ EvolCore 是一个轻量级 AI Agent 网关系统。它为 Claude Code / Codex
 1. **消息渠道层** (`src/channels/`) - Feishu + WeChat + DingTalk + QQBot + WeCom + AUN 网络
 2. **消息队列层** (`src/core/message/message-queue.ts`) - 会话级串行处理 + 中断支持
 3. **命令处理层** (`src/core/command/`) - 斜杠命令处理（slash-handler / menu-handler / command-handler）
-4. **消息处理层** (`src/core/message/message-processor.ts`) - 统一事件处理引擎
+4. **消息处理层** (`src/core/message/response-engine.ts`) - 统一事件处理引擎
 5. **会话管理层** (`src/core/session/session-manager.ts`) - 多项目会话管理
 6. **交互路由层** (`src/core/interaction-router.ts`) - 卡片交互回调注册与路由
 7. **会话存储层** - JSONL 文件（CLI 共用）+ 文件系统（每 chat 一个目录，含 active.json / meta_*.jsonl / messages.jsonl / health.jsonl）
@@ -63,7 +63,7 @@ MessageQueue.enqueue(streamKey, message)
     ↓ 否                                    ↓
 MessageQueue.processNext()  ←──────────────┘
     ↓
-MessageProcessor.processMessage()
+ResponseEngine.processMessage()
     ↓
 ├─ 解析会话和项目路径
 ├─ 创建 StreamFlusher（3 秒批量发送）
@@ -78,12 +78,26 @@ MessageProcessor.processMessage()
 ### 环境要求
 
 - **操作系统**：macOS / Linux / Windows
-- **Node.js** >= 18
+- **Node.js** >= 22（依赖 `node:sqlite`）
 - **Claude Code** >= 2.1.32（`npm install -g @anthropic-ai/claude-code`）
 
 ### 1. 安装
 
-**npm 全局安装**（推荐）：
+**一行安装（macOS / Linux）**：
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/eLeanwang/evolcore/main/scripts/install.sh | bash
+```
+
+**Windows PowerShell**：
+
+```powershell
+irm https://raw.githubusercontent.com/eLeanwang/evolcore/main/scripts/install.ps1 | iex
+```
+
+安装器会在新实例上自动进入 `ec init` 交互向导，完成后运行 `ec start` 和 `ec status`。已有配置的升级场景会跳过自动初始化，不会停止或重启服务。详细流程见 [一键安装脚本说明](docs/evolcore-install-script.md)。
+
+**npm 全局安装**：
 
 ```bash
 npm install -g evolcore
@@ -128,7 +142,7 @@ ec init aun
 
 交互式引导完成以下配置：
 - 环境检查（Node.js >= 22、claude CLI、SDK 版本）
-- 渠道选择（飞书/微信）并扫码登录
+- 渠道选择（飞书 / 微信 / 钉钉 / QQ 频道 / 企业微信 / AUN）并扫码登录
 - 默认项目路径
 - 模型选择（sonnet/opus/haiku）
 - owner 配置：默认走 **Evol App 扫码绑定**，若无 Evol App 可手工录入 AID 兜底
@@ -207,7 +221,8 @@ evolcore/
 │   │   │   └── slash-gate.ts       # 权限前置拦截
 │   │   ├── message/
 │   │   │   ├── message-bridge.ts   # 渠道 ↔ 核心消息桥
-│   │   │   ├── message-processor.ts # 统一消息处理引擎
+│   │   │   ├── response-engine.ts  # 统一响应处理引擎
+│   │   │   ├── inbound-admission.ts # 私聊入站准入
 │   │   │   ├── message-queue.ts    # 消息队列（串行+中断）
 │   │   │   ├── message-cache.ts    # 消息缓存
 │   │   │   ├── message-log.ts      # 每 chat 的 messages.jsonl
@@ -216,11 +231,11 @@ evolcore/
 │   │   │   ├── adapters/           # 各后端会话文件适配器
 │   │   │   ├── session-fs-store.ts # 文件系统存储原语
 │   │   │   └── session-manager.ts  # 会话管理（多项目支持）
-│   │   ├── trigger/                # 触发器引擎
+│   │   ├── auth/                   # 授权审计与 Trigger 鉴权
 │   │   ├── evolagent.ts            # EvolAgent 实体
 │   │   ├── evolagent-registry.ts   # Agent 注册表（扫描/路由/热重载）
 │   │   ├── interaction-router.ts   # 卡片交互回调路由
-│   │   └── permission.ts           # 权限网关
+│   │   └── protected-paths.ts      # 受保护路径分级
 │   ├── channels/
 │   │   ├── feishu.ts               # 飞书 WebSocket 渠道
 │   │   ├── wechat.ts               # 微信 ClawBot 渠道
@@ -228,13 +243,18 @@ evolcore/
 │   │   ├── qqbot.ts                # QQ 频道渠道
 │   │   ├── wecom.ts                # 企业微信 AI Bot 渠道
 │   │   └── aun.ts                  # AUN Mesh 网络渠道
+│   ├── config/                     # 配置分层、访问策略、联系人绑定
+│   ├── eck/                        # ECK 上下文组装（manifest / kit 渲染）
+│   ├── response-system/            # 响应模式决策与参数解析
+│   ├── trigger/                    # 触发器引擎
+│   ├── stats/                      # 用量统计与计费
 │   ├── cli/                        # CLI 命令
 │   ├── utils/                      # 工具函数
 │   ├── types.ts                    # 类型定义
 │   ├── config-store.ts             # 配置加载
 │   ├── paths.ts                    # 路径解析
 │   └── index.ts                    # 主入口
-└── kits/                           # 共享上下文模板
+└── kits/                           # 共享上下文模板（rules / docs / schemas）
 ```
 
 ## 斜杠命令
@@ -252,6 +272,11 @@ evolcore/
 - `/check` - 系统健康检查（摘要）
 - `/help` - 显示所有命令
 
+**身份绑定**：
+- `/bind <6 位绑定码>` - 将当前 IM 账号绑定到已登记的联系人身份（仅私聊）。
+  支持飞书、微信、钉钉、QQ 频道、企业微信。绑定码有效期 10 分钟，可由
+  `ec init <channel>` 生成，或在目标 Agent 的 AUN 私聊发送 `/bind <channel>` 自助申请。
+
 ### 管理员级命令（Admin+ 可用）
 
 **项目**：
@@ -280,6 +305,16 @@ evolcore/
 - `/restart` - 重启服务（自愈机制）
 - `/repair` - 检查并修复会话
 
+### 联系人与关系管理（menu 协议）
+
+`/connect` 与 `/group` 是 menu 协议操作，通过 Evol App 或 EC Web 调用，不是 IM 里的斜杠命令。
+
+- **`/connect`** - 联系人与关系管理：联系人列表、群组列表、角色分配、管理员授权、拉黑状态。
+  准入策略（`connect.access.write`）为 owner 专属，角色分配与 admin 授权委派给 `role` menu 执行，
+  复用其 agent 级互斥锁、CAS revision 与审计链。
+- **`/group`** - 群组管理：群列表、群级 @ 提及策略、群规则加载策略的查询与更新。
+  群操作纳入权限目录与角色能力判定，通过版本比对和原子写入避免并发覆盖。
+
 ### ⚠️ 进程级 menu 操作鉴权（v3.2 Breaking）
 
 进程级 menu 操作（`/system restart/upgrade`、`/agent` agent 生命周期管理）的鉴权已迁移到
@@ -309,7 +344,7 @@ v3.2 新增进程级身份标识。启动时自动生成 `ec+5位数字.agentid.
 ## 技术栈
 
 - **运行时**：Node.js >= 22 + TypeScript（ES modules）
-- **AI 后端**：@anthropic-ai/claude-agent-sdk >= 0.3.211、Codex CLI app-server、Gemini CLI
+- **AI 后端**：@anthropic-ai/claude-agent-sdk 0.3.220（固定版本）、Codex CLI app-server、Gemini CLI
 - **消息渠道**：飞书（@larksuiteoapi/node-sdk）、微信（ClawBot ilink API）、钉钉（dingtalk-stream）、QQ频道（pure-qqbot）、企业微信（AI Bot API）、AUN 网络
 - **数据存储**：文件系统（per-chat 目录） + JSONL（CLI 共用）
 - **测试框架**：Vitest

package/bin/ec-safe-output.js

@@ -6,6 +6,13 @@ import { spawn } from 'child_process';
 const MAX_OUTPUT_BYTES = 1024 * 1024;
 const EC_EXECUTABLES = new Set(['ec']);
 const HOST_PROCESS_EXECUTABLES = new Set(['ps', 'pgrep', 'pidof', 'kill', 'pkill', 'killall']);
+const HEAD_EXECUTABLE = ['/usr/bin/head', '/bin/head'].find(candidate => {
+  try {
+    return fs.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+});
 
 function fail(message) {
   process.stderr.write(`ec-safe-output: ${message}\n`);
@@ -34,6 +41,33 @@ function validateCommand(payload) {
   return !payload.argv.some(arg => /\bnode(?:js|\.exe)?\b/i.test(arg));
 }
 
+function validateStdinOnlyHeadArgs(args) {
+  if (args === undefined) return true;
+  if (!Array.isArray(args) || args.some(arg => typeof arg !== 'string')) return false;
+  let optionsEnded = false;
+  let expectsOptionValue = false;
+  for (const arg of args) {
+    if (expectsOptionValue) {
+      expectsOptionValue = false;
+      continue;
+    }
+    if (optionsEnded) {
+      if (arg !== '-') return false;
+      continue;
+    }
+    if (arg === '--') {
+      optionsEnded = true;
+      continue;
+    }
+    if (arg === '-') continue;
+    if (!arg.startsWith('-')) return false;
+    if (arg === '-n' || arg === '-c' || arg === '--lines' || arg === '--bytes') {
+      expectsOptionValue = true;
+    }
+  }
+  return true;
+}
+
 function resolveExecutionPaths(payload) {
   if (typeof payload.workspace !== 'string' || typeof payload.cwd !== 'string') fail('invalid workspace');
   let workspace;
@@ -87,36 +121,19 @@ function openOutputFile(payload, paths) {
 const payload = decodePayload(process.argv[2]);
 if (!payload) fail('invalid payload');
 if (!validateCommand(payload)) fail('command is not permitted');
-if (payload.headLines !== undefined
-  && (!Number.isSafeInteger(payload.headLines) || payload.headLines < 1 || payload.headLines > 10_000)) {
-  fail('invalid head line limit');
-}
+if (!validateStdinOnlyHeadArgs(payload.headArgs)) fail('head may only consume stdin');
+if (payload.headArgs !== undefined && !HEAD_EXECUTABLE) fail('trusted head executable is unavailable');
 
 const paths = resolveExecutionPaths(payload);
 const output = openOutputFile(payload, paths);
 let bytesWritten = 0;
-let linesWritten = 0;
 let limitReached = false;
 let writeFailed = false;
 
 function writeLimited(chunk) {
   if (limitReached || writeFailed) return;
   const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-  let allowed = Math.min(buffer.length, MAX_OUTPUT_BYTES - bytesWritten);
-  if (payload.headLines !== undefined) {
-    let cursor = 0;
-    while (cursor < allowed) {
-      const newline = buffer.indexOf(0x0a, cursor);
-      if (newline < 0 || newline >= allowed) break;
-      linesWritten++;
-      cursor = newline + 1;
-      if (linesWritten >= payload.headLines) {
-        allowed = cursor;
-        limitReached = true;
-        break;
-      }
-    }
-  }
+  const allowed = Math.min(buffer.length, MAX_OUTPUT_BYTES - bytesWritten);
   if (allowed <= 0) {
     limitReached = true;
     return;
@@ -132,13 +149,35 @@ function writeLimited(chunk) {
   }
 }
 
+const head = payload.headArgs === undefined
+  ? undefined
+  : spawn(HEAD_EXECUTABLE, payload.headArgs, {
+      cwd: paths.cwd,
+      env: process.env,
+      stdio: ['pipe', 'pipe', 'inherit'],
+    });
+if (head) {
+  head.stdout.on('data', writeLimited);
+  // Early-exit options such as --help or a small -n/-c close stdin before the
+  // EC process finishes. Ignore EPIPE and keep draining EC output below.
+  head.stdin.on('error', () => {});
+}
+
 const child = spawn(payload.argv[0], payload.argv.slice(1), {
   cwd: paths.cwd,
   env: process.env,
   stdio: ['ignore', 'pipe', payload.mergeStderr ? 'pipe' : 'inherit'],
 });
-child.stdout.on('data', writeLimited);
-if (payload.mergeStderr) child.stderr.on('data', writeLimited);
+const sourceStreams = [child.stdout, ...(payload.mergeStderr ? [child.stderr] : [])];
+if (head) {
+  for (const stream of sourceStreams) {
+    // The no-op data listener keeps draining the source if head exits early.
+    stream.on('data', () => {});
+    stream.pipe(head.stdin, { end: false });
+  }
+} else {
+  for (const stream of sourceStreams) stream.on('data', writeLimited);
+}
 
 child.once('error', error => {
   if (output) {
@@ -148,7 +187,13 @@ child.once('error', error => {
   fail(`unable to start command: ${error.message}`);
 });
 
-child.once('close', code => {
+let sourceClosed = false;
+let sourceCode = 1;
+let headClosed = !head;
+let headCode = 1;
+
+function finish() {
+  if (!sourceClosed || !headClosed) return;
   if (output) {
     try { fs.closeSync(output.fd); } catch { writeFailed = true; }
   }
@@ -157,5 +202,25 @@ child.once('close', code => {
     fail('failed to write command output');
   }
   if (output) process.stderr.write(`Saved output to ${output.target}\n`);
-  process.exitCode = code ?? 1;
+  process.exitCode = head ? headCode : sourceCode;
+}
+
+if (head) {
+  head.once('error', error => {
+    writeFailed = true;
+    process.stderr.write(`ec-safe-output: unable to start head: ${error.message}\n`);
+  });
+  head.once('close', code => {
+    headCode = code ?? 1;
+    headClosed = true;
+    for (const stream of sourceStreams) stream.unpipe(head.stdin);
+    finish();
+  });
+}
+
+child.once('close', code => {
+  sourceCode = code ?? 1;
+  sourceClosed = true;
+  if (head && !head.stdin.destroyed) head.stdin.end();
+  finish();
 });

package/dist/agents/baseagent.js

@@ -32,6 +32,22 @@ export function normalizeBaseagent(input) {
     const key = String(input || '').trim().toLowerCase().replace(/_/g, '-');
     return BASEAGENT_ALIASES[key] || { canonical: 'unknown', displayName: input ? String(input) : 'Unknown' };
 }
+function directInferencePair(apiKey, baseUrl) {
+    const normalizedApiKey = directInferenceValue(apiKey);
+    const normalizedBaseUrl = directInferenceValue(baseUrl);
+    if (!normalizedApiKey || !normalizedBaseUrl)
+        return undefined;
+    return { apiKey: normalizedApiKey, baseUrl: normalizedBaseUrl };
+}
+function directInferenceValue(...values) {
+    for (const value of values) {
+        const normalized = value?.trim();
+        const lower = normalized?.toLowerCase();
+        if (normalized && !lower?.includes('your-') && !lower?.includes('placeholder'))
+            return normalized;
+    }
+    return undefined;
+}
 function loadClaudeSettings() {
     try {
         const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
@@ -42,6 +58,21 @@ function loadClaudeSettings() {
     catch { }
     return {};
 }
+/**
+ * Resolve a complete credential/endpoint pair for direct Anthropic HTTP calls.
+ * A pair must come from one source so partial configuration cannot be mixed
+ * across Agent config, the process environment, and Claude Code settings.
+ */
+export function resolveAnthropicDirectConfig(override) {
+    const explicit = directInferencePair(override?.apiKey, override?.baseUrl);
+    if (explicit)
+        return explicit;
+    const environment = directInferencePair(directInferenceValue(process.env.ANTHROPIC_AUTH_TOKEN, process.env.ANTHROPIC_API_KEY), process.env.ANTHROPIC_BASE_URL);
+    if (environment)
+        return environment;
+    const settings = loadClaudeSettings();
+    return directInferencePair(directInferenceValue(settings.env?.ANTHROPIC_AUTH_TOKEN, settings.env?.ANTHROPIC_API_KEY), settings.env?.ANTHROPIC_BASE_URL);
+}
 export function resolveAnthropicConfig(config, override) {
     const settings = loadClaudeSettings();
     const isPlaceholder = (v) => !v || v.includes('your-') || v.includes('placeholder');
@@ -103,6 +134,21 @@ function loadCodexSettings() {
     catch { }
     return {};
 }
+/**
+ * Resolve a complete credential/endpoint pair for direct OpenAI HTTP calls.
+ * auth.json and config.toml together form the Codex SDK source; fields are
+ * never combined with a partial Agent or process-environment configuration.
+ */
+export function resolveOpenaiDirectConfig(override) {
+    const explicit = directInferencePair(override?.apiKey, override?.baseUrl);
+    if (explicit)
+        return explicit;
+    const environment = directInferencePair(process.env.OPENAI_API_KEY, process.env.OPENAI_BASE_URL);
+    if (environment)
+        return environment;
+    const settings = loadCodexSettings();
+    return directInferencePair(settings.apiKey, settings.baseUrl);
+}
 export function resolveOpenaiConfig(config, override) {
     const codexSettings = loadCodexSettings();
     const isPlaceholder = (v) => !v || v.includes('your-') || v.includes('placeholder');

package/dist/agents/claude-runner.js

@@ -855,20 +855,6 @@ export class AgentRunner {
                         const customText = values?.custom_text;
                         finish({ kind: 'answered', value: typeof customText === 'string' && customText.trim() ? customText.trim() : null });
                     }
-                    else if (action === '_show_input') {
-                        if (permCtx?.interceptNextMessage) {
-                            permCtx.interactionRouter?.markWaiting(sessionId);
-                            sendPrompt?.('✏️ 请直接发送你的自定义回复').catch(() => { });
-                            permCtx.interceptNextMessage(sessionId, (msg) => {
-                                permCtx.interactionRouter?.unmarkWaiting(sessionId);
-                                const text = (msg.content || '').trim();
-                                finish({ kind: 'answered', value: text || null });
-                            });
-                        }
-                        else {
-                            finish({ kind: 'cancelled', reason: 'explicit_cancel' });
-                        }
-                    }
                     else if (action === 'submit' && q.multiSelect && values) {
                         const selected = [];
                         q.options.forEach((opt, idx) => {
@@ -900,7 +886,6 @@ export class AgentRunner {
             });
             if (settlement.kind === 'cancelled') {
                 try {
-                    permCtx.cancelIntercept?.(sessionId);
                     try {
                         await permCtx.turn?.onInteractionSettled?.(requestId, settlement.reason === 'timeout' ? 'timed_out' : 'cancelled');
                     }
@@ -1133,20 +1118,6 @@ export class AgentRunner {
                         const feedback = typeof values?.custom_text === 'string' ? values.custom_text.trim() : '';
                         deny(feedback || '用户提交了反馈');
                     }
-                    else if (trimmed === '_show_input') {
-                        if (permCtx.interceptNextMessage) {
-                            router.markWaiting(sessionId);
-                            sendPrompt?.('✏️ 请直接发送你的反馈意见').catch(() => { });
-                            permCtx.interceptNextMessage(sessionId, msg => {
-                                router.unmarkWaiting(sessionId);
-                                const feedback = (msg.content || '').trim();
-                                deny(feedback || '用户提交了反馈');
-                            });
-                        }
-                        else {
-                            deny('用户提交了反馈');
-                        }
-                    }
                     else if (trimmed === '2' || trimmed.toLowerCase() === 'reject' || trimmed === '拒绝') {
                         deny('用户拒绝了计划');
                     }
@@ -1173,7 +1144,6 @@ export class AgentRunner {
             });
             try {
                 if (settlement.kind === 'cancelled') {
-                    permCtx.cancelIntercept?.(sessionId);
                     try {
                         await permCtx.turn?.onInteractionSettled?.(requestId, settlement.reason === 'timeout' ? 'timed_out' : 'cancelled');
                     }
@@ -1886,7 +1856,7 @@ export class AgentRunner {
             }
             // These tools need the dedicated canUseTool interaction handlers below.
             if (toolName === 'AskUserQuestion' || toolName === 'ExitPlanMode') {
-                return hookDecision('defer', undefined, updatedInput);
+                return hookDecision('ask', undefined, updatedInput);
             }
             if (callPermissionMode === 'readonly') {
                 const permCtx = this.permissionContexts.get(sessionId);

package/dist/agents/codex-app-server-client.js

@@ -167,6 +167,74 @@ export class CodexAppServerClient {
         await this.request('thread/metadata/update', params);
         return true;
     }
+    async threadShellCommand(threadId, command, timeoutMs = 10_000) {
+        let commandItemId;
+        let output = '';
+        let settle;
+        let fail;
+        const completion = new Promise((resolve, reject) => {
+            settle = resolve;
+            fail = reject;
+        });
+        const unsubscribe = this.onNotification(notification => {
+            const params = (notification.params || {});
+            const notificationThreadId = params.threadId ?? params.thread_id;
+            if (notificationThreadId !== threadId)
+                return;
+            const item = params.item && typeof params.item === 'object'
+                ? params.item
+                : undefined;
+            const itemId = typeof item?.id === 'string'
+                ? item.id
+                : typeof params.itemId === 'string'
+                    ? params.itemId
+                    : undefined;
+            const source = item?.source;
+            const isUserShell = source === 'userShell' || source === 'user_shell';
+            if (notification.method === 'item/started'
+                && item?.type === 'commandExecution'
+                && isUserShell
+                && (item.command === command || commandItemId === undefined)) {
+                commandItemId = itemId;
+                return;
+            }
+            if (notification.method === 'item/commandExecution/outputDelta'
+                && commandItemId
+                && itemId === commandItemId
+                && typeof params.delta === 'string') {
+                output += params.delta;
+                return;
+            }
+            if (notification.method === 'item/completed'
+                && item?.type === 'commandExecution'
+                && isUserShell
+                && (!commandItemId || itemId === commandItemId)) {
+                const aggregated = typeof item.aggregatedOutput === 'string'
+                    ? item.aggregatedOutput
+                    : typeof item.aggregated_output === 'string'
+                        ? item.aggregated_output
+                        : output;
+                const exitCode = typeof item.exitCode === 'number'
+                    ? item.exitCode
+                    : typeof item.exit_code === 'number'
+                        ? item.exit_code
+                        : undefined;
+                settle({ output: aggregated, ...(exitCode !== undefined ? { exitCode } : {}) });
+            }
+        });
+        const timer = setTimeout(() => {
+            fail(new Error(`thread/shellCommand timed out for thread ${threadId}`));
+        }, timeoutMs);
+        timer.unref?.();
+        try {
+            await this.request('thread/shellCommand', { threadId, command });
+            return await completion;
+        }
+        finally {
+            clearTimeout(timer);
+            unsubscribe();
+        }
+    }
     async turnInterrupt(threadId, turnId) {
         await this.request('turn/interrupt', { threadId, turnId });
         return true;