lark-remote 0.1.8 → 0.1.10

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,6 +27,7 @@
  * 进程在 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';
@@ -35,6 +36,8 @@ 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 结束）。 */
@@ -66,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 写入（用户消息与审批响应交错到达）。 */
@@ -182,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 {
@@ -301,6 +312,10 @@ export class ClaudeSession extends SpawningRunner {
         this.cwd = opts.cwd;
         this.autoApprove = false;
         this.pendingToolInputs.clear();
+        // 每次 run 独立：上次 run 会话内跟踪到的计划文件不得泄漏到本次
+        // （否则本次 ExitPlanMode 无 plan/planFilePath 时 resolvePlanContent
+        // 会误读上一次的计划文件当当前计划）。
+        this.planFilePath = '';
         let proc;
         try {
             proc = await this.spawnChild(opts);
@@ -344,7 +359,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();
@@ -530,7 +545,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 之外还可能有
@@ -538,6 +553,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);
         }
@@ -588,7 +607,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`);
@@ -642,21 +717,27 @@ export class ClaudeSession extends SpawningRunner {
             }
             return [makeQuestionApprovalEvent(requestId, questions, this.sessionId)];
         }
-        // ExitPlanMode：语义是「退出计划模式」的通知型工具，input 天然为空（plan
-        // 内容在 plan 文件 + 前置 thinking/text 里，不走 tool input）。它没有
-        // command 语义，塞进 command 槽位会显示无意义 `{}` → 用独立 tool kind，
-        // 标题/工具名 + reason 表达审批内容。
+        // ExitPlanMode：计划已写入计划文件（或经 input.plan 注入）。没有 command
+        // 语义，塞进 command 槽位会显示无意义 `{}` → 用独立 tool kind，把计划
+        // 全文 + 文件路径带给渲染层，决策对齐 TUI 四种交互。
         if (toolName === 'ExitPlanMode') {
-            const rawInput = JSON.stringify(input);
+            const resolved = await this.resolvePlanContent(input, this.planFilePath);
             const view = {
                 requestId,
                 kind: 'tool',
                 toolName,
                 reason: typeof request.description === 'string' ? request.description : undefined,
-                // 非空 input 携带给渲染层（当前 ExitPlanMode 为 `{}`，渲染层不展示）。
-                ...(rawInput && rawInput !== '{}' ? { toolInput: rawInput.slice(0, 500) } : {}),
-                // 计划审批没有「后续自动放行」语义，acceptAll 无意义；只留 accept/decline。
-                availableDecisions: ['accept', 'decline'],
+                ...(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 [

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();
         }

package/dist/runner/dsh/runner.d.ts

@@ -44,6 +44,13 @@ export declare class DshRunner implements AgentRunner {
     private activeAbort;
     private activeSessionId;
     private running;
+    /**
+     * 已对齐模型的 session 集合：同一 session 二次 run 不再重发 selectModel
+     * （session.selectModel 会写服务端全局默认，每次 run 都写是写放大）。
+     * configuredModel 在实例生命周期内不变（/config 改模型会 clearRunners
+     * 重建实例 + 换新 sessionId），故「每 session 对齐一次」足以覆盖配置变化。
+     */
+    private readonly alignedSessions;
     constructor(opts: DshRunnerOptions);
     get isRunning(): boolean;
     getStatusInfo(): AgentStatusInfo;

package/dist/runner/dsh/runner.js

@@ -28,6 +28,13 @@ export class DshRunner {
     activeAbort = null;
     activeSessionId = null;
     running = false;
+    /**
+     * 已对齐模型的 session 集合：同一 session 二次 run 不再重发 selectModel
+     * （session.selectModel 会写服务端全局默认，每次 run 都写是写放大）。
+     * configuredModel 在实例生命周期内不变（/config 改模型会 clearRunners
+     * 重建实例 + 换新 sessionId），故「每 session 对齐一次」足以覆盖配置变化。
+     */
+    alignedSessions = new Set();
     constructor(opts) {
         this.sessionReader = opts.sessionReader;
         this.configuredModel = opts.model;
@@ -51,99 +58,143 @@ export class DshRunner {
         };
     }
     async *run(message, opts) {
+        if (this.running) {
+            throw new Error('DshRunner is already running');
+        }
         const abort = new AbortController();
         this.activeAbort = abort;
         this.running = true;
         let sessionId = opts.sessionId;
-        if (!sessionId) {
-            const created = await this.client.createSession({
-                cwd: opts.cwd,
-                ...(this.agentPreset ? { agentPreset: this.agentPreset } : {}),
-            });
-            sessionId = created.sessionId;
-        }
-        this.activeSessionId = sessionId;
-        // 模型/推理强度变更 = 保留 session，每次 run 前对齐（§4.3）：
-        // 该调用同时会写服务端全局默认；失败仅告警不阻断 run（模型校验由 DSH 负责）。
-        if (this.configuredModel) {
-            try {
-                await this.client.selectModel({
-                    sessionId,
-                    provider: DSH_MODEL_PROVIDER,
-                    model: this.configuredModel,
-                    ...(this.reasoningEffort ? { reasoningEffort: this.reasoningEffort } : {}),
+        let terminalEmitted = false;
+        try {
+            // CC-03: session.create 必须包进同一 try/finally，否则创建失败（服务端不可达/报错）
+            // 会在进入旧 try 之前抛异常，finally 不执行 → running 恒 true、activeAbort 残留。
+            if (!sessionId) {
+                const created = await this.client.createSession({
+                    cwd: opts.cwd,
+                    ...(this.agentPreset ? { agentPreset: this.agentPreset } : {}),
                 });
+                sessionId = created.sessionId;
             }
-            catch (err) {
-                getLogger().warn(`[dsh] selectModel failed for session ${sessionId} (run continues): ${err.message}`);
+            this.activeSessionId = sessionId;
+            // Startup abort：createSession 挂起期间 stop() 已 abort（此时 sessionId 尚
+            // 未知，stop() 无法 cancel）。createSession 返回后立即检查——已 abort 则
+            // cancel 这个刚建的 session 并中断，不让启动流程继续（selectModel/prompt）。
+            // 必须 yield interrupted result（不能裸 return）：调用方依赖 result 收尾
+            // run 卡，否则 for-await 自然结束后无终态、卡片停留「运行中」。
+            if (abort.signal.aborted) {
+                try {
+                    await this.client.unary('session.cancel', { sessionId });
+                }
+                catch {
+                    /* 取消失败仅告警，session 已 abort 无需继续 */
+                }
+                getLogger().info(`[dsh] run aborted during startup, cancelled session ${sessionId}`);
+                terminalEmitted = true;
+                yield {
+                    type: 'result',
+                    subtype: 'interrupted',
+                    session_id: sessionId,
+                    errorMessage: 'run stopped',
+                };
+                return;
             }
-        }
-        yield {
-            type: 'system',
-            subtype: 'init',
-            session_id: sessionId,
-            cwd: opts.cwd,
-            model: this.configuredModel ?? 'DSH',
-        };
-        let terminalEmitted = false;
-        try {
-            // Snapshot the pre-prompt high-water mark before mutating the session.
-            // DSH session.history returns the whole session, so starting from seq 0
-            // would replay the first completed turn on every follow-up prompt.
-            const prePromptSeq = await this.client.latestEventSeq(sessionId);
-            await this.client.unary('session.prompt', {
-                sessionId,
-                mode: 'queue',
-                content: [{ type: 'text', text: message }],
-            });
-            const translator = new DshTranslator();
+            // 模型/推理强度对齐（§4.3）：会话首次 run 时 selectModel 一次
+            // （该调用同时写服务端全局默认，故不重复写）；同一 session 后续 run
+            // 跳过。失败仅告警不阻断 run（模型校验由 DSH 负责）。
+            if (this.configuredModel && !this.alignedSessions.has(sessionId)) {
+                try {
+                    await this.client.selectModel({
+                        sessionId,
+                        provider: DSH_MODEL_PROVIDER,
+                        model: this.configuredModel,
+                        ...(this.reasoningEffort ? { reasoningEffort: this.reasoningEffort } : {}),
+                    });
+                    this.alignedSessions.add(sessionId);
+                }
+                catch (err) {
+                    getLogger().warn(`[dsh] selectModel failed for session ${sessionId} (run continues): ${err.message}`);
+                }
+            }
+            yield {
+                type: 'system',
+                subtype: 'init',
+                session_id: sessionId,
+                cwd: opts.cwd,
+                model: this.configuredModel ?? 'DSH',
+            };
             try {
-                for await (const item of this.client.sessionEvents(sessionId, opts.cwd, abort.signal, prePromptSeq)) {
-                    if (abort.signal.aborted)
-                        break;
-                    if (item.kind === 'approval') {
-                        getLogger().warn(`[dsh] approval requested approvalId=${item.approvalId} tool=${item.toolName} — resolve in DSH Web UI`);
-                        yield {
-                            type: 'assistant',
-                            message: {
-                                content: [
-                                    {
-                                        type: 'text',
-                                        text: `⚠️ 需要授权（${item.toolName}）：请在 DSH Web UI 处理 ${this.client.baseUrl}`,
-                                    },
-                                ],
-                            },
-                        };
-                        continue;
-                    }
-                    for (const ev of translator.eventToAgentEvents(item.event, sessionId)) {
-                        yield ev;
-                        if (ev.type === 'result') {
-                            terminalEmitted = true;
-                            return;
+                // Snapshot the pre-prompt high-water mark before mutating the session.
+                // DSH session.history returns the whole session, so starting from seq 0
+                // would replay the first completed turn on every follow-up prompt.
+                const prePromptSeq = await this.client.latestEventSeq(sessionId);
+                await this.client.unary('session.prompt', {
+                    sessionId,
+                    mode: 'queue',
+                    content: [{ type: 'text', text: message }],
+                });
+                const translator = new DshTranslator();
+                try {
+                    for await (const item of this.client.sessionEvents(sessionId, opts.cwd, abort.signal, prePromptSeq)) {
+                        if (abort.signal.aborted)
+                            break;
+                        if (item.kind === 'approval') {
+                            getLogger().warn(`[dsh] approval requested approvalId=${item.approvalId} tool=${item.toolName} — resolve in DSH Web UI`);
+                            yield {
+                                type: 'assistant',
+                                message: {
+                                    content: [
+                                        {
+                                            type: 'text',
+                                            text: `⚠️ 需要授权（${item.toolName}）：请在 DSH Web UI 处理 ${this.client.baseUrl}`,
+                                        },
+                                    ],
+                                },
+                            };
+                            continue;
+                        }
+                        for (const ev of translator.eventToAgentEvents(item.event, sessionId)) {
+                            yield ev;
+                            if (ev.type === 'result') {
+                                terminalEmitted = true;
+                                return;
+                            }
                         }
                     }
                 }
+                catch (err) {
+                    if (abort.signal.aborted)
+                        throw err;
+                    getLogger().error(`[dsh] run consume error: ${err.message}`);
+                    yield {
+                        type: 'result',
+                        subtype: 'error',
+                        session_id: sessionId,
+                        errorMessage: `DSH stream error: ${err.message}`,
+                    };
+                    terminalEmitted = true;
+                }
             }
             catch (err) {
-                if (abort.signal.aborted)
-                    throw err;
-                getLogger().error(`[dsh] run consume error: ${err.message}`);
-                yield {
-                    type: 'result',
-                    subtype: 'error',
-                    session_id: sessionId,
-                    errorMessage: `DSH stream error: ${err.message}`,
-                };
-                terminalEmitted = true;
+                if (!abort.signal.aborted) {
+                    yield {
+                        type: 'result',
+                        subtype: 'error',
+                        session_id: sessionId,
+                        errorMessage: `DSH run failed: ${err.message}`,
+                    };
+                    terminalEmitted = true;
+                }
             }
         }
         catch (err) {
+            // CC-03: createSession 等启动期失败也产出 error result（而非抛异常），
+            // 由本 catch 统一转 error result；state 清理在 finally。
             if (!abort.signal.aborted) {
                 yield {
                     type: 'result',
                     subtype: 'error',
-                    session_id: sessionId,
+                    session_id: sessionId ?? '',
                     errorMessage: `DSH run failed: ${err.message}`,
                 };
                 terminalEmitted = true;
@@ -158,7 +209,7 @@ export class DshRunner {
             yield {
                 type: 'result',
                 subtype: abort.signal.aborted ? 'interrupted' : 'error',
-                session_id: sessionId,
+                session_id: sessionId ?? '',
                 errorMessage: abort.signal.aborted ? 'run stopped' : 'turn ended without a terminal event',
             };
         }

package/dist/runner/kimi/acp/runner.js

@@ -405,6 +405,21 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
             sessionId = newResult.sessionId;
         }
         this.activeSessionId = sessionId;
+        // CC-07: 下发配置的模型（provider/model）。session/new|resume 只带 cwd/mcpServers，
+        // 不带 model；不主动下发则实际跑 kimi 服务端默认模型（旧 KimiRunner 通过 -m 传模型，
+        // 迁移到纯 ACP 后丢失）。仿 opencode 用 session/set_config_option。失败仅告警不阻断。
+        if (this.model) {
+            try {
+                await client.request('session/set_config_option', {
+                    sessionId,
+                    configId: 'model',
+                    value: this.model,
+                });
+            }
+            catch (err) {
+                getLogger().warn(`[${this.logTag}] set_config_option model failed (non-fatal): ${err.message}`);
+            }
+        }
         // Set permission mode (§5.1): EVERY fresh ACP session starts in
         // 'default' (= manual approvals, acp-server modes.ts DEFAULT_MODE_ID),
         // so the mode must be sent unconditionally — skipping yolo leaves the

package/dist/runner/pi/rpc/runner.js

@@ -134,7 +134,12 @@ export class PiRpcRunner extends ConnectionBasedRunner {
         this.currentTurnId = turnId;
         this.pushEvents([translator.produceTurnStarted(sessionId, turnId)]);
         this.promptSettled = false;
-        await client.request({ type: 'prompt', message });
+        const response = await client.request({ type: 'prompt', message });
+        if (!response.success) {
+            // CC-08: pi 返回 success:false（无效模型/provider 错误/忙）时立即失败，
+            // 不能当成成功 ACK 继续等 agent_settled（否则最长 turn idle timeout）。
+            throw new Error(`pi prompt failed: ${response.error ?? 'unknown error'}`);
+        }
         this.promptSettled = true;
     }
     /**

package/dist/runner/registry.d.ts

@@ -5,8 +5,9 @@ import type { AgentKind, Runner } from './index.js';
  * up `config.defaultAgent` here to pick the concrete runner.
  *
  * Singleton caching: the factory MAY cache its instance internally. Most
- * current agents (claude, opencode, pi, kimi) are spawn-per-message; codex is
- * workspace-lifetime (app-server). Each factory returns a runner per call.
+ * current spawn-type agents (claude, opencode, pi, kimi) are spawn-per-message; codex is
+ * workspace-lifetime (app-server); dsh is HTTP+WS direct connection (no local
+ * subprocess). Each factory returns a runner per call.
  *
  * Dynamic config reload: factory can read latest config via registry's
  * configContainer, enabling runtime config changes to take effect.

package/dist/runner/registry.js

@@ -9,8 +9,9 @@ let globalRegistry;
  * up `config.defaultAgent` here to pick the concrete runner.
  *
  * Singleton caching: the factory MAY cache its instance internally. Most
- * current agents (claude, opencode, pi, kimi) are spawn-per-message; codex is
- * workspace-lifetime (app-server). Each factory returns a runner per call.
+ * current spawn-type agents (claude, opencode, pi, kimi) are spawn-per-message; codex is
+ * workspace-lifetime (app-server); dsh is HTTP+WS direct connection (no local
+ * subprocess). Each factory returns a runner per call.
  *
  * Dynamic config reload: factory can read latest config via registry's
  * configContainer, enabling runtime config changes to take effect.