lark-remote 0.1.7 → 0.1.9

package/dist/router/utils.js

@@ -80,6 +80,16 @@ export function formatUsageStats(usage, options) {
     const cumTotalSuffix = usage?.cumulativeTotalTokens !== undefined
         ? ` · 累计 ${formatTokenK(usage.cumulativeTotalTokens)}`
         : '';
+    // 一致性护栏：本 run ≤ 累计 是硬不变量（累计 = 所有 run 之和，必 ≥ 本 run）。
+    // 违反说明来源 scope 混用（如 DeepSeek live result usage 是累积/超大 scope，
+    // 大于 jsonl 去重聚合的 session 累计）。只标记不修正——数字保持原样便于排查，
+    // 由数据源修复。两侧都有值时校验（避免旧数据/缺失字段误报）。
+    // 两个分支（real input/output / 10% 估计）共用，保证"本 run > 累计"在任意
+    // 路径都显式暴露。
+    const withCumGuard = (totalTokens) => cumTotalSuffix +
+        (usage?.cumulativeTotalTokens !== undefined && totalTokens > usage.cumulativeTotalTokens
+            ? ' · ⚠️ 累计异常'
+            : '');
     // 计算累计 cache 命中率
     const cumInput = usage?.cumulativeInputTokens;
     const cumCacheRead = usage?.cumulativeCacheReadTokens;
@@ -110,7 +120,7 @@ export function formatUsageStats(usage, options) {
             lines.push(`Cache create - ${formatTokenK(cacheCreation)}${cumCacheCreateSuffix}`);
         }
         lines.push(`Cached token - ${formatTokenK(cacheRead)} (${cachePercent}%)${cumCacheReadSuffix}`);
-        lines.push(`Total token - ${formatTokenK(totalTokens)}${cumTotalSuffix}`);
+        lines.push(`Total token - ${formatTokenK(totalTokens)}${withCumGuard(totalTokens)}`);
     }
     else {
         // Estimate path: when real input/output are absent,
@@ -127,7 +137,7 @@ export function formatUsageStats(usage, options) {
                 lines.push(`Cache create - ${formatTokenK(cacheCreation)}${cumCacheCreateSuffix}`);
             }
             lines.push(`Cached token - ${formatTokenK(cacheRead)} (${cachePercent}%)${cumCacheReadSuffix}`);
-            lines.push(`Total token - ${formatTokenK(totalTokens)}${cumTotalSuffix}`);
+            lines.push(`Total token - ${formatTokenK(totalTokens)}${withCumGuard(totalTokens)}`);
         }
     }
     return lines.join('\n');

package/dist/runner/agent-choices-common.js

@@ -23,6 +23,9 @@ export const AGENT_CHOICE_FIELDS = {
         { configKey: 'model', choicesKey: 'model' },
         { configKey: 'thinkingEffort', choicesKey: 'thinkingEffort' },
     ],
