lark-remote 0.1.13 → 0.2.0

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

@@ -6,20 +6,26 @@
  * → synthetic init → session/prompt → consume session/update notifications
  * until prompt settles → result event.
  *
- * Structurally aligned with codex AppServerRunner (design doc §3.1) via the
- * shared ConnectionBasedRunner base: same notification queue + waitResolve
- * pattern, same forceFinish/stopRequested semantics, same turn idle timeout,
- * same ConnectionLostError retry.
+ * Turn/connection/compact/approval orchestration lives in BaseAcpRunner.
+ * Kimi-specific parts:
+ * - compaction is a BACKGROUND task: after the compact prompt settles, poll
+ *   wire.jsonl for a NEW terminal compaction record (§5.2, never fake success)
+ * - terminal/* reverse RPC: kimi delegates Bash execution to the client —
+ *   this runner spawns one-shot local bash processes (handleTerminalRequest)
+ * - terminal-backed Bash tool notifications are filtered (bashToolCallIds) so
+ *   the run card doesn't get duplicate output-less Bash panels
+ * - AskUserQuestion flows through elicitation forms + a request_permission
+ *   question bridge (buildQuestionResponse)
  */
-import { spawn } from 'node:child_process';
+import { spawnProcess, mergeProcessEnv, useDetachedProcessGroup } from '../../../platform/spawn.js';
 import { StringDecoder } from 'node:string_decoder';
