lark-remote 0.1.12 → 0.2.0

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

@@ -6,25 +6,29 @@
  * → 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 { findOptionIdByKind } from '../../common/acp/protocol-helpers.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';
-/** R2: how long to wait for the background compaction record after the
- *  /compact prompt settles (design doc §6.1). Real kimi 0.36.0 lands
- *  context.apply_compaction ~8s after end_turn. */
-const COMPACT_POLL_TIMEOUT_MS = 30_000;
+/** §5.2: compaction 等待的默认沉默超时（对齐 turnIdleTimeoutMs 默认值）。 */
+const COMPACT_IDLE_TIMEOUT_MS = 10 * 60_000;
 /** Poll interval for the wire.jsonl compaction record. */
 const COMPACT_POLL_INTERVAL_MS = 1_000;
 // =============================================================================
@@ -36,6 +40,16 @@ const COMPACT_POLL_INTERVAL_MS = 1_000;
 // =============================================================================
 /** terminal/create 未显式给 outputByteLimit 时的缓冲上限（对齐服务端默认 4MB）。 */
 const TERMINAL_DEFAULT_OUTPUT_LIMIT = 4 * 1024 * 1024;
+/** 压缩终态记录：complete / apply_compaction 完成，cancel 为失败或取消（共用）。 */
+function isCompactionTerminalLike(record) {
+    return (record.type === 'full_compaction.complete' ||
+        record.type === 'context.apply_compaction' ||
+        record.type === 'full_compaction.cancel');
+}
+/** 沉默窗口的展示文案（测试用小窗口显示秒，生产默认显示分钟）。 */
+function formatIdleWindow(ms) {
+    return ms >= 60_000 ? `${Math.round(ms / 60_000)} 分钟` : `${Math.round(ms / 1000)} 秒`;
+}
 /**
  * Map user-facing permission mode to ACP mode id.
  *
@@ -58,53 +72,6 @@ function toAcpMode(mode) {
             return 'yolo';
     }
 }
-/**
- * Build the ACP protocol response for a permission approval decision.
- *
- * accept            → {outcome:{outcome:'selected', optionId:<approve_once kind>}}
- * accept_for_session → {outcome:{outcome:'selected', optionId:<approve_always kind>}}
- * decline           → {outcome:{outcome:'selected', optionId:<reject kind>}}
- * cancel            → {outcome:{outcome:'cancelled'}}
- *
- * optionId is looked up from the request's options[] by kind (approval.ts:28-29):
- * approve_once / approve_always / allow_once for accept;
- * approve_always / allow_always for accept_for_session;
- * reject / reject_once for decline. If not found, fall back to cancelled
- * (safe universal default — the server treats it as "user declined").
- *
- * 2026-08-15 live test: approve_once + approve_always + reject observed.
- */
-function buildApprovalResponse(action, pending) {
-    if (action === 'cancel') {
-        return { outcome: { outcome: 'cancelled' } };
-    }
-    if (action === 'accept') {
-        const optionId = findOptionIdByKind(pending.options, [
-            'approve_once',
-            'approve_always',
-            'allow_once',
-        ]);
-        if (optionId) {
-            return { outcome: { outcome: 'selected', optionId } };
-        }
-        // Fallback: can't find allow option → cancel is safe
-        return { outcome: { outcome: 'cancelled' } };
-    }
-    if (action === 'accept_for_session') {
-        // §P4: 卡片「允许本次会话」→ always 类 optionId（kimi approve_always）
-        const optionId = findOptionIdByKind(pending.options, ['approve_always', 'allow_always']);
-        if (optionId) {
-            return { outcome: { outcome: 'selected', optionId } };
-        }
-        return { outcome: { outcome: 'cancelled' } };
-    }
-    // decline
-    const optionId = findOptionIdByKind(pending.options, ['reject', 'reject_once']);
-    if (optionId) {
-        return { outcome: { outcome: 'selected', optionId } };
-    }
-    return { outcome: { outcome: 'cancelled' } };
-}
 /**
  * AskUserQuestion 回编（kind === 'question'）：
  * - elicitation form：answer → {action:'accept', content:{q0..qn}}（多选数组/
@@ -165,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;
-    compactPollTimeoutMs;
-    /** Pending approval requests: requestId → kind + view + options. */
-    pendingApprovals = new Map();
+    compactIdleTimeoutMs;
+    /**
+     * §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, …）。 */
@@ -189,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.compactPollTimeoutMs = opts.compactPollTimeoutMs ?? COMPACT_POLL_TIMEOUT_MS;
         const managerOpts = {
             binary: opts.binary ?? 'kimi',
             args: opts.acpArgs ?? ['acp'],
@@ -222,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';
@@ -233,144 +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' }],
-            };
-            // R2: compaction is a BACKGROUND task — the prompt settles before the
-            // wire.jsonl compaction record lands (real kimi: ~8s). Baseline the
-            // record count, fire the prompt without awaiting (notifications flow
-            // through consumeTurn), then poll for a NEW record before producing
-            // the result. This keeps the connection alive while the background
-            // compaction finishes — otherwise dispose/exit kills it and the record
-            // never lands (S5/S6 打回复现).
-            const compactionReader = this.sessionReader.readCompactionRecords;
-            const baselineCount = compactionReader
-                ? compactionReader.call(this.sessionReader, sessionId, opts.cwd).length
-                : 0;
-            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) {
-                    await this.waitForCompactionRecord(compactionReader, opts, baselineCount);
+    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 记录，可能已在跑或被拒绝）`);
                 }
+                const outcome = await this.waitForCompactionTerminal(compactionReader, opts, baselineTerminalCount);
                 if (this.forceFinish)
                     return; // stopped while polling
-                // Translate prompt result into a result event
-                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;
+                if (outcome === 'completed') {
+                    // 压缩完成：正常翻译 prompt 结果（subtype success）。
+                    const resultEvent = translator.handlePromptResponse(sessionId, result);
+                    this.pushEvents([resultEvent]);
+                }
+                else if (outcome === 'cancelled') {
+                    this.pushEvents([
+                        translator.produceErrorResult(sessionId, '压缩未完成：已被取消或压缩请求失败（可重试）'),
+                    ]);
                 }
-                const resultEvent = translator.produceErrorResult(sessionId, err.message);
+                else if (outcome === 'unknown') {
+                    this.pushEvents([
+                        translator.produceErrorResult(sessionId, `压缩状态未知：超过 ${formatIdleWindow(this.compactIdleTimeoutMs)} 未观察到完成/取消记录，压缩可能仍在后台进行`),
+                    ]);
+                }
+                // 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)
-            : buildApprovalResponse(action, pending);
-        client.respond(requestId, acpResponse);
-        this.pendingApprovals.delete(requestId);
-        getLogger().info(`[${this.logTag}] approval responded requestId=${requestId} action=${action}`);
+            : buildAcpPermissionOutcome(action, pending.options, KIMI_APPROVAL_KINDS);
     }
     getStatusInfo() {
         return {
@@ -395,144 +332,53 @@ 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 服务端默认模型（旧 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
-        // 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]);
-        });
-    }
-    /**
-     * R2: poll wire.jsonl until a NEW compaction record
-     * (context.apply_compaction / full_compaction.complete) appears.
+     * §5.2: 等 wire.jsonl 出现 NEW 压缩终态记录，返回判别结果而非 void。
      *
-     * The /compact prompt settles before the background compaction lands its
-     * record; returning early would let the caller dispose the connection and
-     * kill the background job. Timeout is WARN-only (the compact may have been
-     * a no-op) — never fails the turn. Aborts early on stop/forceFinish.
+     * 压缩是完整 LLM 请求（引擎 ≤5 次重试 + overflow 收缩重试），时长无上限；
+     * 旧「固定 30s 超时 = 成功」已删除。出口：
+     *   completed — 观察到 full_compaction.complete / context.apply_compaction；
+     *   cancelled — 观察到 full_compaction.cancel（API 失败/abort 与用户取消共用，
+     *               绝不当成功）；
+     *   stopped   — 等待中 stop()/forceFinish（consumeTurn 产 interrupted 兜底）；
+     *   unknown   — 距上次观察到任何新 compaction 记录（begin/terminal）超过
+     *               compactIdleTimeoutMs（沉默超时，压缩可能仍在后台进行）。
+     * 观察到新记录即重置沉默时钟，并顺带重置 turn idle 时钟（lastEventAt +
+     * wakeWaiters），避免数分钟的压缩被 consumeTurn 滚动空闲看门狗误杀。
      */
-    async waitForCompactionRecord(reader, opts, baselineCount) {
+    async waitForCompactionTerminal(reader, opts, baselineTerminalCount) {
         const sessionId = this.activeSessionId ?? opts.sessionId ?? '';
-        const deadline = Date.now() + this.compactPollTimeoutMs;
-        while (Date.now() < deadline) {
+        let lastActivityAt = Date.now();
+        let lastTotalCount = reader.call(this.sessionReader, sessionId, opts.cwd).length;
+        while (true) {
             if (this.forceFinish || this.stopRequested)
-                return;
+                return 'stopped';
             const records = reader.call(this.sessionReader, sessionId, opts.cwd);
-            if (records.length > baselineCount) {
-                getLogger().info(`[${this.logTag}] compaction record observed (${records.length} > baseline ${baselineCount})`);
-                return;
+            if (records.length !== lastTotalCount) {
+                lastTotalCount = records.length;
+                lastActivityAt = Date.now();
+                // 压缩仍在活动（新 begin / 重试 / terminal）：重置 turn idle 时钟，
+                // 让 consumeTurn 重新计算滚动截止时间。
+                this.lastEventAt = Date.now();
+                this.wakeWaiters();
+            }
+            const terminalRecords = records.filter(isCompactionTerminalLike);
+            if (terminalRecords.length > baselineTerminalCount) {
+                const newest = terminalRecords[terminalRecords.length - 1];
+                getLogger().info(`[${this.logTag}] compaction terminal observed (${newest.type}, ${terminalRecords.length} > baseline ${baselineTerminalCount})`);
+                return newest.type === 'full_compaction.cancel' ? 'cancelled' : 'completed';
+            }
+            if (Date.now() - lastActivityAt >= this.compactIdleTimeoutMs) {
+                getLogger().warn(`[${this.logTag}] no compaction terminal within ${this.compactIdleTimeoutMs}ms of last activity (baselineTerminal=${baselineTerminalCount}); reporting unknown`);
+                return 'unknown';
             }
             await new Promise((resolve) => setTimeout(resolve, COMPACT_POLL_INTERVAL_MS));
         }
-        getLogger().warn(`[${this.logTag}] compaction record not observed within ${this.compactPollTimeoutMs}ms (baseline=${baselineCount}); proceeding without confirmation`);
     }
     handleNotification(method, params) {
         // Terminal-backed Bash 的通知走 runner 自产事件（见 bashToolCallIds），
@@ -606,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);
     }
     /**
@@ -665,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 替换符。
@@ -835,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