+    // DSH has no model/provider choice fields (host endpoint is connection
+    // config, not a per-run choice) — empty to satisfy the Record type.
+    dsh: [],
 };
 /** 返回指定 agent 的字段映射；claude 或未知 agent 返回 undefined。 */
 export function choiceFieldsFor(agent) {

package/dist/runner/claude/runner.js

@@ -102,6 +102,28 @@ export class ClaudeRunner {
                 this.session.setAutoApprove(true);
                 await this.session.respondPermission(requestId, { behavior: 'allow' });
                 return;
+            case 'accept_with_feedback': {
+                // 计划审批「批准并采纳修改」：allow + updatedInput.plan（改写过的新计划），
+                // 触发 Claude 侧 planWasEdited → tool_result 回显 edited plan 并写回文件。
+                const plan = response.plan;
+                if (!plan || !plan.trim()) {
+                    throw new Error('approval accept_with_feedback missing plan payload');
+                }
+                await this.session.respondPermission(requestId, {
+                    behavior: 'allow',
+                    updatedInput: { plan },
+                });
+                return;
+            }
+            case 'decline_with_feedback': {
+                // 计划审批「拒绝并附意见」：deny + message，Claude 留在 plan 模式修订。
+                const message = response.message?.trim();
+                if (!message) {
+                    throw new Error('approval decline_with_feedback missing message payload');
+                }
+                await this.session.respondPermission(requestId, { behavior: 'deny', message });
+                return;
+            }
             case 'decline':
                 await this.session.respondPermission(requestId, { behavior: 'deny' });
                 return;

package/dist/runner/claude/session.d.ts

@@ -46,6 +46,11 @@ export interface ClaudeSessionOptions {
 export interface PermissionResult {
     behavior: 'allow' | 'deny';
     message?: string;
+    /**
+     * allow 时显式覆盖 updatedInput（默认回写 pendingToolInputs 原始 input）。
+     * 计划审批「批准并采纳修改意见」用它携带改写的 plan。
+     */
+    updatedInput?: unknown;
 }
 /**
  * ClaudeSession extends SpawningRunner 复用其 spawn/pid 文件/killOrphan/
@@ -74,6 +79,12 @@ export declare class ClaudeSession extends SpawningRunner {
     private waitResolve;
     /** 待审批的 control_request 原始 input（回写 updatedInput 需要）。 */
     private pendingToolInputs;
+    /**
+     * 本会话内跟踪到的计划文件路径：Write/Edit 工具把文件写到 `plans` 目录
+     * 时记录（ExitPlanMode 的 plan 内容不总是经 input 注入，文件是可靠兜底）。
+     * 会话进程生命周期内有效（长驻进程 = 一个会话）。
+     */
+    private planFilePath;
     /** 允许所有：后续 control_request 自动 allow（本会话进程生命周期内有效）。 */
     private autoApprove;
     /** 串行化 stdin 写入（用户消息与审批响应交错到达）。 */
@@ -160,6 +171,21 @@ export declare class ClaudeSession extends SpawningRunner {
      */
     private writeStdin;
     private translateEvent;
+    /**
+     * 跟踪会话内 Write/Edit 工具写到 `plans` 目录的文件路径：CLI 对
+     * ExitPlanMode 的 plan 注入不稳定（input.plan 时有时无），但模型被要求
+     * 先把计划写入计划文件，路径可经工具调用可靠捕获（含模型写错目录的
+     * 退化场景——渲染层可展示实际落盘位置）。
+     */
+    private trackPlanFilePath;
+    /**
+     * ExitPlanMode 计划解析，优先级：
+     * 1. control_request input.plan（CLI normalizeToolInput 从磁盘注入，非稳定）；
+     * 2. input.planFilePath 指向的文件；
+     * 3. 会话内 Write/Edit 跟踪到的计划文件。
+     * 全部落空时返回空对象，渲染层展示「未获取到计划文件内容」兜底。
+     */
+    private resolvePlanContent;
     private translateControlRequest;
     /** 统一方案：所有 runner 自己生成 timestamp（缺失时补）。 */
     private withTimestamp;

package/dist/runner/claude/session.js

@@ -27,13 +27,17 @@
  * 进程在 turn 之间保持存活（stdin 不关闭），/stop / /new / /cd / 看门狗超时
  * 时经 ProcessStopper 组杀，下条消息按 SessionStore 的 sessionId --resume。
  */
+import { readFile } from 'node:fs/promises';
 import { silentlyUnlink } from '../../common/fs.js';
 import { getLogger } from '../../logger/index.js';
 import { SpawningRunner } from '../common/spawning-runner.js';
 import { pipeAllStdio } from '../common/runner-utils.js';
 import { authErrorEvent, syntheticInitEvent } from '../common/runner-utils.js';
+import { makeQuestionApprovalEvent } from '../question-common.js';
 /** 拒绝权限时的默认提示（进入 claude 上下文，中文用户可读）。 */
 const DENY_MESSAGE = '用户拒绝了此工具调用，请停止并等待用户指令。';
+/** ExitPlanMode 计划文件读取上限（超出截断，防超大计划拖垮事件翻译）。 */
+const MAX_PLAN_CHARS = 60_000;
 /** 会话级空闲回收默认 TTL（对齐 codex appServer.idleTtlMs 默认 30 分钟）。 */
 const DEFAULT_IDLE_TTL_MS = 30 * 60 * 1000;
 /** result 事件里表示「turn 中途压缩」的 subtype（不是 turn 结束）。 */
@@ -65,6 +69,12 @@ export class ClaudeSession extends SpawningRunner {
     waitResolve = null;
     /** 待审批的 control_request 原始 input（回写 updatedInput 需要）。 */
     pendingToolInputs = new Map();
+    /**
+     * 本会话内跟踪到的计划文件路径：Write/Edit 工具把文件写到 `plans` 目录
+     * 时记录（ExitPlanMode 的 plan 内容不总是经 input 注入，文件是可靠兜底）。
+     * 会话进程生命周期内有效（长驻进程 = 一个会话）。
+     */
+    planFilePath = '';
     /** 允许所有：后续 control_request 自动 allow（本会话进程生命周期内有效）。 */
     autoApprove = false;
     /** 串行化 stdin 写入（用户消息与审批响应交错到达）。 */
@@ -181,7 +191,9 @@ export class ClaudeSession extends SpawningRunner {
         if (result.behavior === 'allow') {
             await this.writeControlResponse(requestId, {
                 behavior: 'allow',
-                updatedInput: input ?? {},
+                // 显式 updatedInput 优先（计划审批「批准并采纳修改」携带改写 plan）；
+                // 缺省回写原始 input，保证其他工具审批行为不变。
+                updatedInput: result.updatedInput !== undefined ? result.updatedInput : (input ?? {}),
             });
         }
         else {
@@ -343,7 +355,7 @@ export class ClaudeSession extends SpawningRunner {
                 for await (const raw of stream) {
                     if (generation !== this.processGeneration)
                         return; // 旧进程残留事件丢弃
-                    const events = this.translateEvent(raw);
+                    const events = await this.translateEvent(raw);
                     if (events.length > 0) {
                         this.eventQueue.push(...events);
                         this.wakeWaiters();
@@ -529,7 +541,7 @@ export class ClaudeSession extends SpawningRunner {
     // =========================================================================
     // Internal: event translation
     // =========================================================================
-    translateEvent(raw) {
+    async translateEvent(raw) {
         const event = raw;
         const type = event.type;
         // review P3-3：--resume 会先重放上一轮历史事件（旧 result 之外还可能有
@@ -537,6 +549,10 @@ export class ClaudeSession extends SpawningRunner {
         // 内容混进当前卡片（result 分支的 sawInit 守卫升级为全类型守卫）。
         if (type !== 'system' && !this.sawInit)
             return [];
+        // 跟踪会话内计划文件写入（ExitPlanMode 审批卡的 plan 文件兜底）。
+        if (type === 'assistant') {
+            this.trackPlanFilePath(event);
+        }
         if (type === 'control_request') {
             return this.translateControlRequest(event);
         }
@@ -587,7 +603,63 @@ export class ClaudeSession extends SpawningRunner {
         // 下游 reducer 忽略，保留诊断价值。
         return [this.withTimestamp(event)];
     }
-    translateControlRequest(raw) {
+    /**
+     * 跟踪会话内 Write/Edit 工具写到 `plans` 目录的文件路径：CLI 对
+     * ExitPlanMode 的 plan 注入不稳定（input.plan 时有时无），但模型被要求
+     * 先把计划写入计划文件，路径可经工具调用可靠捕获（含模型写错目录的
+     * 退化场景——渲染层可展示实际落盘位置）。
+     */
+    trackPlanFilePath(raw) {
+        const content = raw.message?.content;
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            const b = block;
+            if (b?.type !== 'tool_use')
+                continue;
+            if (b.name !== 'Write' && b.name !== 'Edit')
+                continue;
+            const fp = b.input?.file_path;
+            if (typeof fp === 'string' && fp.includes('/plans/')) {
+                this.planFilePath = fp;
+            }
+        }
+    }
+    /**
+     * ExitPlanMode 计划解析，优先级：
+     * 1. control_request input.plan（CLI normalizeToolInput 从磁盘注入，非稳定）；
+     * 2. input.planFilePath 指向的文件；
+     * 3. 会话内 Write/Edit 跟踪到的计划文件。
+     * 全部落空时返回空对象，渲染层展示「未获取到计划文件内容」兜底。
+     */
+    async resolvePlanContent(input, trackedPath) {
+        const direct = typeof input.plan === 'string' && input.plan.trim() ? input.plan : undefined;
+        if (direct !== undefined) {
+            // 计划已随 input 注入时仍携带文件路径（input.planFilePath 或会话内跟踪），
+            // 供卡片展示「计划落盘位置」。
+            const filePath = typeof input.planFilePath === 'string' && input.planFilePath
+                ? input.planFilePath
+                : trackedPath;
+            return filePath ? { plan: direct, planFilePath: filePath } : { plan: direct };
+        }
+        const candidate = typeof input.planFilePath === 'string' && input.planFilePath
+            ? input.planFilePath
+            : trackedPath;
+        if (!candidate)
+            return {};
+        try {
+            const content = await readFile(candidate, 'utf8');
+            const trimmed = content.trim();
+            if (trimmed) {
+                return { plan: trimmed.slice(0, MAX_PLAN_CHARS), planFilePath: candidate };
+            }
+        }
+        catch {
+            // 计划文件缺失/不可读：fall through，渲染层兜底。
+        }
+        return {};
+    }
+    async translateControlRequest(raw) {
         const requestId = raw.request_id;
         if (requestId === null || requestId === undefined) {
             getLogger().warn(`[${this.logTag}] control_request missing request_id, dropping`);
@@ -639,17 +711,36 @@ export class ClaudeSession extends SpawningRunner {
                 this.pendingToolInputs.delete(requestId);
                 return [];
             }
+            return [makeQuestionApprovalEvent(requestId, questions, this.sessionId)];
+        }
+        // ExitPlanMode：计划已写入计划文件（或经 input.plan 注入）。没有 command
+        // 语义，塞进 command 槽位会显示无意义 `{}` → 用独立 tool kind，把计划
+        // 全文 + 文件路径带给渲染层，决策对齐 TUI 四种交互。
+        if (toolName === 'ExitPlanMode') {
+            const resolved = await this.resolvePlanContent(input, this.planFilePath);
             const view = {
                 requestId,
-                kind: 'question',
-                questions,
-                availableDecisions: [],
+                kind: 'tool',
+                toolName,
+                reason: typeof request.description === 'string' ? request.description : undefined,
+                ...(resolved.plan !== undefined ? { plan: resolved.plan } : {}),
+                ...(resolved.planFilePath !== undefined ? { planFilePath: resolved.planFilePath } : {}),
+                // 对齐 TUI：批准并执行 / 批准并自动放行（acceptAll）/ 拒绝并附意见 /
+                // 批准并采纳修改 / 拒绝。
+                availableDecisions: [
+                    'accept',
+                    'acceptAll',
+                    'declineWithFeedback',
+                    'acceptWithFeedback',
+                    'decline',
+                ],
             };
+            getLogger().info(`[${this.logTag}] permission request requestId=${requestId} tool=${toolName}`);
             return [
                 {
                     type: 'approval_requested',
                     requestId,
-                    kind: 'question',
+                    kind: 'tool',
                     threadId: this.sessionId,
                     turnId: '',
                     itemId: '',
@@ -658,7 +749,12 @@ export class ClaudeSession extends SpawningRunner {
                 },
             ];
         }
-        const command = typeof input.command === 'string' ? input.command : JSON.stringify(input ?? {});
+        // 非命令工具的兜底防御：input 无 command 字段时 JSON 序列化，但空对象
+        // 序列化成 `{}` 对用户无意义——内容为空时回退展示工具名（review P3-5）。
+        const rawCommand = typeof input.command === 'string' ? input.command : JSON.stringify(input);
+        const command = rawCommand && rawCommand !== '{}' && rawCommand !== 'null'
+            ? rawCommand
+            : toolName || '(unknown tool)';
         const view = {
             requestId,
             kind: 'command',

package/dist/runner/codex/app-server/protocol-types.d.ts

@@ -83,6 +83,8 @@ export interface ThreadResumeParams {
     modelProvider?: string | null;
     approvalPolicy?: AskForApproval;
     sandbox?: SandboxMode;
+    /** Configuration overrides for the resumed thread (codex v2 wire field). */
+    config?: Record<string, unknown> | null;
 }
 export interface ThreadResumeResponse {
     thread: Thread;
@@ -432,6 +434,7 @@ export declare const ServerRequestMethod: {
     readonly COMMAND_EXECUTION_APPROVAL: "item/commandExecution/requestApproval";
     readonly FILE_CHANGE_APPROVAL: "item/fileChange/requestApproval";
     readonly PERMISSIONS_APPROVAL: "item/permissions/requestApproval";
+    readonly REQUEST_USER_INPUT: "item/tool/requestUserInput";
 };
 export interface NetworkApprovalContext {
     host: string;
@@ -515,5 +518,37 @@ export interface PermissionsRequestApprovalResponse {
     permissions: GrantedPermissionProfile;
     scope?: 'turn' | 'session';
 }
+/**
+ * Codex AskUserQuestion（request_user_input）协议形状。
+ * 来源：codex-rs/codex-rs/protocol/src/request_user_input.rs +
+ * app-server-protocol v2/item.rs ToolRequestUserInput*（EXPERIMENTAL）。
+ * isOther=true → 渲染层提供自定义答案输入；isSecret 仅影响展示（按普通输入
+ * 处理）；options 为 null/空 → 自由文本题。
+ */
+export interface ToolRequestUserInputOption {
+    label: string;
+    description: string;
+}
+export interface ToolRequestUserInputQuestion {
+    id: string;
+    header: string;
+    question: string;
+    isOther: boolean;
+    isSecret: boolean;
+    options: ToolRequestUserInputOption[] | null;
+}
+export interface ToolRequestUserInputParams {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    questions: ToolRequestUserInputQuestion[];
+    autoResolutionMs?: number | null;
+}
+export interface ToolRequestUserInputAnswer {
+    answers: string[];
+}
+export interface ToolRequestUserInputResponse {
+    answers: Record<string, ToolRequestUserInputAnswer>;
+}
 /** Unsupported / ignored server request methods. */
 export declare const UNSUPPORTED_SERVER_REQUEST_METHODS: Set<string>;

package/dist/runner/codex/app-server/protocol-types.js

@@ -41,10 +41,10 @@ export const ServerRequestMethod = {
     COMMAND_EXECUTION_APPROVAL: 'item/commandExecution/requestApproval',
     FILE_CHANGE_APPROVAL: 'item/fileChange/requestApproval',
     PERMISSIONS_APPROVAL: 'item/permissions/requestApproval',
+    REQUEST_USER_INPUT: 'item/tool/requestUserInput',
 };
 /** Unsupported / ignored server request methods. */
 export const UNSUPPORTED_SERVER_REQUEST_METHODS = new Set([
-    'item/tool/requestUserInput',
     'mcpServer/elicitation/request',
     'item/tool/call',
     'account/chatgptAuthTokens/refresh',

package/dist/runner/codex/app-server/runner.d.ts

@@ -43,6 +43,16 @@ export interface CodexAppServerRunnerOptions {
  * object used by `thread/settings/update` (`sandboxPolicy`).
  */
 export declare function sandboxModeToSandboxPolicy(mode: SandboxMode): SandboxPolicy;
+/**
+ * Codex 官方 feature override（thread/start·resume 的 `config` 字段）：
+ * 让 `request_user_input` 在 Default 协作模式下也可用，无需改 codex
+ * config.toml。协议键与 openai/codex 的 feature registry 一致
+ * （key `default_mode_request_user_input`），app-server 官方测试
+ * （turn_start.rs）验证同一路径。
+ */
+export declare const THREAD_CONFIG_DEFAULT_MODE_REQUEST_USER_INPUT: {
+    readonly 'features.default_mode_request_user_input': true;
+};
 export declare class CodexAppServerRunner extends ConnectionBasedRunner<JsonRpcClient<InitializeResult>, TranslatorEvent> {
     private connectionManager;
     private currentTranslator;

package/dist/runner/codex/app-server/runner.js

@@ -13,6 +13,7 @@
 import { ConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { CodexAppServerTranslator } from './translator.js';
 import { RpcErrorCode } from '../../common/acp/protocol-types.js';
+import { mapAnswersByIndex } from '../../question-common.js';
 import { getLogger } from '../../../logger/index.js';
 import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
 /**
@@ -34,6 +35,39 @@ function buildApprovalResponse(action, view) {
     }
     return { decision: action };
 }
+/**
+ * 构造 request_user_input 响应。answer → 按问题 id 回编；decline/cancel →
+ * 空 answers。answers 值与问题 options 无强校验（Codex 接受任意字符串，
+ * 包括自由文本题的自定义答案）。
+ */
+function buildRequestUserInputResponse(action, questions, response) {
+    if (action !== 'answer') {
+        return { answers: {} };
+    }
+    const answers = response.answers;
+    if (!answers) {
+        return { answers: {} };
+    }
+    const notes = response.notes;
+    const byIndex = mapAnswersByIndex(questions ?? [], answers);
+    const result = {};
+    (questions ?? []).forEach((q, i) => {
+        const value = byIndex[i];
+        if (!q.id || value === undefined)
+            return;
+        const values = Array.isArray(value) ? value : [value];
+        const cleaned = values.filter((v) => typeof v === 'string' && v.length > 0);
+        // Codex user_note：补充说明编码为 "user_note: <text>" 条目（2026-08-18
+        // live 验证 deepseek-v4-flash 明确理解并遵守该格式）。
+        const note = notes?.[q.question]?.trim();
+        if (note)
+            cleaned.push(`user_note: ${note}`);
+        if (cleaned.length === 0)
+            return;
+        result[q.id] = { answers: cleaned };
+    });
+    return { answers: result };
+}
 /**
  * Map the client-side SandboxMode enum to the response-side SandboxPolicy
  * object used by `thread/settings/update` (`sandboxPolicy`).
@@ -54,6 +88,16 @@ export function sandboxModeToSandboxPolicy(mode) {
             return { type: 'dangerFullAccess' };
     }
 }
+/**
+ * Codex 官方 feature override（thread/start·resume 的 `config` 字段）：
+ * 让 `request_user_input` 在 Default 协作模式下也可用，无需改 codex
+ * config.toml。协议键与 openai/codex 的 feature registry 一致
+ * （key `default_mode_request_user_input`），app-server 官方测试
+ * （turn_start.rs）验证同一路径。
+ */
+export const THREAD_CONFIG_DEFAULT_MODE_REQUEST_USER_INPUT = {
+    'features.default_mode_request_user_input': true,
+};
 export class CodexAppServerRunner extends ConnectionBasedRunner {
     connectionManager;
     currentTranslator = null;
@@ -177,7 +221,15 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
         if (!client || !pending)
             return;
         const action = response?.action ?? 'decline';
-        if (pending.kind === 'permissions') {
+        if (pending.kind === 'question') {
+            // AskUserQuestion 回编：文本 key 答案按问题顺序展开后映射回问题 id
+            // （{answers:{id:{answers:[值]}}}）；跳过/拒绝/取消 → 空 answers
+            // （Codex 视为 unanswered，turn 继续，对齐 cc-connect deny 语义）。
+            const questions = pending.view.questions ?? [];
+            const answerPayload = buildRequestUserInputResponse(action, questions, response);
+            client.respond(requestId, answerPayload);
+        }
+        else if (pending.kind === 'permissions') {
             // 权限审批的响应没有 decision 字段（真实协议只回 granted profile +
             // scope）：decline/cancel 必须返回空授权（拒绝全部），否则会把用户已
             // 勾选的条目当作授予返回（2026-08-12 review 发现：勾选后点「拒绝」实
@@ -258,6 +310,9 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
             ...(this.modelProvider ? { modelProvider: this.modelProvider } : {}),
             ...(this.approvalPolicyConfig ? { approvalPolicy: this.approvalPolicyConfig } : {}),
             ...(this.sandboxConfig ? { sandbox: this.sandboxConfig } : {}),
+            // Default 协作模式下默认启用 request_user_input（Ask User Question），
+            // 协议级 override，不依赖 codex config.toml。
+            config: THREAD_CONFIG_DEFAULT_MODE_REQUEST_USER_INPUT,
         };
         return params;
     }

package/dist/runner/codex/app-server/translator.d.ts

@@ -43,6 +43,13 @@ export declare class CodexAppServerTranslator {
      * Handle a server request (incoming JSON-RPC request from server, e.g. approval).
      */
     handleServerRequest(id: number | string, method: string, params: unknown): TranslatorEvent[];
+    /**
+     * Codex AskUserQuestion：item/tool/requestUserInput → question 审批事件。
+     * 问题 id 保留在 UserQuestion.id（回编时文本 → id 映射），options 为
+     * null/空 → 自由文本题（空数组驱动卡片渲染输入框）；autoResolutionMs
+     * 透传为 per-request 超时（coordinator 优先使用）。
+     */
+    private handleRequestUserInput;
     /**
      * Synthesize a ResultEvent from the current turn state.
      * Called when the turn completes.

package/dist/runner/codex/app-server/translator.js

@@ -7,6 +7,7 @@
  * completes. Method names and parameter shapes follow the real Codex
  * app-server v2 protocol (see protocol-types.ts).
  */
+import { makeQuestionApprovalEvent } from '../../question-common.js';
 import { NotificationMethod, ServerRequestMethod, UNSUPPORTED_SERVER_REQUEST_METHODS, } from './protocol-types.js';
 // =============================================================================
 // Translator
@@ -86,10 +87,33 @@ export class CodexAppServerTranslator {
                 return this.handleFileApproval(id, params);
             case ServerRequestMethod.PERMISSIONS_APPROVAL:
                 return this.handlePermissionsApproval(id, params);
+            case ServerRequestMethod.REQUEST_USER_INPUT:
+                return this.handleRequestUserInput(id, params);
             default:
                 return [];
         }
     }
+    /**
+     * Codex AskUserQuestion：item/tool/requestUserInput → question 审批事件。
+     * 问题 id 保留在 UserQuestion.id（回编时文本 → id 映射），options 为
+     * null/空 → 自由文本题（空数组驱动卡片渲染输入框）；autoResolutionMs
+     * 透传为 per-request 超时（coordinator 优先使用）。
+     */
+    handleRequestUserInput(requestId, params) {
+        const questions = params.questions
+            .map((q) => requestUserInputQuestionToUserQuestion(q))
+            .filter((q) => q !== null);
+        if (questions.length === 0) {
+            // 无有效问题：不渲染空提问卡，返回 [] 由 runner 以 method-not-found
+            // 拒绝（服务端视作请求失败，不会悬挂）。
+            return [];
+        }
+        return [
+            makeQuestionApprovalEvent(requestId, questions, params.threadId, {
+                timeoutMs: params.autoResolutionMs ?? undefined,
+            }),
+        ];
+    }
     /**
      * Synthesize a ResultEvent from the current turn state.
      * Called when the turn completes.
@@ -713,4 +737,25 @@ function normalizeCommandDecisions(list) {
         ...(Object.keys(payloads).length > 0 ? { payloads } : {}),
     };
 }
+/** Codex wire question → 统一 UserQuestion（options null/空 → 自由文本题）。 */
+function requestUserInputQuestionToUserQuestion(q) {
+    const question = q.question?.trim();
+    if (!question)
+        return null;
+    const options = (q.options ?? []).map((opt) => ({
+        label: opt.label,
+        ...(opt.description ? { description: opt.description } : {}),
+    }));
+    return {
+        id: q.id,
+        header: q.header || undefined,
+        question,
+        isOther: q.isOther,
+        isSecret: q.isSecret,
+        options,
+        // Codex user_note：选项题渲染「补充说明（可选）」输入（live 验证模型理解
+        // "user_note:" 条目）；自由文本题（options 空）不需要。
+        ...(options.length > 0 ? { allowNote: true } : {}),
+    };
+}
 //# sourceMappingURL=translator.js.map

package/dist/runner/common/acp/protocol-types.d.ts

@@ -207,6 +207,8 @@ export interface SessionUpdateNotification {
 }
 export declare const ServerRequestMethod: {
     readonly REQUEST_PERMISSION: "session/request_permission";
+    /** Kimi AskUserQuestion elicitation form（客户端广告 elicitation.form 时启用）。 */
+    readonly ELICITATION_CREATE: "elicitation/create";
 };
 export interface PermissionOption {
     /** Opaque option identifier — echo back in response outcome.optionId. */
@@ -236,3 +238,34 @@ export interface RequestPermissionResponse {
         optionId?: string;
     };
 }
+export interface ElicitationEnumOption {
+    const: string;
+    title?: string;
+    description?: string;
+}
+export interface ElicitationPropertySchema {
+    type: 'string' | 'array';
+    title?: string;
+    description?: string;
+    minItems?: number;
+    oneOf?: ElicitationEnumOption[];
+    items?: {
+        anyOf?: ElicitationEnumOption[];
+    };
+}
+export interface ElicitationCreateParams {
+    sessionId: string;
+    toolCallId?: string;
+    mode: 'form';
+    message?: string;
+    requestedSchema: {
+        type: 'object';
+        required?: string[];
+        properties: Record<string, ElicitationPropertySchema>;
+    };
+}
+export interface ElicitationCreateResponse {
+    action: 'accept' | 'decline' | 'cancel';
+    /** accept 时的答案，key 为 q0..qn（按问题顺序）。 */
+    content?: Record<string, string | string[]>;
+}

package/dist/runner/common/acp/protocol-types.js

@@ -71,5 +71,7 @@ export const SessionEventType = {
 // =============================================================================
 export const ServerRequestMethod = {
     REQUEST_PERMISSION: 'session/request_permission',
+    /** Kimi AskUserQuestion elicitation form（客户端广告 elicitation.form 时启用）。 */
+    ELICITATION_CREATE: 'elicitation/create',
 };
 //# sourceMappingURL=protocol-types.js.map

package/dist/runner/common/connection-based-runner.js

@@ -104,18 +104,23 @@ export class ConnectionBasedRunner {
      * unblock; otherwise cancel now via cancelCurrentTurn().
      */
     async stop(_opts) {
-        if (!this._isRunning || !this.currentClient || !this.currentSessionId())
+        if (!this._isRunning)
             return;
+        // CC-01: 启动阶段（client/session 未建立）也必须记录停止意图，否则 /stop 被吞、
+        // turn 照常执行。executeTurn 在 setup 完成后检查 stopRequested 补发 cancel。
+        this.stopRequested = true;
+        this.forceFinish = true;
+        this.wakeWaiters();
+        if (!this.currentClient || !this.currentSessionId()) {
+            getLogger().warn(`[${this.logTag}] stop during setup (client/session not ready); will cancel after setup`);
+            return;
+        }
         if (this.shouldDeferStop()) {
             // turn/start 或 prompt 尚未响应：先标记，等 run() 完成后再补发 cancel。
-            this.stopRequested = true;
-            this.forceFinish = true;
-            this.wakeWaiters();
             return;
         }
         // turn/start 或 prompt 已 resolved：立即 cancel；同时置 stopRequested 抑制
         // 尚未结算的 prompt 结果翻译（opencode 语义），对已结算方无害。
-        this.stopRequested = true;
         try {
             await this.cancelCurrentTurn();
         }