lark-remote 0.5.19 → 0.5.20

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

@@ -140,7 +140,7 @@ export declare class ClaudeSession extends SpawningRunner {
      * 消费事件队列直到本 turn 的 result 事件（非 compact/compaction）。
      * 消费者提前关闭生成器（bridge 循环体抛错）→ 杀进程防孤儿（语义）。
      *
-     * result = turn 终态（2026-08-16 真实 claude 实测：长驻模式下 result 之后
+     * result = turn 终态（长驻模式下 result 之后
      * 不再有 stdout 事件，后台任务完成是静默的；旧 -p 流程「等进程退出再收尾」
      * 的 post-result drain 在长驻模式下无对应物）。
      */

package/dist/runner/claude/session.js

@@ -127,7 +127,7 @@ export class ClaudeSession extends SpawningRunner {
             // 或 --resume 目标会话）。比较进程当前 session（init 报告值）而非 spawn
             // 请求值：bridge 会把 init 的 session_id 写回 SessionStore，第二条消息
             // 带着它来；若拿 spawn 请求值（''）比较，每条消息都会误判切换、杀进程
-            // 重启，长驻设计失效（2026-08-16）。
+            // 重启，长驻设计失效。
             if (this.isRunning && this.sessionId !== (opts.sessionId ?? '')) {
                 getLogger().info(`[${this.logTag}] session mismatch: process=${this.sessionId || '(fresh)'} ` +
                     `requested=${opts.sessionId ?? '(fresh)'}, recycling process`);
@@ -151,7 +151,7 @@ export class ClaudeSession extends SpawningRunner {
                 // review：stop()/进程死亡与写 stdin 竞态（EPIPE/ENOTCONN）。用户
                 // stop 已置 stoppedByUser（或进程已死/流已结束）时，写入失败不抛给
                 // 调用方，交由 consumeTurn 按 interrupted/error 产出终态——否则
-                // stop 在途的 run 会以裸 EPIPE 崩溃（2026-08-16 复现的 flaky）。
+                // stop 在途的 run 会以裸 EPIPE 崩溃（flaky）。
                 if (this.stoppedByUser || !this.isRunning || this.streamEnded) {
                     getLogger().warn(`[${this.logTag}] user message write failed, process stopping: ${err instanceof Error ? err.message : String(err)}`);
                 }
@@ -383,7 +383,7 @@ export class ClaudeSession extends SpawningRunner {
      * 消费事件队列直到本 turn 的 result 事件（非 compact/compaction）。
      * 消费者提前关闭生成器（bridge 循环体抛错）→ 杀进程防孤儿（语义）。
      *
-     * result = turn 终态（2026-08-16 真实 claude 实测：长驻模式下 result 之后
+     * result = turn 终态（长驻模式下 result 之后
      * 不再有 stdout 事件，后台任务完成是静默的；旧 -p 流程「等进程退出再收尾」
      * 的 post-result drain 在长驻模式下无对应物）。
      */
@@ -716,7 +716,9 @@ export class ClaudeSession extends SpawningRunner {
                 void this.writeControlResponse(requestId, {
                     behavior: 'deny',
                     message: '无法解析 AskUserQuestion 选项',
-                }).catch(() => { });
+                }).catch((err) => {
+                    getLogger().warn(`[${this.logTag}] AskUserQuestion deny write failed requestId=${requestId}: ${err.message}`);
+                });
                 // 解析失败 deny 后同样释放条目（不经过 respondPermission）。
                 this.pendingToolInputs.delete(requestId);
                 return [];

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

@@ -62,7 +62,14 @@ export declare class CodexAppServerRunner extends ConnectionBasedRunner<JsonRpcC
     protected cancelCurrentTurn(): Promise<void>;
     protected clearTurnState(): void;
     protected releaseConnection(cwd: string): Promise<void>;
+    /**
+     * Wire the acquired client's hooks into the turn dispatcher (anchor-guarded).
+     * 代际锚点与 ACP/pi 同口径：连接按 workspace 缓存复用，旧 turn 迟到的通知 /
+     * server request / onClose 不得进入新轮（此前 codex 缺这层守卫，属补齐漂移）。
+     */
+    private installTurnHooks;
     protected notifyIdle(cwd: string): void;
+    protected notifyConnectionActivity(cwd: string): void;
     protected disposeConnections(): Promise<void>;
     /**
      * Run a compact operation on the current thread.
@@ -100,8 +107,8 @@ export declare class CodexAppServerRunner extends ConnectionBasedRunner<JsonRpcC
      *
      * App-server 把已知线程的通知全部复用同一条 stdio 连接：agent 用
      * multi-agent v2 派生子 agent 后，子线程的 `turn/started`、`item/*`、
-     * `turn/completed`、`thread/tokenUsage/updated` 会与本轮通知交错到达
-     * （2026-10-09 实测）。一个 turn 只属于一个线程，因此外来线程的通知一律
+     * `turn/completed`、`thread/tokenUsage/updated` 会与本轮通知交错到达。
+     * 一个 turn 只属于一个线程，因此外来线程的通知一律
      * 丢弃——否则子线程的 `turn/started` 会覆盖本轮 threadId，会话写回把子
      * 线程 id 当成顶层会话指针存盘（冷连接 `thread/resume` 直接报
      * "cannot resume an unloaded multi-agent v2 sub-agent"），且子线程的

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

@@ -58,8 +58,8 @@ function buildRequestUserInputResponse(action, questions, response) {
             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 明确理解并遵守该格式）。
+        // Codex user_note：补充说明编码为 "user_note: <text>" 条目（deepseek-v4-flash
+        // 明确理解并遵守该格式）。
         const note = notes?.[q.question]?.trim();
         if (note)
             cleaned.push(`user_note: ${note}`);
@@ -184,9 +184,27 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
     async releaseConnection(cwd) {
         await this.connectionManager.release(cwd);
     }
+    /**
+     * Wire the acquired client's hooks into the turn dispatcher (anchor-guarded).
+     * 代际锚点与 ACP/pi 同口径：连接按 workspace 缓存复用，旧 turn 迟到的通知 /
+     * server request / onClose 不得进入新轮（此前 codex 缺这层守卫，属补齐漂移）。
+     */
+    installTurnHooks(anchor) {
+        anchor.client.setHooks({
+            onNotification: this.forCurrentTurn(anchor, 'notification', (method, params) => this.handleNotification(method, params)),
+            onServerRequest: this.forCurrentTurn(anchor, 'server request', (id, method, params) => this.handleServerRequest(id, method, params)),
+            onClose: this.forCurrentTurn(anchor, 'connection close', () => {
+                getLogger().warn(`[${this.logTag}] client connection closed`);
+                this.failTurn('Codex app-server connection closed');
+            }),
+        });
+    }
     notifyIdle(cwd) {
         this.connectionManager.notifyIdle(cwd);
     }
+    notifyConnectionActivity(cwd) {
+        this.connectionManager.notifyActivity(cwd);
+    }
     async disposeConnections() {
         await this.connectionManager.disposeAll();
     }
@@ -195,14 +213,9 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
      */
     async *runCompact(_message, opts) {
         yield* this.executeTurn(opts, async () => {
-            const client = await this.connectionManager.acquire(opts.cwd);
-            this.connectionManager.notifyActivity(opts.cwd);
-            this.currentClient = client;
-            client.setHooks({
-                onNotification: (method, params) => this.handleNotification(method, params),
-                onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
-                onClose: () => this.failTurn('Codex app-server connection closed'),
-            });
+            const anchor = await this.acquireForTurn(opts.cwd, () => this.connectionManager.acquire(opts.cwd));
+            this.installTurnHooks(anchor);
+            const { client } = anchor;
             if (!opts.sessionId) {
                 throw new Error('compact requires a sessionId');
             }
@@ -244,8 +257,8 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
         else if (pending.kind === 'permissions') {
             // 权限审批的响应没有 decision 字段（真实协议只回 granted profile +
             // scope）：decline/cancel 必须返回空授权（拒绝全部），否则会把用户已
-            // 勾选的条目当作授予返回（2026-08-12 ：勾选后点「拒绝」实
-            // 际授予了所选权限）。accept/acceptForSession 才带用户勾选的条目。
+            // 勾选的条目当作授予返回（勾选后点「拒绝」实际授予了所选权限）。
+            // accept/acceptForSession 才带用户勾选的条目。
             const denied = action === 'decline' || action === 'cancel';
             client.respond(requestId, {
                 permissions: denied
@@ -344,17 +357,9 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
      * thread/resume（按 sessionId 恢复既有线程）→ turn/start。
      */
     async setupTurn(message, opts) {
-        const client = await this.connectionManager.acquire(opts.cwd);
-        this.connectionManager.notifyActivity(opts.cwd);
-        this.currentClient = client;
-        client.setHooks({
-            onNotification: (method, params) => this.handleNotification(method, params),
-            onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
-            onClose: () => {
-                getLogger().warn(`[${this.logTag}] client connection closed`);
-                this.failTurn('Codex app-server connection closed');
-            },
-        });
+        const anchor = await this.acquireForTurn(opts.cwd, () => this.connectionManager.acquire(opts.cwd));
+        this.installTurnHooks(anchor);
+        const { client } = anchor;
         const threadParams = this.buildThreadParams(opts.cwd);
         let threadId;
         if (opts.sessionId) {
@@ -387,8 +392,8 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
      *
      * App-server 把已知线程的通知全部复用同一条 stdio 连接：agent 用
      * multi-agent v2 派生子 agent 后，子线程的 `turn/started`、`item/*`、
-     * `turn/completed`、`thread/tokenUsage/updated` 会与本轮通知交错到达
-     * （2026-10-09 实测）。一个 turn 只属于一个线程，因此外来线程的通知一律
+     * `turn/completed`、`thread/tokenUsage/updated` 会与本轮通知交错到达。
+     * 一个 turn 只属于一个线程，因此外来线程的通知一律
      * 丢弃——否则子线程的 `turn/started` 会覆盖本轮 threadId，会话写回把子
      * 线程 id 当成顶层会话指针存盘（冷连接 `thread/resume` 直接报
      * "cannot resume an unloaded multi-agent v2 sub-agent"），且子线程的

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

@@ -14,7 +14,6 @@ export type TranslatorEvent = AgentEvent | TurnStartedEvent | TurnDiffEvent | Ap
 export declare class CodexAppServerTranslator {
     private turnId;
     private threadId;
-    private turnStatus;
     /** Full agentMessage text per item id (item-scoped snapshot). */
     private textByItem;
     /** agentMessage item ids whose protocol phase is `final_answer`. */
@@ -69,10 +68,6 @@ export declare class CodexAppServerTranslator {
         inputTokens: number;
         outputTokens: number;
     };
-    /**
-     * Get the current turn status.
-     */
-    getTurnStatus(): string;
     /**
      * Set the operation kind (exec vs compact).
      */

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

@@ -8,6 +8,7 @@
  * app-server v2 protocol (see protocol-types.ts).
  */
 import { makeQuestionApprovalEvent } from '../../question-common.js';
+import { renderPlanMarkdown } from '../../common/acp/base-translator.js';
 import { NotificationMethod, ServerRequestMethod, UNSUPPORTED_SERVER_REQUEST_METHODS, } from './protocol-types.js';
 // =============================================================================
 // Translator
@@ -15,7 +16,6 @@ import { NotificationMethod, ServerRequestMethod, UNSUPPORTED_SERVER_REQUEST_MET
 export class CodexAppServerTranslator {
     turnId = '';
     threadId = '';
-    turnStatus = 'pending';
     /** Full agentMessage text per item id (item-scoped snapshot). */
     textByItem = new Map();
     /** agentMessage item ids whose protocol phase is `final_answer`. */
@@ -133,7 +133,6 @@ export class CodexAppServerTranslator {
      */
     handleTurnCompleted(params) {
         const turn = params?.turn;
-        this.turnStatus = turn?.status ?? 'completed';
         const events = [];
         // 兜底：turn.items 里权威 agentMessage / plan item 与已流式内容不一致或
         // 未发过（如 itemsView 摘要只含部分 item）时，补发 item 级快照。已一致则
@@ -204,12 +203,6 @@ export class CodexAppServerTranslator {
             outputTokens: this.usage.outputTokens,
         };
     }
-    /**
-     * Get the current turn status.
-     */
-    getTurnStatus() {
-        return this.turnStatus;
-    }
     /**
      * Set the operation kind (exec vs compact).
      */
@@ -222,7 +215,6 @@ export class CodexAppServerTranslator {
     handleTurnStarted(params) {
         this.threadId = params.threadId;
         this.turnId = params.turn.id;
-        this.turnStatus = params.turn.status ?? 'inProgress';
         // 单 turn 用量从零开始累计：turn 内每次采样都会发一条
         // `thread/tokenUsage/updated`，本 run 的用量是这些增量之和（不是最后一条）。
         // resume 后服务端重放的上一 turn 用量若在此之后到达，由 handleTokenUsageUpdated
@@ -497,14 +489,9 @@ export class CodexAppServerTranslator {
      * status 缺省或未知一律按 pending 处理（防御 wire 枚举漂移）。
      */
     handleTurnPlanUpdated(params) {
-        const ICON = { completed: '✅', in_progress: '🔄', pending: '⬜', error: '❌' };
-        const markdown = params.plan
-            .map((s) => {
-            const status = s.status && s.status in ICON ? s.status : 'pending';
-            return `${ICON[status]} ${s.title}${s.subtitle ? ` — ${s.subtitle}` : ''}`;
-        })
-            .join('\n');
-        return [{ type: 'plan', plan: markdown, timestamp: this.now() }];
+        // 图标表 + status 归一与 ACP handlePlan 共用 renderPlanMarkdown
+        // （未知/缺省 status 一律按 pending，防 wire 枚举漂移）。
+        return [{ type: 'plan', plan: renderPlanMarkdown(params.plan), timestamp: this.now() }];
     }
     handleError(params) {
         if (params.willRetry) {

package/dist/runner/common/acp/acp-approval.d.ts

@@ -13,7 +13,7 @@ export interface AcpApprovalKinds {
     acceptForSession: string[];
     decline: string[];
 }
-/** kimi 观测 kind（approval.ts:28-29 + 2026-08-15 live：approve_once/approve_always/reject）。 */
+/** kimi 观测 kind（approval.ts:28-29：approve_once/approve_always/reject）。 */
 export declare const KIMI_APPROVAL_KINDS: AcpApprovalKinds;
 /** opencode kind（permission.ts:219-223：once/always → approve，其余 → reject）。 */
 export declare const OPENCODE_APPROVAL_KINDS: AcpApprovalKinds;

package/dist/runner/common/acp/acp-approval.js

@@ -20,7 +20,7 @@ function findOptionIdByKind(options, candidateKinds) {
     }
     return undefined;
 }
-/** kimi 观测 kind（approval.ts:28-29 + 2026-08-15 live：approve_once/approve_always/reject）。 */
+/** kimi 观测 kind（approval.ts:28-29：approve_once/approve_always/reject）。 */
 export const KIMI_APPROVAL_KINDS = {
     accept: ['approve_once', 'approve_always', 'allow_once'],
     acceptForSession: ['approve_always', 'allow_always'],

package/dist/runner/common/acp/base-acp-runner.d.ts

@@ -6,7 +6,7 @@
  * prompt orchestration, compact orchestration, approval response dispatch,
  * cancel/clear/release plumbing and the pendingApprovals registry were
  * line-for-line duplicated with only constants/field names differing
- * (2026-09 round-2 simplification). This base absorbs them; what stays in
+ * (round-2 simplification). This base absorbs them; what stays in
  * subclasses:
  *   - applyTurnSettings: mode/model下发 semantics differ (kimi unconditional,
  *     opencode conditional on cached values)
@@ -80,7 +80,7 @@ export declare abstract class BaseAcpRunner<TTranslator extends BaseAcpTranslato
      * 自身半死：opencode v2 的 location 在每轮拉起的 `opencode acp` 子进程里 boot，
      * boot 期间后台服务不可用会让它长期停在未激活，后续轮次复用同一连接只会重复
      * 失败——用户重启 opencode service 也治不好，因为连接缓存在本进程里
-     * （2026-10-30 现场：4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
+     * （4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
      * 后下一轮重新 spawn，拿到的是新进程的新状态。
      *
      * 只对声明为可重试的错误生效：kimi 等沿用默认 `isRetryableSessionSetupError`
@@ -94,6 +94,9 @@ export declare abstract class BaseAcpRunner<TTranslator extends BaseAcpTranslato
     protected clearTurnState(): void;
     protected releaseConnection(cwd: string): Promise<void>;
     protected notifyIdle(cwd: string): void;
+    protected notifyConnectionActivity(cwd: string): void;
+    /** Wire the acquired client's hooks into the turn dispatcher (anchor-guarded). */
+    private installTurnHooks;
     protected disposeConnections(): Promise<void>;
     /**
      * Respond to an approval server request. `response` is the bridge

package/dist/runner/common/acp/base-acp-runner.js

@@ -65,7 +65,7 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
      * 自身半死：opencode v2 的 location 在每轮拉起的 `opencode acp` 子进程里 boot，
      * boot 期间后台服务不可用会让它长期停在未激活，后续轮次复用同一连接只会重复
      * 失败——用户重启 opencode service 也治不好，因为连接缓存在本进程里
-     * （2026-10-30 现场：4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
+     * （4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
      * 后下一轮重新 spawn，拿到的是新进程的新状态。
      *
      * 只对声明为可重试的错误生效：kimi 等沿用默认 `isRetryableSessionSetupError`
@@ -123,6 +123,21 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
     notifyIdle(cwd) {
         this.connectionManager.notifyIdle(cwd);
     }
+    notifyConnectionActivity(cwd) {
+        this.connectionManager.notifyActivity(cwd);
+    }
+    /** Wire the acquired client's hooks into the turn dispatcher (anchor-guarded). */
+    installTurnHooks(anchor) {
+        anchor.client.setHooks({
+            onNotification: this.forCurrentTurn(anchor, 'notification', (method, params) => this.handleNotification(method, params)),
+            onServerRequest: this.forCurrentTurn(anchor, 'server request', (id, method, params) => this.handleServerRequest(id, method, params)),
+            onClose: this.forCurrentTurn(anchor, 'connection close', () => {
+                getLogger().warn(`[${this.logTag}] client connection closed`);
+                this.onConnectionClosed();
+                this.failTurn(this.connectionClosedMessage);
+            }),
+        });
+    }
     async disposeConnections() {
         await this.beforeDisposeConnections();
         await this.connectionManager.disposeAll();
@@ -201,36 +216,12 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
      * session/resume (existing sessionId) → applyTurnSettings → session/prompt.
      */
     async setupTurn(message, opts) {
-        // 本轮回调归属锚点：代际 + client 都不可变。旧轮迟到的 prompt
-        // 结果/通知在新轮开始时 stopRequested 已被重置，只有这两个值能识别它。
-        const generation = this.turnGeneration;
-        const client = await this.connectionManager.acquire(opts.cwd);
-        this.connectionManager.notifyActivity(opts.cwd);
-        this.currentClient = client;
+        // 本轮回调归属锚点（代际 + client）由 acquireForTurn 捕获：旧轮迟到的
+        // prompt 结果/通知在新轮开始时 stopRequested 已被重置，只有这对值能识别它。
+        const anchor = await this.acquireForTurn(opts.cwd, () => this.connectionManager.acquire(opts.cwd));
         this.onConnectionAcquired(opts);
-        client.setHooks({
-            onNotification: (method, params) => {
-                if (!this.isCurrentTurn(generation, client)) {
-                    getLogger().debug(`[${this.logTag}] dropped notification from a finished turn`);
-                    return;
-                }
-                this.handleNotification(method, params);
-            },
-            onServerRequest: (id, method, params) => {
-                if (!this.isCurrentTurn(generation, client)) {
-                    getLogger().debug(`[${this.logTag}] dropped server request from a finished turn`);
-                    return;
-                }
-                this.handleServerRequest(id, method, params);
-            },
-            onClose: () => {
-                if (!this.isCurrentTurn(generation, client))
-                    return;
-                getLogger().warn(`[${this.logTag}] client connection closed`);
-                this.onConnectionClosed();
-                this.failTurn(this.connectionClosedMessage);
-            },
-        });
+        this.installTurnHooks(anchor);
+        const { client } = anchor;
         let sessionId;
         if (opts.sessionId) {
             const resumeParams = {
@@ -267,19 +258,7 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
         this.promptSettled = false;
         const promptPromise = client.request('session/prompt', promptParams, Number.POSITIVE_INFINITY);
         this.promptSent = true;
-        promptPromise.then((result) => {
-            if (!this.isCurrentTurn(generation, client)) {
-                getLogger().debug(`[${this.logTag}] dropped late prompt result from a finished turn`);
-                return;
-            }
-            this.handlePromptResolved(result, translator, sessionId);
-        }, (err) => {
-            if (!this.isCurrentTurn(generation, client)) {
-                getLogger().debug(`[${this.logTag}] dropped late prompt rejection from a finished turn`);
-                return;
-            }
-            this.handlePromptRejected(err, translator, sessionId, '');
-        });
+        promptPromise.then(this.forCurrentTurn(anchor, 'late prompt result', (result) => this.handlePromptResolved(result, translator, sessionId)), this.forCurrentTurn(anchor, 'late prompt rejection', (err) => this.handlePromptRejected(err, translator, sessionId, '')));
     }
     /**
      * Run a compact operation on the current session: resume → '/compact'
@@ -287,29 +266,11 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
      */
     async *runCompact(_message, opts) {
         yield* this.executeTurn(opts, async () => {
-            const generation = this.turnGeneration;
-            const client = await this.connectionManager.acquire(opts.cwd);
-            this.connectionManager.notifyActivity(opts.cwd);
-            this.currentClient = client;
+            // 同 setupTurn：acquireForTurn 捕获代际锚点，installTurnHooks 守卫 dispatch。
+            const anchor = await this.acquireForTurn(opts.cwd, () => this.connectionManager.acquire(opts.cwd));
             this.onConnectionAcquired(opts);
-            client.setHooks({
-                onNotification: (method, params) => {
-                    if (!this.isCurrentTurn(generation, client))
-                        return;
-                    this.handleNotification(method, params);
-                },
-                onServerRequest: (id, method, params) => {
-                    if (!this.isCurrentTurn(generation, client))
-                        return;
-                    this.handleServerRequest(id, method, params);
-                },
-                onClose: () => {
-                    if (!this.isCurrentTurn(generation, client))
-                        return;
-                    this.onConnectionClosed();
-                    this.failTurn(this.connectionClosedMessage);
-                },
-            });
+            this.installTurnHooks(anchor);
+            const { client } = anchor;
             const sessionId = opts.sessionId;
             if (!sessionId) {
                 throw new Error('compact requires a sessionId');

package/dist/runner/common/acp/base-translator.d.ts

@@ -4,7 +4,7 @@
  * Both agents' session/update notification envelopes, prompt-response
  * stopReason mapping, tool_call/tool_call_update normalization, usage_update
  * occupancy bookkeeping and self-produced turn_started events are
- * line-for-line identical — extracted here in the 2026-09 round-2
+ * line-for-line identical — extracted here in the round-2
  * simplification. What genuinely diverges is the content channel:
  * kimi accumulates wire deltas into turn_diff snapshots (snapshot semantics,
  * see KimiAcpTranslator header), opencode forwards `assistant` deltas
@@ -21,6 +21,16 @@
  */
 import type { AgentEvent, ApprovalRequestedEvent, ApprovalView, ResultEvent, TurnStartedEvent } from '../../types.js';
 import { type AgentMessageChunkEvent, type AgentThoughtChunkEvent, type ToolCallEvent, type ToolCallUpdateEvent, type UsageUpdateEvent, type RequestPermissionParams, type AcpPlanEvent } from './protocol-types.js';
+/**
+ * Plan entries → 「图标 + 标题」markdown 清单（每行一条，`\n` join）。
+ * ACP 与 codex 双抄收编（R5）；subtitle 拼接、trim、空清单语义等差异留在
+ * 各自调用点。
+ */
+export declare function renderPlanMarkdown(entries: ReadonlyArray<{
+    title: string;
+    subtitle?: string;
+    status?: string;
+}>): string;
 /** Self-produced turn_started event (no wire equivalent — produced on prompt start). */
 export type AcpTurnStartedEvent = TurnStartedEvent;
 /**
@@ -58,7 +68,7 @@ export declare abstract class BaseAcpTranslator {
     /**
      * Latest streaming-args text per tool call (keyed by wire toolCallId).
      * kimi ACP sends the permission request BEFORE tool.call.started (verified
-     * live against kimi 0.42.0, 2026-09-13): the request_permission toolCall
+     * against kimi 0.42.0): the request_permission toolCall
      * carries only title + a truncated summary in content, NO rawInput — the
      * full args only ever reach the client as accumulated text in the
      * tool_call/tool_call_update streaming deltas. Tracking them here lets the

package/dist/runner/common/acp/base-translator.js

@@ -12,6 +12,32 @@ const KIND_TO_TOOL = {
     search: 'Grep',
     fetch: 'WebFetch',
 };
+/**
+ * Plan 条目 status → 渲染图标。未知/缺省 status 一律按 pending 渲染——
+ * 两处调用点（ACP handlePlan / codex handleTurnPlanUpdated）注释都点名防
+ * wire 枚举漂移，新增枚举值时只改这张表。
+ */
+const PLAN_STATUS_ICONS = {
+    completed: '✅',
+    in_progress: '🔄',
+    pending: '⬜',
+    error: '❌',
+};
+/**
+ * Plan entries → 「图标 + 标题」markdown 清单（每行一条，`\n` join）。
+ * ACP 与 codex 双抄收编（R5）；subtitle 拼接、trim、空清单语义等差异留在
+ * 各自调用点。
+ */
+export function renderPlanMarkdown(entries) {
+    return entries
+        .map((entry) => {
+        const status = entry.status && entry.status in PLAN_STATUS_ICONS
+            ? entry.status
+            : 'pending';
+        return `${PLAN_STATUS_ICONS[status]} ${entry.title}${entry.subtitle ? ` — ${entry.subtitle}` : ''}`;
+    })
+        .join('\n');
+}
 /**
  * Join the text payloads of a tool_call(/_update) content array
  * (`[{type:'content', content:{type:'text', text}}]` entries). Returns
@@ -59,7 +85,7 @@ export class BaseAcpTranslator {
     /**
      * Latest streaming-args text per tool call (keyed by wire toolCallId).
      * kimi ACP sends the permission request BEFORE tool.call.started (verified
-     * live against kimi 0.42.0, 2026-09-13): the request_permission toolCall
+     * against kimi 0.42.0): the request_permission toolCall
      * carries only title + a truncated summary in content, NO rawInput — the
      * full args only ever reach the client as accumulated text in the
      * tool_call/tool_call_update streaming deltas. Tracking them here lets the
@@ -213,16 +239,12 @@ export class BaseAcpTranslator {
      * completed）。基类具体方法：kimi/opencode wire 结构相同，直接复用。
      */
     handlePlan(event) {
-        const ICON = { completed: '✅', in_progress: '🔄', pending: '⬜', error: '❌' };
         const entries = Array.isArray(event.entries) ? event.entries : [];
-        const markdown = entries
-            .map((e) => {
+        const markdown = renderPlanMarkdown(entries.map((e) => {
             const entry = e;
-            const status = entry.status && entry.status in ICON ? entry.status : 'pending';
-            return `${ICON[status]} ${entry.content ?? ''}`;
-        })
-            .join('\n')
-            .trim();
+            // ACP 条目的正文字段是 content（codex 是 title），无 subtitle。
+            return { title: entry.content ?? '', status: entry.status };
+        })).trim();
         if (!markdown)
             return [];
         return [{ type: 'plan', plan: markdown, timestamp: new Date().toISOString() }];

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

@@ -238,7 +238,7 @@ export interface PermissionOption {
 export interface RequestPermissionParams {
     sessionId: string;
     /**
-     * Approval target. Divergence by server (2026-09-13 live probes):
+     * Approval target. Divergence by server:
      *  - kimi 0.42: {toolCallId, title: toolName, content: [truncated summary
      *    text]} — NO rawInput; the approval gate fires BEFORE tool.call.started,
      *    so the full args only exist in the pre-approval tool_call/_update

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

@@ -43,7 +43,7 @@ export const RpcErrorCode = {
 // =============================================================================
 // Notifications (server → client, via session/update)
 // Shape source: kimi-code/packages/acp-server/src/events-map.ts
-//   (each constructor below) + 2026-08-15 live smoke test against kimi 0.36.0
+//   (each constructor below) + verified against kimi 0.36.0
 //
 // REAL envelope: {sessionId, update: {sessionUpdate: '<kind>', ...}}.
 // The discriminator field is `update.sessionUpdate` — there is NO nested
@@ -72,7 +72,7 @@ export const SessionEventType = {
 // Server Requests (approval — reverse RPC)
 // Shape source: kimi-code/packages/acp-server/src/approval.ts:28-29
 //   options: [{optionId, name, kind}]; optionId is opaque, echo back as-is
-//   + 2026-08-15 live smoke test: approve_once / approve_always / reject
+//   + verified against kimi 0.36.0: approve_once / approve_always / reject
 // =============================================================================
 export const ServerRequestMethod = {
     REQUEST_PERMISSION: 'session/request_permission',

package/dist/runner/common/connection-based-runner.d.ts

@@ -18,6 +18,18 @@ import type { AgentKind } from '../../agent-kinds.js';
 import type { AgentSessionReader } from '../../session-contract.js';
 import type { AgentEvent, AgentRunner, AgentStatusInfo, SpawnOptions } from '../types.js';
 import type { AgentStopper } from '../../platform/agent-stopper.js';
+/**
+ * 本轮回调的归属锚点（generation + client），由 {@link ConnectionBasedRunner.acquireForTurn}
+ * 捕获。两个值在整轮内不可变：旧轮迟到的回调（prompt 结果 / 通知 / onClose）在
+ * 新轮开始时 `stopRequested` 已被重置，只有这对值能识别它们——pi 的教训是旧 client
+ * 上残留的上一轮 onClose 闭包会把假错误推进新 turn 的共享队列（用户消息未发出即
+ * 丢失），迟到的 agent_settled 同理（新 turn 空转立即「成功」）。所有 hook 的事件
+ * 落地前必须过 {@link ConnectionBasedRunner.isCurrentTurn} 守卫。
+ */
+export interface TurnAnchor<TClient> {
+    readonly client: TClient;
+    readonly generation: number;
+}
 export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent> implements AgentRunner {
     readonly kind: AgentKind;
     readonly sessionReader: AgentSessionReader;
@@ -115,7 +127,7 @@ export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent
     /**
      * Mark this runner as evicted from the bridge's runner cache while a run may
      * still be holding/creating connections on it (queue-advance race during
-     * interruptCurrentRun's await window, 2026-10-11). The active run's finally
+     * interruptCurrentRun's await window). The active run's finally
      * disposes connections eagerly instead of arming the idle TTL timer —
      * otherwise the agent server process lingers for up to 30 minutes holding
      * its session write lock (codex: "thread already has an active writer").
@@ -145,6 +157,25 @@ export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent
      * server request 一律只记 debug，不得进入共享 notificationQueue。
      */
     protected isCurrentTurn(generation: number, client: TClient | null): boolean;
+    /**
+     * Acquire the per-turn connection and capture the callback anchor
+     * ({@link TurnAnchor}): acquire → activity ping → currentClient → anchor.
+     * Shared preamble of every setupTurn / runCompact; the acquired anchor is
+     * what the turn's hooks (and prompt-settle callbacks) validate against.
+     *
+     * `acquire` is a closure so subclasses keep their own acquire signatures
+     * (pi passes the spawn-bound `{ sessionId }`).
+     */
+    protected acquireForTurn(cwd: string, acquire: () => Promise<TClient>): Promise<TurnAnchor<TClient>>;
+    /** Per-cwd activity ping on the subclass connection manager (mirror of notifyIdle). */
+    protected abstract notifyConnectionActivity(cwd: string): void;
+    /**
+     * Wrap a per-turn callback with the isCurrentTurn guard: events from a
+     * finished turn are dropped with a debug log and never reach the turn
+     * dispatcher. 6 处守卫原有的日志粒度不一（ACP setupTurn 记 debug，其余静默），
+     * 统一为最详细版本：dropped 一律 debug，便于事后追溯。
+     */
+    protected forCurrentTurn<A extends unknown[]>(anchor: TurnAnchor<TClient>, label: string, handler: (...args: A) => void): (...args: A) => void;
     protected failTurn(message: string): void;
     protected resetRunState(): void;
     /** Release the connection + detach stale client hooks after a lost connection. */