lark-remote 0.5.19 → 0.5.21

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

@@ -8,14 +8,268 @@
  * 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
-// =============================================================================
+/** 权限 profile → 去重后的权限项列表（entries 优先，legacy read/write 兜底）。 */
+function pushFsEntries(items, profile) {
+    // entries 是结构化形式（[{ path, access }]），read/write 是 legacy 字符串数组。
+    for (const entry of profile.fileSystem?.entries ?? []) {
+        if (entry.access === 'read' || entry.access === 'write') {
+            items.push({
+                id: `fs-${entry.access}:${entry.path}`,
+                label: `${entry.access === 'read' ? 'Read' : 'Write'}: ${entry.path}`,
+                target: { kind: entry.access === 'read' ? 'fsRead' : 'fsWrite', path: entry.path },
+                selected: false,
+            });
+        }
+    }
+}
+/** legacy read/write 字符串数组 → 权限项（按 id 去重，entries 优先）。 */
+function pushLegacyPaths(items, profile, access) {
+    const paths = access === 'read' ? profile.fileSystem?.read : profile.fileSystem?.write;
+    for (const path of paths ?? []) {
+        const id = `fs-${access}:${path}`;
+        if (!items.some((i) => i.id === id)) {
+            items.push({
+                id,
+                label: `${access === 'read' ? 'Read' : 'Write'}: ${path}`,
+                target: { kind: access === 'read' ? 'fsRead' : 'fsWrite', path },
+                selected: false,
+            });
+        }
+    }
+}
+/** network.enabled 整体开关 → 单条权限项。 */
+function pushNetworkItem(items, profile) {
+    if (profile.network?.enabled) {
+        // 真实 AdditionalNetworkPermissions 只有 enabled 布尔开关（整体网络访问）。
+        items.push({
+            id: 'net:all',
+            label: '网络访问',
+            target: { kind: 'network' },
+            selected: false,
+        });
+    }
+}
+/** 权限 profile → 去重后的权限项列表（entries 优先，legacy read/write 兜底）。 */
+function permissionItemsOf(profile) {
+    const items = [];
+    pushFsEntries(items, profile);
+    pushLegacyPaths(items, profile, 'read');
+    pushLegacyPaths(items, profile, 'write');
+    pushNetworkItem(items, profile);
+    return items;
+}
+/** agentMessage 权威全文与已流式内容不一致 → 补发快照。 */
+function agentMessageFallback(state, item, ids, events) {
+    const text = item.text ?? '';
+    if (text && state.textByItem.get(item.id) !== text) {
+        state.textByItem.set(item.id, text);
+        const final = item.phase === 'final_answer';
+        events.push(final
+            ? {
+                type: 'final_answer',
+                text,
+                itemId: item.id,
+                complete: true,
+                timestamp: state.now(),
+            }
+            : state.turnDiff(ids, { text, itemId: item.id, complete: true }));
+    }
+}
+/** plan 权威文本与已流式内容不一致 → 补发快照。 */
+function planFallback(state, item, ids, events) {
+    const planText = item.text ?? '';
+    if (planText && state.planByItem.get(item.id) !== planText) {
+        state.planByItem.set(item.id, planText);
+        events.push(state.turnDiff(ids, { plan: planText, itemId: item.id, complete: true }));
+    }
+}
+const TURN_COMPLETED_FALLBACK_HANDLERS = new Map([
+    ['agentMessage', agentMessageFallback],
+    ['plan', planFallback],
+]);
+/** turn.completed 的权威 items 与已流式内容不一致时补发 item 级快照。 */
+function turnCompletedFallbackEvents(state, params) {
+    const events = [];
+    const turn = params?.turn;
+    const ids = {
+        threadId: params?.threadId ?? state.threadId,
+        turnId: params?.turn?.id ?? state.turnId,
+    };
+    for (const item of turn?.items ?? []) {
+        TURN_COMPLETED_FALLBACK_HANDLERS.get(item.type)?.(state, item, ids, events);
+    }
+    return events;
+}
+/** 终态 ResultEvent：interrupted / failed / success 保持各自 subtype。 */
+function resultEventOf(state, params) {
+    const turn = params?.turn;
+    const usage = {
+        input_tokens: state.usage.inputTokens,
+        output_tokens: state.usage.outputTokens,
+        cache_read_tokens: state.usage.cachedInputTokens,
+        total_tokens: state.usage.totalTokens,
+        context_limit: state.usage.contextLimit,
+    };
+    const subtype = turn?.status === 'failed'
+        ? 'error'
+        : turn?.status === 'interrupted'
+            ? 'interrupted'
+            : 'success';
+    return {
+        type: 'result',
+        subtype,
+        session_id: state.threadId,
+        usage,
+        errorMessage: turn?.error?.message,
+    };
+}
+function fileChangeCompleted(state, params) {
+    // 查表已按 type 分派；此处显式断言还原原分支内的类型收窄。
+    const item = params.item;
+    if (!Array.isArray(item.changes))
+        return { events: [], stop: false };
+    // 权威文件变更（含聚合后的 diff）；以快照语义替换本 item 的变更列表。
+    state.fileChangeItems.set(item.id, item.changes);
+    return {
+        events: [
+            state.turnDiff(params, {
+                fileChanges: normalizeFileChanges(item.changes),
+                itemId: item.id,
+                complete: true,
+            }),
+        ],
+        stop: true,
+    };
+}
+function reasoningCompleted(state, params) {
+    // 查表已按 type 分派；此处显式断言还原原分支内的类型收窄。
+    const item = params.item;
+    const content = Array.isArray(item.content) ? item.content : [];
+    const summary = Array.isArray(item.summary) ? item.summary : [];
+    if (content.length > 0 || summary.length > 0) {
+        // 权威内容：summary 优先展示，content 段落保留（per-item 替换）。
+        const entry = state.reasoningEntry(item.id);
+        entry.content = new Map(content.map((c, i) => [i, c]));
+        entry.summary = summary.join('\n');
+        return {
+            events: [
+                state.turnDiff(params, {
+                    reasoning: state.reasoningSnapshotFor(entry),
+                    itemId: item.id,
+                    complete: true,
+                }),
+            ],
+            stop: true,
+        };
+    }
+    return { events: [], stop: false };
+}
+function commandExecutionCompleted(state, params) {
+    const item = params.item;
+    // 无 outputDelta 流时（短命令），用 item/completed 的聚合输出兜底；
+    // 已流式输出则以累积快照收尾（complete 语义标记工具完成）。
+    const accumulated = state.toolOutputByItem.get(item.id) ?? '';
+    const aggregated = item.aggregatedOutput;
+    const authoritative = aggregated != null ? String(aggregated) : accumulated;
+    // 从未 item/started 且无任何输出（如审批被拒的空命令）→ 不产生工具块，
+    // 避免完成时刻凭空冒出一个空命令块。
+    if (!authoritative && !state.startedToolItems.has(item.id)) {
+        return { events: [], stop: true };
+    }
+    state.toolOutputByItem.set(item.id, authoritative);
+    // 信息保真 完成事件同样携带身份，并在发出后释放 meta。
+    const meta = state.toolItemMeta.get(item.id);
+    state.toolItemMeta.delete(item.id);
+    return {
+        events: [
+            state.turnDiff(params, {
+                toolOutput: authoritative,
+                ...meta,
+                itemId: item.id,
+                complete: true,
+                toolStatus: commandExecutionStatusToToolStatus(item.status),
+            }),
+        ],
+        stop: true,
+    };
+}
+function agentMessageCompleted(state, params) {
+    const item = params.item;
+    // item/completed 的 agentMessage 带权威全文（text 字段）；以 item 级
+    // 快照收尾，run-state 按 itemId 原地替换，保证内容收敛到权威值。
+    const text = item.text ?? '';
+    const accumulated = state.textByItem.get(item.id) ?? '';
+    // 空最终文本但已有流式内容（异常边界）→ 用累积内容收尾，补齐 completedAt；
+    // 完全无内容则没有块可完成，不发事件。
+    if (text || accumulated) {
+        const finalText = text || accumulated;
+        state.textByItem.set(item.id, finalText);
+        if (item.phase === 'final_answer' ||
+            state.finalTextItems.has(item.id)) {
+            state.finalTextItems.delete(item.id);
+            return {
+                events: [
+                    {
+                        type: 'final_answer',
+                        text: finalText,
+                        itemId: item.id,
+                        complete: true,
+                        timestamp: state.now(),
+                    },
+                ],
+                stop: true,
+            };
+        }
+        return {
+            events: [state.turnDiff(params, { text: finalText, itemId: item.id, complete: true })],
+            stop: true,
+        };
+    }
+    return { events: [], stop: false };
+}
+function planCompleted(state, params) {
+    const item = params.item;
+    const text = item.text ?? '';
+    if (text) {
+        state.planByItem.set(item.id, text);
+        return {
+            events: [state.turnDiff(params, { plan: text, itemId: item.id, complete: true })],
+            stop: true,
+        };
+    }
+    return { events: [], stop: false };
+}
+/** 终态分支查表：命中且定案则直接返回，否则落到通用工具收尾。 */
+const ITEM_COMPLETED_HANDLERS = new Map([
+    ['fileChange', fileChangeCompleted],
+    ['reasoning', reasoningCompleted],
+    ['commandExecution', commandExecutionCompleted],
+    ['agentMessage', agentMessageCompleted],
+    ['plan', planCompleted],
+]);
+/** 无专属 completed 分支的工具 item 也必须收尾（避免工具块永挂 running）。 */
+function finalizeUnhandledToolItem(state, params) {
+    const item = params.item;
+    if (state.startedToolItems.has(item.id)) {
+        const meta = state.toolItemMeta.get(item.id);
+        state.toolItemMeta.delete(item.id);
+        state.startedToolItems.delete(item.id);
+        return [
+            state.turnDiff(params, {
+                toolOutput: state.toolOutputByItem.get(item.id) ?? '',
+                ...meta,
+                itemId: item.id,
+                complete: true,
+            }),
+        ];
+    }
+    return [];
+}
 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`. */
@@ -132,67 +386,9 @@ export class CodexAppServerTranslator {
      * Called when the turn completes.
      */
     handleTurnCompleted(params) {
-        const turn = params?.turn;
-        this.turnStatus = turn?.status ?? 'completed';
-        const events = [];
-        // 兜底：turn.items 里权威 agentMessage / plan item 与已流式内容不一致或
-        // 未发过（如 itemsView 摘要只含部分 item）时，补发 item 级快照。已一致则
-        // 跳过，避免冗余事件（run-state 按 itemId 原地替换、幂等）。
-        for (const item of turn?.items ?? []) {
-            if (item.type === 'agentMessage') {
-                const text = item.text ?? '';
-                if (text && this.textByItem.get(item.id) !== text) {
-                    this.textByItem.set(item.id, text);
-                    const final = item.phase === 'final_answer';
-                    events.push(final
-                        ? {
-                            type: 'final_answer',
-                            text,
-                            itemId: item.id,
-                            complete: true,
-                            timestamp: this.now(),
-                        }
-                        : this.turnDiffEvent({
-                            threadId: params?.threadId ?? this.threadId,
-                            turnId: params?.turn?.id ?? this.turnId,
-                        }, { text, itemId: item.id, complete: true }));
-                }
-            }
-            else if (item.type === 'plan') {
-                // plan 是 EXPERIMENTAL 文本增量，不保证与最终 plan item 一致；
-                // turn/completed 的权威 plan item 以此兜底校正。
-                const planText = item.text ?? '';
-                if (planText && this.planByItem.get(item.id) !== planText) {
-                    this.planByItem.set(item.id, planText);
-                    events.push(this.turnDiffEvent({
-                        threadId: params?.threadId ?? this.threadId,
-                        turnId: params?.turn?.id ?? this.turnId,
-                    }, { plan: planText, itemId: item.id, complete: true }));
-                }
-            }
-        }
-        const usage = {
-            input_tokens: this.usage.inputTokens,
-            output_tokens: this.usage.outputTokens,
-            cache_read_tokens: this.usage.cachedInputTokens,
-            total_tokens: this.usage.totalTokens,
-            context_limit: this.usage.contextLimit,
-        };
-        // 语义保真：interrupted（审批超时/取消、/stop）与 failed（Agent 真失败）
-        // 是性质不同的终态。interrupted 走独立 subtype，卡片不再误报「Agent 返回
-        // 错误结果」；failed 保持 error。
-        const subtype = turn?.status === 'failed'
-            ? 'error'
-            : turn?.status === 'interrupted'
-                ? 'interrupted'
-                : 'success';
-        events.push({
-            type: 'result',
-            subtype,
-            session_id: this.threadId,
-            usage,
-            errorMessage: turn?.error?.message,
-        });
+        const state = this.translatorState();
+        const events = turnCompletedFallbackEvents(state, params);
+        events.push(resultEventOf(state, params));
         return events;
     }
     /**
@@ -204,12 +400,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 +412,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
@@ -282,122 +471,12 @@ export class CodexAppServerTranslator {
         return [];
     }
     handleItemCompleted(params) {
-        const item = params.item;
-        if (item.type === 'fileChange' && Array.isArray(item.changes)) {
-            // 权威文件变更（含聚合后的 diff）；以快照语义替换本 item 的变更列表。
-            this.fileChangeItems.set(item.id, item.changes);
-            return [
-                this.turnDiffEvent(params, {
-                    fileChanges: normalizeFileChanges(item.changes),
-                    itemId: item.id,
-                    complete: true,
-                }),
-            ];
-        }
-        if (item.type === 'reasoning') {
-            const content = Array.isArray(item.content) ? item.content : [];
-            const summary = Array.isArray(item.summary) ? item.summary : [];
-            if (content.length > 0 || summary.length > 0) {
-                // 权威内容：summary 优先展示，content 段落保留（per-item 替换）。
-                const entry = this.reasoningEntry(item.id);
-                entry.content = new Map(content.map((c, i) => [i, c]));
-                entry.summary = summary.join('\n');
-                return [
-                    this.turnDiffEvent(params, {
-                        reasoning: this.reasoningSnapshotFor(entry),
-                        itemId: item.id,
-                        complete: true,
-                    }),
-                ];
-            }
-        }
-        if (item.type === 'commandExecution') {
-            // 无 outputDelta 流时（短命令），用 item/completed 的聚合输出兜底；
-            // 已流式输出则以累积快照收尾（complete 语义标记工具完成）。
-            const accumulated = this.toolOutputByItem.get(item.id) ?? '';
-            const aggregated = item.aggregatedOutput;
-            const authoritative = aggregated != null ? String(aggregated) : accumulated;
-            // 从未 item/started 且无任何输出（如审批被拒的空命令）→ 不产生工具块，
-            // 避免完成时刻凭空冒出一个空命令块。
-            if (!authoritative && !this.startedToolItems.has(item.id)) {
-                return [];
-            }
-            this.toolOutputByItem.set(item.id, authoritative);
-            // 信息保真 完成事件同样携带身份，并在发出后释放 meta。
-            const meta = this.toolItemMeta.get(item.id);
-            this.toolItemMeta.delete(item.id);
-            return [
-                this.turnDiffEvent(params, {
-                    toolOutput: authoritative,
-                    ...meta,
-                    itemId: item.id,
-                    complete: true,
-                    toolStatus: commandExecutionStatusToToolStatus(item.status),
-                }),
-            ];
-        }
-        if (item.type === 'agentMessage') {
-            // item/completed 的 agentMessage 带权威全文（text 字段）；以 item 级
-            // 快照收尾，run-state 按 itemId 原地替换，保证内容收敛到权威值。
-            const text = item.text ?? '';
-            const accumulated = this.textByItem.get(item.id) ?? '';
-            // 空最终文本但已有流式内容（异常边界）→ 用累积内容收尾，补齐 completedAt；
-            // 完全无内容则没有块可完成，不发事件。
-            if (text || accumulated) {
-                const finalText = text || accumulated;
-                this.textByItem.set(item.id, finalText);
-                if (item.phase === 'final_answer' ||
-                    this.finalTextItems.has(item.id)) {
-                    this.finalTextItems.delete(item.id);
-                    return [
-                        {
-                            type: 'final_answer',
-                            text: finalText,
-                            itemId: item.id,
-                            complete: true,
-                            timestamp: this.now(),
-                        },
-                    ];
-                }
-                return [
-                    this.turnDiffEvent(params, {
-                        text: finalText,
-                        itemId: item.id,
-                        complete: true,
-                    }),
-                ];
-            }
-        }
-        if (item.type === 'plan') {
-            const text = item.text ?? '';
-            if (text) {
-                this.planByItem.set(item.id, text);
-                return [
-                    this.turnDiffEvent(params, {
-                        plan: text,
-                        itemId: item.id,
-                        complete: true,
-                    }),
-                ];
-            }
-        }
-        // 信息保真 webSearch/mcpToolCall/dynamicToolCall 等无专属 completed 分支的
-        // 工具 item 也必须收尾——否则 run-state 侧工具块永挂 running（无 completedAt/终态），
-        // toolItemMeta 泄漏到下个 turn 的 clear() 才被释放。
-        if (this.startedToolItems.has(item.id)) {
-            const meta = this.toolItemMeta.get(item.id);
-            this.toolItemMeta.delete(item.id);
-            this.startedToolItems.delete(item.id);
-            return [
-                this.turnDiffEvent(params, {
-                    toolOutput: this.toolOutputByItem.get(item.id) ?? '',
-                    ...meta,
-                    itemId: item.id,
-                    complete: true,
-                }),
-            ];
-        }
-        return [];
+        const state = this.translatorState();
+        const handler = ITEM_COMPLETED_HANDLERS.get(params.item.type);
+        const result = handler?.(state, params);
+        if (result?.stop)
+            return result.events;
+        return finalizeUnhandledToolItem(state, params);
     }
     handleReasoningTextDelta(params) {
         const index = params.contentIndex ?? 0;
@@ -497,14 +576,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) {
@@ -743,48 +817,7 @@ export class CodexAppServerTranslator {
         ];
     }
     buildPermissionItems(profile) {
-        const items = [];
-        // entries 是结构化形式（[{ path, access }]），read/write 是 legacy 字符串数组。
-        for (const entry of profile.fileSystem?.entries ?? []) {
-            if (entry.access === 'read' || entry.access === 'write') {
-                items.push({
-                    id: `fs-${entry.access}:${entry.path}`,
-                    label: `${entry.access === 'read' ? 'Read' : 'Write'}: ${entry.path}`,
-                    target: { kind: entry.access === 'read' ? 'fsRead' : 'fsWrite', path: entry.path },
-                    selected: false,
-                });
-            }
-        }
-        for (const path of profile.fileSystem?.read ?? []) {
-            if (!items.some((i) => i.id === `fs-read:${path}`)) {
-                items.push({
-                    id: `fs-read:${path}`,
-                    label: `Read: ${path}`,
-                    target: { kind: 'fsRead', path },
-                    selected: false,
-                });
-            }
-        }
-        for (const path of profile.fileSystem?.write ?? []) {
-            if (!items.some((i) => i.id === `fs-write:${path}`)) {
-                items.push({
-                    id: `fs-write:${path}`,
-                    label: `Write: ${path}`,
-                    target: { kind: 'fsWrite', path },
-                    selected: false,
-                });
-            }
-        }
-        if (profile.network?.enabled) {
-            // 真实 AdditionalNetworkPermissions 只有 enabled 布尔开关（整体网络访问）。
-            items.push({
-                id: 'net:all',
-                label: '网络访问',
-                target: { kind: 'network' },
-                selected: false,
-            });
-        }
-        return items;
+        return permissionItemsOf(profile);
     }
     /** Get (or lazily create) the reasoning accumulator for one item. */
     reasoningEntry(itemId) {
@@ -807,6 +840,26 @@ export class CodexAppServerTranslator {
     now() {
         return new Date().toISOString();
     }
+    /** 把实例状态打包成模块级 handler 可用的显式快照（.bind 保留 this 绑定）。 */
+    translatorState() {
+        return {
+            fileChangeItems: this.fileChangeItems,
+            reasoningByItem: this.reasoningByItem,
+            toolOutputByItem: this.toolOutputByItem,
+            toolItemMeta: this.toolItemMeta,
+            startedToolItems: this.startedToolItems,
+            textByItem: this.textByItem,
+            finalTextItems: this.finalTextItems,
+            planByItem: this.planByItem,
+            usage: this.usage,
+            threadId: this.threadId,
+            turnId: this.turnId,
+            turnDiff: this.turnDiffEvent.bind(this),
+            now: this.now.bind(this),
+            reasoningEntry: this.reasoningEntry.bind(this),
+            reasoningSnapshotFor: this.reasoningSnapshotFor.bind(this),
+        };
+    }
 }
 /** Normalize protocol change kind to the ApprovalView kind vocabulary. */
 function normalizeChangeKind(kind) {

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