-import { ConnectionManager as KimiAcpConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
+import { ConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { KimiAcpTranslator } from './translator.js';
 import { NotificationMethod, RpcErrorCode, ServerRequestMethod, } from '../../common/acp/protocol-types.js';
 import { KIMI_APPROVAL_KINDS, buildAcpPermissionOutcome, } from '../../common/acp/protocol-helpers.js';
 import { mapAnswersByIndex } from '../../question-common.js';
 import { getLogger } from '../../../logger/index.js';
-import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
+import { BaseAcpRunner } from '../../common/acp/base-acp-runner.js';
 import { ProcessStopper } from '../../common/process-stopper.js';
 /** §5.2: compaction 等待的默认沉默超时（对齐 turnIdleTimeoutMs 默认值）。 */
 const COMPACT_IDLE_TIMEOUT_MS = 10 * 60_000;
@@ -126,15 +132,15 @@ function buildQuestionResponse(action, pending, response) {
 // =============================================================================
 // Runner
 // =============================================================================
-export class KimiAcpRunner extends ConnectionBasedRunner {
-    connectionManager;
-    currentTranslator = null;
-    activeSessionId = null;
-    model;
+export class KimiAcpRunner extends BaseAcpRunner {
     permissionMode;
     compactIdleTimeoutMs;
-    /** Pending approval requests: requestId → kind + view + options. */
-    pendingApprovals = new Map();
+    /**
+     * §5.2 compaction baseline: wire.jsonl records sampled by compactBaseline()
+     * BEFORE the compact prompt fires (reset per compact run). onCompactPromptFired
+     * derives both the terminal-count baseline and the total-count probe from it.
+     */
+    compactBaselineRecords = [];
     /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
     terminals = new Map();
     /** terminalId 自增序号（term-1, term-2, …）。 */
@@ -150,13 +156,7 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
     /** 当前 run 的 session cwd（terminal/create 未给 cwd 时回退用）。 */
     activeCwd = null;
     processStopper = new ProcessStopper({ graceMs: 2_000 });
-    /** Tracker for the in-flight prompt request — needed for cancellation. */
-    promptSettled = false;
     constructor(opts) {
-        super({ kind: opts.kind, sessionReader: opts.sessionReader }, opts.turnIdleTimeoutMs);
-        this.model = opts.model;
-        this.permissionMode = opts.permissionMode ?? 'manual';
-        this.compactIdleTimeoutMs = opts.compactIdleTimeoutMs ?? COMPACT_IDLE_TIMEOUT_MS;
         const managerOpts = {
             binary: opts.binary ?? 'kimi',
             args: opts.acpArgs ?? ['acp'],
@@ -183,7 +183,14 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
                 },
             },
         };
-        this.connectionManager = new KimiAcpConnectionManager(managerOpts);
+        super({
+            kind: opts.kind,
+            sessionReader: opts.sessionReader,
+            turnIdleTimeoutMs: opts.turnIdleTimeoutMs,
+        }, new ConnectionManager(managerOpts));
+        this.model = opts.model;
+        this.permissionMode = opts.permissionMode ?? 'manual';
+        this.compactIdleTimeoutMs = opts.compactIdleTimeoutMs ?? COMPACT_IDLE_TIMEOUT_MS;
     }
     get logTag() {
         return 'kimi-acp-runner';
@@ -194,172 +201,113 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
     get turnInterruptedErrorMessage() {
         return 'Kimi ACP turn interrupted';
     }
-    currentSessionId() {
-        return this.activeSessionId;
+    get connectionClosedMessage() {
+        return 'Kimi ACP connection closed';
     }
     shouldDeferStop() {
         return !this.promptSettled;
     }
-    async cancelCurrentTurn() {
-        if (!this.currentClient || !this.activeSessionId)
-            return;
+    createTranslator() {
+        return new KimiAcpTranslator();
+    }
+    async applyTurnSettings(client, sessionId) {
+        // CC-07: 下发配置的模型（provider/model）。session/new|resume 只带 cwd/mcpServers，
+        // 不带 model；不主动下发则实际跑 kimi 服务端默认模型。
+        // 仿 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
+        // session in manual and tool calls stall on unanswered approvals
+        // (live dark-test repro: approval_requested → idle timeout).
+        const modeParams = {
+            sessionId,
+            modeId: toAcpMode(this.permissionMode),
+        };
         try {
-            // session/cancel is a NOTIFICATION (no id, no response) per ACP spec.
-            const cancelParams = { sessionId: this.activeSessionId };
-            this.currentClient.notify('session/cancel', cancelParams);
+            await client.request('session/set_mode', modeParams);
         }
         catch (err) {
-            getLogger().warn(`[${this.logTag}] session/cancel failed: ${err.message}`);
+            getLogger().warn(`[${this.logTag}] session/set_mode failed (non-fatal): ${err.message}`);
         }
     }
-    clearTurnState() {
-        this.currentTranslator = null;
-        this.promptSettled = false;
-        this.activeSessionId = null;
-        this.activeCwd = null;
-    }
-    async releaseConnection(cwd) {
-        await this.connectionManager.release(cwd);
-    }
-    notifyIdle(cwd) {
-        this.connectionManager.notifyIdle(cwd);
-    }
-    async disposeConnections() {
-        // 关闭前 kill/release 所有存活 terminal，避免孤儿 bash 进程。
-        await this.cleanupTerminals();
-        await this.connectionManager.disposeAll();
-    }
     /**
-     * Run a compact operation on the current session.
-     *
-     * Design doc §6.1: acquire → session/resume → session/prompt with "/compact"
-     * text (builtin slash command, host intercepts) → consume notifications until
-     * prompt settles.
+     * §5.2: compaction is a BACKGROUND task — the prompt settles before the
+     * wire.jsonl terminal record lands. Baselines are captured BEFORE the
+     * compact prompt fires (see compactBaseline override — a begin record
+     * landing after the fire must count as new activity, not baseline), then
+     * wait for a NEW terminal (complete/apply → completed; cancel → cancelled)
+     * before producing the result. There is NO total timeout — silence beyond
+     * compactIdleTimeoutMs yields 'unknown' (never a fake success). Keeps the
+     * connection alive while the background compaction finishes — otherwise
+     * dispose/exit kills it and the record never lands (S5/S6 打回复现 /
+     * 2026-08-31 事故).
      */
-    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;
-            this.activeCwd = opts.cwd;
-            client.setHooks({
-                onNotification: (method, params) => this.handleNotification(method, params),
-                onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
-                onClose: () => {
-                    void this.cleanupTerminals();
-                    this.failTurn('Kimi ACP connection closed');
-                },
-            });
-            const sessionId = opts.sessionId;
-            if (!sessionId) {
-                throw new Error('compact requires a sessionId');
-            }
-            this.activeSessionId = sessionId;
-            // Cold-connection fallback: session/resume loads the session into memory.
-            // On a reused connection the session is already loaded — resume is
-            // idempotent and harmless; after connection rebuild it's required.
-            const resumeParams = {
-                sessionId,
-                cwd: opts.cwd,
-            };
-            await client.request('session/resume', resumeParams);
-            const translator = new KimiAcpTranslator();
-            translator.setOperationKind('compact');
-            this.currentTranslator = translator;
-            // Emit turn_started with operationKind='compaction' before the prompt
-            // (consumeTurn yields it while the background compaction runs).
-            const turnId = `compact-${Date.now()}`;
-            const turnStarted = translator.produceTurnStarted(sessionId, turnId);
-            this.currentTurnId = turnId;
-            this.pushEvents([turnStarted]);
-            // Send /compact as prompt text
-            const promptParams = {
-                sessionId,
-                prompt: [{ type: 'text', text: '/compact' }],
-            };
-            // §5.2: compaction is a BACKGROUND task — the prompt settles before the
-            // wire.jsonl terminal record lands. Baseline the terminal record count,
-            // fire the prompt without awaiting (notifications flow through
-            // consumeTurn), then wait for a NEW terminal (complete/apply →
-            // completed; cancel → cancelled) before producing the result. There is
-            // NO total timeout — silence beyond compactIdleTimeoutMs yields
-            // 'unknown' (never a fake success). Keeps the connection alive while the
-            // background compaction finishes — otherwise dispose/exit kills it and
-            // the record never lands (S5/S6 打回复现 / 2026-08-31 事故).
-            const compactionReader = this.sessionReader.readCompactionRecords;
-            const baselineRecords = compactionReader
-                ? compactionReader.call(this.sessionReader, sessionId, opts.cwd)
-                : [];
-            const baselineTerminalCount = baselineRecords.filter(isCompactionTerminalLike).length;
-            const baselineTotalCount = baselineRecords.length;
-            this.promptSettled = false;
-            // ACP holds the session/prompt response for the ENTIRE turn (unlike
-            // codex turn/start), so the RPC-level timeout must not apply here —
-            // turn liveness is guarded by the rolling idle watchdog instead.
-            const promptPromise = client.request('session/prompt', promptParams, Number.POSITIVE_INFINITY);
-            promptPromise.then(async (result) => {
-                this.promptSettled = true;
-                if (this.stopRequested)
-                    return; // already cancelled
-                if (compactionReader) {
-                    // §5.4 可选防线（日志探针）：prompt settle 后既无新 begin 也无新
-                    // terminal → compact 未被引擎接受（可能已在跑或被拒绝）。不解析
-                    // "already running" 文本、不影响卡片。
-                    const totalNow = compactionReader.call(this.sessionReader, sessionId, opts.cwd).length;
-                    if (totalNow === baselineTotalCount) {
-                        getLogger().warn(`[${this.logTag}] compact 未被引擎接受（无新 begin/terminal 记录，可能已在跑或被拒绝）`);
-                    }
-                    const outcome = await this.waitForCompactionTerminal(compactionReader, opts, baselineTerminalCount);
-                    if (this.forceFinish)
-                        return; // stopped while polling
-                    if (outcome === 'completed') {
-                        // 压缩完成：正常翻译 prompt 结果（subtype success）。
-                        const resultEvent = translator.handlePromptResponse(sessionId, result);
-                        this.pushEvents([resultEvent]);
-                    }
-                    else if (outcome === 'cancelled') {
-                        this.pushEvents([
-                            translator.produceErrorResult(sessionId, '压缩未完成：已被取消或压缩请求失败（可重试）'),
-                        ]);
-                    }
-                    else if (outcome === 'unknown') {
-                        this.pushEvents([
-                            translator.produceErrorResult(sessionId, `压缩状态未知：超过 ${formatIdleWindow(this.compactIdleTimeoutMs)} 未观察到完成/取消记录，压缩可能仍在后台进行`),
-                        ]);
-                    }
-                    // outcome === 'stopped'：不推 result，由 consumeTurn 的 interrupted 兜底。
+    compactBaseline(sessionId, opts) {
+        const compactionReader = this.sessionReader.readCompactionRecords;
+        this.compactBaselineRecords = compactionReader
+            ? compactionReader.call(this.sessionReader, sessionId, opts.cwd)
+            : [];
+        return this.compactBaselineRecords.length;
+    }
+    onCompactPromptFired(promptPromise, translator, sessionId, opts, baselineTotalCount) {
+        const compactionReader = this.sessionReader.readCompactionRecords;
+        // Derived from the pre-fire snapshot captured by compactBaseline() —
+        // re-reading here would race the prompt fire and misclassify new records.
+        const baselineTerminalCount = this.compactBaselineRecords.filter(isCompactionTerminalLike).length;
+        promptPromise.then(async (result) => {
+            this.promptSettled = true;
+            if (this.stopRequested)
+                return; // already cancelled
+            if (compactionReader) {
+                // §5.4 可选防线（日志探针）：prompt settle 后既无新 begin 也无新
+                // terminal → compact 未被引擎接受（可能已在跑或被拒绝）。不解析
+                // "already running" 文本、不影响卡片。
+                const totalNow = compactionReader.call(this.sessionReader, sessionId, opts.cwd).length;
+                if (totalNow === baselineTotalCount) {
+                    getLogger().warn(`[${this.logTag}] compact 未被引擎接受（无新 begin/terminal 记录，可能已在跑或被拒绝）`);
                 }
-                else {
+                const outcome = await this.waitForCompactionTerminal(compactionReader, opts, baselineTerminalCount);
+                if (this.forceFinish)
+                    return; // stopped while polling
+                if (outcome === 'completed') {
+                    // 压缩完成：正常翻译 prompt 结果（subtype success）。
                     const resultEvent = translator.handlePromptResponse(sessionId, result);
                     this.pushEvents([resultEvent]);
                 }
-            }, (err) => {
-                this.promptSettled = true;
-                if (this.stopRequested) {
-                    getLogger().warn(`[${this.logTag}] compact prompt rejected after stopRequested: ${err.message}`);
-                    return;
+                else if (outcome === 'cancelled') {
+                    this.pushEvents([
+                        translator.produceErrorResult(sessionId, '压缩未完成：已被取消或压缩请求失败（可重试）'),
+                    ]);
+                }
+                else if (outcome === 'unknown') {
+                    this.pushEvents([
+                        translator.produceErrorResult(sessionId, `压缩状态未知：超过 ${formatIdleWindow(this.compactIdleTimeoutMs)} 未观察到完成/取消记录，压缩可能仍在后台进行`),
+                    ]);
                 }
-                const resultEvent = translator.produceErrorResult(sessionId, err.message);
+                // outcome === 'stopped'：不推 result，由 consumeTurn 的 interrupted 兜底。
+            }
+            else {
+                const resultEvent = translator.handlePromptResponse(sessionId, result);
                 this.pushEvents([resultEvent]);
-            });
-        });
+            }
+        }, (err) => this.handlePromptRejected(err, translator, sessionId, 'compact'));
     }
-    /**
-     * Respond to an approval server request. `response` is the bridge
-     * ApprovalAction (`{ action: 'accept' | 'decline' | 'cancel' }`).
-     */
-    async respondApproval(requestId, response) {
-        const client = this.currentClient;
-        const pending = this.pendingApprovals.get(requestId);
-        if (!client || !pending)
-            return;
-        const action = response?.action ?? 'decline';
-        const acpResponse = pending.kind === 'question'
+    buildApprovalOutcome(action, pending, response) {
+        return pending.kind === 'question'
             ? buildQuestionResponse(action, pending, response)
             : buildAcpPermissionOutcome(action, pending.options, KIMI_APPROVAL_KINDS);
-        client.respond(requestId, acpResponse);
-        this.pendingApprovals.delete(requestId);
-        getLogger().info(`[${this.logTag}] approval responded requestId=${requestId} action=${action}`);
     }
     getStatusInfo() {
         return {
@@ -384,121 +332,11 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         if (settings.permissionMode !== undefined) {
             this.permissionMode = settings.permissionMode;
         }
-        if (!this.currentClient || !this.activeSessionId)
-            return;
-        const modeParams = {
-            sessionId: this.activeSessionId,
-            modeId: toAcpMode(this.permissionMode),
-        };
-        try {
-            await this.currentClient.request('session/set_mode', modeParams);
-            getLogger().info(`[${this.logTag}] session/set_mode hot-applied session=${this.activeSessionId} modeId=${modeParams.modeId}`);
-        }
-        catch (err) {
-            getLogger().warn(`[${this.logTag}] session/set_mode failed (non-fatal): ${err.message}`);
-        }
+        await this.sendApprovalModeUpdate(toAcpMode(this.permissionMode));
     }
     // =========================================================================
     // Internal
     // =========================================================================
-    /**
-     * Acquire the connection and set up the turn:
-     * session/new (new session) or session/resume (existing sessionId)
-     * → set permission mode if needed → session/prompt.
-     */
-    async setupTurn(message, opts) {
-        const client = await this.connectionManager.acquire(opts.cwd);
-        this.connectionManager.notifyActivity(opts.cwd);
-        this.currentClient = client;
-        this.activeCwd = opts.cwd;
-        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`);
-                void this.cleanupTerminals();
-                this.failTurn('Kimi ACP connection closed');
-            },
-        });
-        let sessionId;
-        if (opts.sessionId) {
-            const resumeParams = {
-                sessionId: opts.sessionId,
-                cwd: opts.cwd,
-            };
-            await client.request('session/resume', resumeParams);
-            sessionId = opts.sessionId;
-        }
-        else {
-            const newParams = { cwd: opts.cwd, mcpServers: [] };
-            const newResult = await client.request('session/new', newParams);
-            sessionId = newResult.sessionId;
-        }
-        this.activeSessionId = sessionId;
-        // CC-07: 下发配置的模型（provider/model）。session/new|resume 只带 cwd/mcpServers，
-        // 不带 model；不主动下发则实际跑 kimi 服务端默认模型。
-        // 仿 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
-        // session in manual and tool calls stall on unanswered approvals
-        // (live dark-test repro: approval_requested → idle timeout).
-        const modeParams = {
-            sessionId,
-            modeId: toAcpMode(this.permissionMode),
-        };
-        try {
-            await client.request('session/set_mode', modeParams);
-        }
-        catch (err) {
-            getLogger().warn(`[${this.logTag}] session/set_mode failed (non-fatal): ${err.message}`);
-        }
-        const translator = new KimiAcpTranslator();
-        this.currentTranslator = translator;
-        // Emit turn_started before prompt
-        const turnId = `turn-${Date.now()}`;
-        const turnStarted = translator.produceTurnStarted(sessionId, turnId);
-        this.currentTurnId = turnId;
-        this.pushEvents([turnStarted]);
-        // Send the prompt
-        const promptParams = {
-            sessionId,
-            prompt: [{ type: 'text', text: message }],
-        };
-        // Fire the prompt request; notifications will be buffered in the queue.
-        // We process them concurrently.
-        this.promptSettled = false;
-        const promptPromise = client.request('session/prompt', promptParams, Number.POSITIVE_INFINITY);
-        // Wait for prompt to settle, then push the result event.
-        // Notifications are pushed concurrently by the hook handlers.
-        promptPromise.then((result) => {
-            this.promptSettled = true;
-            if (this.stopRequested)
-                return; // already cancelled
-            const resultEvent = translator.handlePromptResponse(sessionId, result);
-            this.pushEvents([resultEvent]);
-        }, (err) => {
-            this.promptSettled = true;
-            if (this.stopRequested) {
-                getLogger().warn(`[${this.logTag}] prompt rejected after stopRequested: ${err.message}`);
-                return;
-            }
-            const resultEvent = translator.produceErrorResult(sessionId, err.message);
-            this.pushEvents([resultEvent]);
-        });
-    }
     /**
      * §5.2: 等 wire.jsonl 出现 NEW 压缩终态记录，返回判别结果而非 void。
      *
@@ -614,17 +452,7 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
             }
             return;
         }
-        for (const ev of events) {
-            if (ev.type === 'approval_requested') {
-                this.pendingApprovals.set(ev.requestId, {
-                    kind: ev.kind,
-                    view: ev.view,
-                    options: params.options,
-                    proto: method === ServerRequestMethod.ELICITATION_CREATE ? 'elicitation' : 'permission',
-                });
-                getLogger().info(`[${this.logTag}] approval requested requestId=${ev.requestId} kind=${ev.kind}`);
-            }
-        }
+        this.registerApprovalEvents(events, params.options, method === ServerRequestMethod.ELICITATION_CREATE ? 'elicitation' : 'permission');
         this.pushEvents(events);
     }
     /**
@@ -673,14 +501,17 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
             : undefined;
         const cwd = params.cwd ?? this.activeCwd ?? undefined;
         const outputLimit = params.outputByteLimit ?? TERMINAL_DEFAULT_OUTPUT_LIMIT;
-        const proc = spawn(params.command, params.args ?? [], {
+        const proc = spawnProcess(params.command, params.args ?? [], {
             cwd,
-            env: env ? { ...process.env, ...env } : undefined,
+            // env 覆盖大小写不敏感合并（win32 PATH/Path 双键防护，v2 §8.3）
+            env: env ? mergeProcessEnv(process.env, env) : undefined,
             stdio: ['ignore', 'pipe', 'pipe'],
             // ProcessStopper 用负 PID 杀进程组（kill(-pgid)）；子进程必须是组长
             // 才能命中，否则 kill(-pid) 抛 ESRCH 被吞 → kill/release/清理全失效。
-            // 与 JsonlRpcTransport / spawning-runner 的 detached:true 同模式。
-            detached: true,
+            // 与 JsonlRpcTransport / spawning-runner 同模式；win32 不 detached
+            // （`.cmd` 垫片在 DETACHED_PROCESS 下丢 stdio），树杀由 taskkill /T 负责。
+            detached: useDetachedProcessGroup(),
+            windowsHide: true,
         });
         // 每个流独立 decoder：多字节字符跨 chunk 拆分时由 decoder 保留不完整
         // 序列，避免按 chunk 单独 toString 产生 U+FFFD 替换符。
@@ -843,5 +674,21 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
             await this.processStopper.stop(handle.proc, { immediate: true });
         }
     }
+    // =========================================================================
+    // BaseAcpRunner hooks
+    // =========================================================================
+    onConnectionAcquired(opts) {
+        this.activeCwd = opts.cwd;
+    }
+    onConnectionClosed() {
+        void this.cleanupTerminals();
+    }
+    onClearTurnState() {
+        this.activeCwd = null;
+    }
+    async beforeDisposeConnections() {
+        // 关闭前 kill/release 所有存活 terminal，避免孤儿 bash 进程。
+        await this.cleanupTerminals();
+    }
 }
 //# sourceMappingURL=runner.js.map