lark-remote 0.1.13 → 0.2.1

package/dist/runner/common/spawning-runner.js

@@ -1,4 +1,5 @@
-import { spawn, execFileSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
+import { spawnProcess, isWindowsCommandNotFoundLine, useDetachedProcessGroup, } from '../../platform/spawn.js';
 import path from 'node:path';
 import os from 'node:os';
 import fs from 'node:fs';
@@ -7,7 +8,6 @@ import { getLogger } from '../../logger/index.js';
 import { ProcessStopper } from './process-stopper.js';
 import { SpawnHeartbeat } from './spawn-heartbeat.js';
 import { createJSONLStream } from './jsonl-stream.js';
-import { authErrorEvent, syntheticInitEvent } from './runner-utils.js';
 import { DEFAULT_STOP_GRACE_MS } from '../../config/index.js';
 /**
  * Magic-number constants (Clean Code P3-1, G25 Replace Magic Numbers with
@@ -16,16 +16,15 @@ import { DEFAULT_STOP_GRACE_MS } from '../../config/index.js';
  */
 /** Max bytes of stderr retained for the result-event error message. */
 const STDERR_TAIL_BYTES = 4000;
-/** Max bytes of stderr surfaced in the non-zero-exit log line. */
-const STDERR_LOG_TAIL = 500;
 /** Error thrown by `spawnChild` when the child process fails to spawn. */
 class SpawnChildError extends Error {
 }
 /**
  * Timeout (ms) for awaiting the spawn 'error' event when proc.pid === undefined
  * (review P2-11). Node guarantees 'error' for ENOENT/EACCES, but some binaries
- * fail silently; the race keeps a silent failure from hanging run() forever.
- * Matches the 5s race kimi's override used before it was hoisted to the base.
+ * fail silently; the race keeps a silent failure from hanging the spawn lead-in
+ * forever. Matches the 5s race kimi's override used before it was hoisted to
+ * the base.
  */
 const SPAWN_ERROR_TIMEOUT_MS = 5000;
 const registeredRunners = new Set();
@@ -59,24 +58,22 @@ export function unregisterExitCleanup(handler) {
     registeredRunners.delete(handler);
 }
 /**
- * Abstract base class for runners that spawn a child process per turn.
+ * Abstract base class encapsulating the spawn lifecycle shared by agent
+ * runners: spawn lead-in (pid-undefined check, pid file write, heartbeat,
+ * stderr tail accumulation), user-initiated stop, orphan kill with pid
+ * identity verification, and process-exit cleanup registration.
  *
- * Encapsulates the spawn + completion + cleanup orchestration shared by
- * Claude/Pi runners. Subclasses override:
- *   - buildArgv(opts)              → agent-specific CLI flags (required)
- *   - createTranslator(opts)       → stateful translator (pi)
- *     OR translate(raw, ctx)       → stateless passthrough (claude)
+ * The sole production subclass is ClaudeSession (src/runner/claude/session.ts),
+ * a long-lived interactive session that overrides `run()` with its own
+ * per-turn consumption loop and reads `spawnStderr` / `stoppedByUser` /
+ * `commandNotFoundSeen` to build its terminal result events.
  *
- * Optional hooks (with sensible defaults):
- *   - getStdio()                   → stdio config (default ['ignore','pipe','pipe'])
- *   - createStreamReader(stdout)   → JSONL or readline parser (default createJSONLStream)
- *   - awaitSpawnError(proc)        → wait for spawn error (default once('error'))
+ * Subclasses override:
+ *   - buildArgv(opts) → agent-specific CLI flags (required)
  *
- * The base class always emits a unified result event at the end of `run()`
- * via `buildResultEvent(...)` — never throws on non-zero exit. This matches
- * the contract pinned by the agent subclass anchors and the bridge's
- * `runAgentStreamToEnd` error handling (which accepts both thrown errors and
- * yielded error-result events).
+ * Optional hooks (with sensible defaults):
+ *   - getStdio()                 → stdio config (default ['ignore','pipe','pipe'])
+ *   - createStreamReader(stdout) → JSONL or readline parser (default createJSONLStream)
  */
 export class SpawningRunner {
     currentProcess = null;
@@ -91,26 +88,23 @@ export class SpawningRunner {
      * Log prefix used in all operational log lines emitted by this runner
      * (spawn, pid file, non-zero exit, stderr, killOrphan, stop cleanup) and
      * as the SpawnHeartbeat label. Subclasses pass their own tag (e.g.
-     * 'claude-runner') so operators can grep agent-specific logs; the default
-     * 'spawning-runner' keeps the base-class anchor tests' neutral identity.
+     * 'claude-runner') so operators can grep agent-specific logs.
      */
     logTag;
-    /**
-     * The `message` argument from the most recent `run(message, opts)` call.
-     * Set in `run()` before `buildArgv(opts)` is invoked so subclasses can
-     * embed the message in their agent-specific argv (e.g. claude's `-p
-     * <message>`). This avoids changing the `buildArgv(opts)` signature,
-     * which would break existing anchor subclasses.
-     */
-    currentMessage = '';
     /**
      * Whether the current run was interrupted by user-initiated stop().
      * Set to true by stop() when a running process is being terminated;
-     * reset to false at the top of run(). `resolveTranslatorError()` and
-     * `buildResultEvent()` read this to decide result event subtype
-     * (error vs success) and the error message precedence.
+     * subclasses reset it at the start of a turn and read it when building
+     * the terminal result event (interrupted vs error precedence).
      */
     stoppedByUser = false;
+    /**
+     * §4.4 win32 command-not-found 嗅探嫌疑标记：stderr 命中特征行时置位，
+     * 但**不**立即杀进程——agent 正常输出可能引用该错误文本（调试 Windows
+     * 报错场景），见行即杀会误杀 run。定性走双条件：子类收尾时「标记在 +
+     * 非零退出」才判 command-not-found；真挂起由既有 grace/超时兜底。
+     */
+    commandNotFoundSeen = false;
     constructor(opts) {
         // Subclasses set this.binary after super()
         this.binary = '';
@@ -130,15 +124,15 @@ export class SpawningRunner {
     }
     // --- Hooks (subclasses override as needed) ---
     /**
-     * stdio config for spawn. Default: stdin ignored (claude/kimi/pi pass the
-     * prompt via argv).
+     * stdio config for spawn. Default: stdin ignored (agents pass the prompt
+     * via argv).
      */
     getStdio() {
         return ['ignore', 'pipe', 'pipe'];
     }
     /**
      * Create an async iterator over the child's stdout. Default: createJSONLStream
-     * (claude/kimi/pi) with P1-4 backpressure enabled (pauseThreshold=100).
+     * with P1-4 backpressure enabled (pauseThreshold=100).
      */
     createStreamReader(stdout) {
         return createJSONLStream(stdout, {
@@ -149,21 +143,14 @@ export class SpawningRunner {
             resumeThreshold: 50,
         });
     }
-    /**
-     * Create a stateful translator for this run. Default: null (uses the
-     * stateless passthrough). pi overrides to return its translator instance.
-     */
-    createTranslator(_opts) {
-        return null;
-    }
     /**
      * Await the spawn 'error' event when proc.pid === undefined. Races a
      * finite timeout (review P2-11) against the 'error' event: Node guarantees
      * 'error' for ENOENT/EACCES, but some binaries fail silently without ever
-     * emitting it (kimi's CLI is documented to do so). Without the race, run()
-     * hangs forever → the workspace serial queue never settles → permanent
-     * deadlock, and /stop can't recover (ProcessStopper returns early when
-     * pid === undefined). The timeout keeps the deadlock bounded.
+     * emitting it. Without the race, the spawn lead-in hangs forever → the
+     * workspace serial queue never settles → permanent deadlock, and /stop
+     * can't recover (ProcessStopper returns early when pid === undefined).
+     * The timeout keeps the deadlock bounded.
      */
     awaitSpawnError(proc) {
         return Promise.race([
@@ -180,22 +167,18 @@ export class SpawningRunner {
      *
      * Throws a `SpawnChildError` (carrying the user-facing spawn failure
      * message) when the process fails to spawn (binary missing / pid undefined).
-     * On success returns the spawned child plus the accumulated stderr tail.
-     *
-     * Shared by the base `run()` (yields an authErrorEvent on failure) and
-     * ClaudeSession's `doStartProcess` (returns the error message), which would
-     * otherwise duplicate ~60 lines of spawn lead-in with two copies of the
-     * STDERR_TAIL_BYTES cap.
+     * On success returns the spawned child.
      */
     async spawnChild(opts) {
-        const proc = spawn(this.binary, this.buildArgv(opts), {
+        const proc = spawnProcess(this.binary, this.buildArgv(opts), {
             cwd: opts.cwd,
             stdio: this.getStdio(),
             env: process.env,
-            // Spawn in a new process group so we can kill the entire group
-            // when stopping. This ensures child processes (shell wrappers,
-            // sub-processes) are also terminated.
-            detached: true,
+            // posix 建新进程组以便负 PID 组杀（壳包装/子进程一并终止）；win32 不
+            // detached —— `.cmd` 垫片在 DETACHED_PROCESS 下丢 stdio（见
+            // useDetachedProcessGroup），树杀由 taskkill /T 负责。
+            detached: useDetachedProcessGroup(),
+            windowsHide: true,
         });
         this.currentProcess = proc;
         getLogger().info(`[${this.logTag}] spawn pid=${proc.pid ?? '(none)'} binary=${this.binary} ` +
@@ -231,6 +214,14 @@ export class SpawningRunner {
             const text = chunk.toString('utf-8').trim();
             if (text) {
                 this.spawnStderr = (this.spawnStderr + '\n' + text).trim().slice(-STDERR_TAIL_BYTES);
+                // §4.4 win32 command-not-found 嗅探：经 cmd 垫片启动失败不是 spawn 的
+                // ENOENT，而是 stderr 的 "is not recognized..." 行。命中只记嫌疑标记
+                // （双条件之一），不立即杀——定性由子类收尾的「标记 + 非零退出」
+                // 双条件完成；子进程真挂起由既有 grace/超时看门狗兜底。
+                if (isWindowsCommandNotFoundLine(text)) {
+                    this.commandNotFoundSeen = true;
+                    getLogger().error(`[${this.logTag}] command not found suspected (win32 shim): ${text}`);
+                }
                 // P2-16: most agent CLIs emit progress/warnings/deprecation notices on
                 // stderr, not real errors. Logging each chunk at error level drowns out
                 // genuine errors. Downgrade to warn — the accumulated stderr is already
@@ -240,151 +231,11 @@ export class SpawningRunner {
         });
         return proc;
     }
-    /**
-     * Spawn the agent binary with argv built by buildArgv(opts), iterate its
-     * stdout stream, and yield translated events. Always emits a unified
-     * result event at the end via `buildResultEvent(...)` — never throws on
-     * non-zero exit (the bridge accepts both thrown errors and yielded
-     * error-result events, and the latter carries richer diagnostic info).
-     *
-     * Spawn failures (binary missing, pid undefined) yield an `authErrorEvent`
-     * instead of throwing, so the user sees a friendly error card.
-     */
-    async *run(message, opts) {
-        if (this.isRunning) {
-            getLogger().warn(`[${this.logTag}] run() called while already running, refusing`);
-            throw new Error(`${this.binary} process already running`);
-        }
-        this.stoppedByUser = false;
-        this.currentMessage = message;
-        let proc;
-        try {
-            proc = await this.spawnChild(opts);
-        }
-        catch (err) {
-            // §9.22: yield synthetic init before the error result so bridge/run-state
-            // guards don't silently drop it.
-            yield syntheticInitEvent(opts.sessionId);
-            yield authErrorEvent(err.message);
-            return;
-        }
-        const completion = new Promise((resolve) => {
-            proc.once('error', (err) => {
-                this.spawnHeartbeat.clear();
-                getLogger().error(`[${this.logTag}] spawn failed: ${err.message} binary=${this.binary} cwd=${opts.cwd}`);
-                // Resolve (not reject) so the unified result event is emitted
-                // via buildResultEvent instead of throwing past the finally
-                // into the bridge's catch (which would leak the pid file).
-                // P2-12: a post-spawn 'error' (e.g. kill failure, broken pipe)
-                // MUST surface as an error result, not success. Previously
-                // {code:null,signal:null} was classified as success by
-                // buildResultEvent; code=1 forces the error branch so the
-                // failure is never silently swallowed as a successful run.
-                resolve({ code: 1, signal: null });
-            });
-            proc.once('close', (code, signal) => {
-                this.spawnHeartbeat.clear();
-                resolve({ code, signal });
-            });
-        });
-        // Create translator (per-run state) — null for stateless passthrough
-        const translator = this.createTranslator(opts);
-        // Create stream reader (jsonl or readline)
-        const stream = this.createStreamReader(proc.stdout);
-        try {
-            // Stream loop wrapped in try/catch so a stream error (e.g. stdout
-            // 'error' event propagated through the async generator) does not
-            // bypass the completion await and result event emission. Matches
-            // kimi's long-standing behavior; safe for all runners because the
-            // completion promise still resolves via proc 'close'.
-            try {
-                for await (const rawEvent of stream) {
-                    let translated;
-                    if (translator) {
-                        // Per-event error isolation: a translator throw must not kill
-                        // the stream (pi's accumulator could throw on malformed input).
-                        try {
-                            translated = translator.translate(rawEvent);
-                        }
-                        catch (err) {
-                            getLogger().warn(`[${this.logTag}] translator error: ${err.message}, raw: ${JSON.stringify(rawEvent).slice(0, 100)}`);
-                            continue;
-                        }
-                    }
-                    else {
-                        translated = this.translate(rawEvent, { message, opts });
-                    }
-                    if (translated === null)
-                        continue;
-                    if (Array.isArray(translated)) {
-                        for (const e of translated)
-                            yield e;
-                    }
-                    else {
-                        yield translated;
-                    }
-                }
-            }
-            catch (error) {
-                getLogger().error(`[${this.logTag}] stream error: ${error}`);
-            }
-            const { code, signal } = await completion;
-            // If the stream ended before a terminal event, let the translator
-            // record its terminal state (e.g. codex `finish('failed')` stashes
-            // "stream ended before a terminal event"). The runner folds this
-            // into buildResultEvent below.
-            if (translator && !translator.isTerminal()) {
-                const reason = this.stoppedByUser ? 'interrupted' : 'failed';
-                translator.finish(reason);
-            }
-            // Resolve translatorError precedence (most-specific first):
-            //   - agent-reported terminal error always wins
-            //   - stream-ended-early symptom only surfaces with no external cause
-            let translatorError;
-            if (translator) {
-                const agentError = translator.hasAgentTerminalError();
-                const hasExternalCause = this.stoppedByUser || signal !== null || (code !== null && code !== 0);
-                translatorError =
-                    agentError || !hasExternalCause ? translator.getTerminalError() : undefined;
-            }
-            const nonUserError = !this.stoppedByUser && ((code !== null && code !== 0) || signal !== null);
-            yield this.buildResultEvent({
-                code,
-                signal,
-                stderr: this.spawnStderr,
-                sessionId: translator?.getSessionId?.() ?? '',
-                usage: translator?.getLastUsage?.(),
-                translatorError,
-            });
-            if (nonUserError) {
-                getLogger().error(`[${this.logTag}] non-zero exit code=${code} signal=${signal} stderr=${this.spawnStderr.slice(-STDERR_LOG_TAIL)}`);
-            }
-        }
-        finally {
-            this.spawnHeartbeat.clear();
-            // P1-11: 消费者提前关闭生成器（for-await 循环体抛错/break 触发的 .return()）
-            // 会跳过 completion await 直接进 finally——此时子进程可能仍在运行。若不杀，
-            // 它会成为 stop()（currentProcess 已置 null）、killOrphan()（pid 文件已删）、
-            // exit handler（同一字段）都够不到的孤儿黑洞，且 stdout 管道背压会把它永久
-            // 阻塞。正常完成路径进程已退出，stop 是 no-op，零成本。
-            const proc = this.currentProcess;
-            if (proc && proc.exitCode === null && proc.signalCode === null) {
-                try {
-                    await this.stopper.stop(proc, { immediate: true });
-                }
-                catch {
-                    /* ignore */
-                }
-            }
-            this.currentProcess = null;
-            silentlyUnlink(this.pidFilePath);
-        }
-    }
     /**
      * Stop the current process if one is running. Delegates the actual
      * SIGTERM → grace → SIGKILL sequence to `this.stopper.stop(proc, opts)`
      * (see `src/runner/common/process-stopper.ts`), forwarding the `immediate`
-     * flag verbatim so all 5 subclasses inherit identical stop semantics.
+     * flag verbatim so all subclasses inherit identical stop semantics.
      */
     async stop(opts) {
         const proc = this.currentProcess;
@@ -497,7 +348,7 @@ export class SpawningRunner {
     /**
      * Shared process-exit cleanup: SIGTERM the still-running child process and
      * remove the pid file. Called by the singleton dispatcher for every
-     * registered runner; previously duplicated verbatim in all 5 runner
+     * registered runner; previously duplicated verbatim in the runner
      * subclasses.
      */
     cleanupOnExit() {
@@ -512,75 +363,5 @@ export class SpawningRunner {
         }
         silentlyUnlink(this.pidFilePath);
     }
-    /**
-     * Build a unified result event from process exit state. Centralizes the
-     * result-event semantics specified in Candidate 2:
-     *   - stoppedByUser → error ("interrupted by user")
-     *   - translatorError set → error (translator-supplied message, e.g. codex
-     *     `turn.failed` or "stream ended before a terminal event")
-     *   - code !== 0 && code !== null → error (exit code + stderr tail)
-     *   - signal !== null → error (killed by signal)
-     *   - otherwise → success (with optional usage)
-     *
-     * Error message precedence (most-specific first):
-     *   - stoppedByUser:  "{binary} interrupted by user"
-     *   - translatorError: verbatim translator-supplied message
-     *   - signal:         "{binary} killed by signal {signal}{stderr tail}"
-     *   - non-zero code:  "{binary} exited code={code}{stderr tail}"
-     *
-     * @param opts.code            - Process exit code (null if killed by signal)
-     * @param opts.signal          - Process signal code (null if exited normally)
-     * @param opts.stderr          - Accumulated stderr (tail included in code/signal errors)
-     * @param opts.sessionId       - Session ID to include in the result event
-     * @param opts.usage           - Token usage to include on success
-     * @param opts.translatorError - Agent-specific terminal error message (e.g.
-     *                                codex turn.failed, or "stream ended early")
-     * @returns AgentEvent with type='result'
-     */
-    buildResultEvent(opts) {
-        const isError = this.stoppedByUser ||
-            opts.translatorError !== undefined ||
-            (opts.code !== null && opts.code !== 0) ||
-            opts.signal !== null;
-        const sessionId = opts.sessionId ?? '';
-        if (isError) {
-            let errorMessage;
-            const stderrTail = opts.stderr ? opts.stderr.slice(-STDERR_LOG_TAIL) : '';
-            if (this.stoppedByUser) {
-                errorMessage = `${this.binary} interrupted by user`;
-            }
-            else if (opts.translatorError !== undefined) {
-                errorMessage = opts.translatorError;
-            }
-            else if (opts.signal !== null) {
-                errorMessage = `${this.binary} killed by signal ${opts.signal}${stderrTail ? `: ${stderrTail}` : ''}`;
-            }
-            else {
-                errorMessage = `${this.binary} exited code=${opts.code}${stderrTail ? `: ${stderrTail}` : ''}`;
-            }
-            return {
-                type: 'result',
-                subtype: 'error',
-                session_id: sessionId,
-                errorMessage,
-            };
-        }
-        return {
-            type: 'result',
-            subtype: 'success',
-            session_id: sessionId,
-            ...(opts.usage ? { usage: opts.usage } : {}),
-        };
-    }
-    /**
-     * Stateless passthrough translator hook. Used by ClaudeRunner
-     * which does not need per-run translation state. Subclasses that return
-     * a translator from `createTranslator(opts)` leave this as the default
-     * no-op — the base `run()` loop only calls `translate()` when
-     * `createTranslator()` returns null.
-     */
-    translate(_rawEvent, _ctx) {
-        return null;
-    }
 }
 //# sourceMappingURL=spawning-runner.js.map

package/dist/runner/common/usage.d.ts

@@ -25,6 +25,8 @@ interface NormalizedResultUsage {
     totalTokens?: number;
     /** Model context window limit (codex app-server `modelContextWindow` passthrough). */
     contextLimit?: number;
+    /** Reasoning tokens (pi usage.reasoning). Undefined when not provided. */
+    reasoningTokens?: number;
     /** Reconstructed or agent-declared context length (see JSDoc above). */
     contextLength: number;
 }

package/dist/runner/common/usage.js

@@ -15,6 +15,7 @@ export function normalizeResultUsage(usage) {
     const cacheCreation = usage.cache_creation_tokens ?? usage.cache_creation_input_tokens;
     const totalTokens = usage.total_tokens;
     const contextLimit = usage.context_limit;
+    const reasoningTokens = usage.reasoning_tokens;
     // total_tokens (agent-declared total) takes priority; otherwise reconstruct
     // from the parts: input + cacheRead + cacheCreation + output.
     const contextLength = totalTokens ?? inputTokens + (cacheRead ?? 0) + (cacheCreation ?? 0) + outputTokens;
@@ -25,6 +26,7 @@ export function normalizeResultUsage(usage) {
         cacheCreationTokens: cacheCreation,
         totalTokens,
         contextLimit,
+        reasoningTokens,
         contextLength,
     };
 }

package/dist/runner/index.d.ts

@@ -15,6 +15,6 @@ export { KimiAcpRunner } from './kimi/index.js';
 export { DshRunner } from './dsh/index.js';
 export { BashProcessRunner, type BashRunner } from './bash/index.js';
 export { AgentRegistry } from './registry.js';
-export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, SessionSummary, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, } from './types.js';
+export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, SessionSummary, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, NoticeEvent, SessionInfoEvent, ToolHint, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, } from './types.js';
 export { resolveAgentChoices } from './resolve-agent-choices.js';
 export { syncAgentChoices } from './sync-agent-choices.js';

package/dist/runner/kimi/acp/runner.d.ts

@@ -6,15 +6,23 @@
  * → 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 type { AgentKind, AgentSessionReader, AgentEvent, AgentStatusInfo, SpawnOptions } from '../../types.js';
-import { JsonRpcClient as KimiAcpClient } from '../../common/jsonrpc/client.js';
-import { type AcpTranslatorEvent } from './translator.js';
-import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
+import type { AgentKind, AgentSessionReader, AgentStatusInfo, SpawnOptions } from '../../types.js';
+import { JsonRpcClient } from '../../common/jsonrpc/client.js';
+import { KimiAcpTranslator } from './translator.js';
+import { type SessionPromptResult } from '../../common/acp/protocol-types.js';
+import { type AcpPendingApproval } from '../../common/acp/protocol-helpers.js';
+import { BaseAcpRunner } from '../../common/acp/base-acp-runner.js';
 export interface KimiAcpRunnerOptions {
     kind: AgentKind;
     sessionReader: AgentSessionReader;
@@ -39,15 +47,15 @@ export interface KimiAcpRunnerOptions {
     /** Kimi permission mode (user-facing: manual/auto/yolo). */
     permissionMode?: 'manual' | 'auto' | 'yolo';
 }
-export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient, AcpTranslatorEvent> {
-    private connectionManager;
-    private currentTranslator;
-    private activeSessionId;
-    private model?;
+export declare class KimiAcpRunner extends BaseAcpRunner<KimiAcpTranslator> {
     private permissionMode;
     private readonly compactIdleTimeoutMs;
-    /** Pending approval requests: requestId → kind + view + options. */
-    private pendingApprovals;
+    /**
+     * §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.
+     */
+    private compactBaselineRecords;
     /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
     private terminals;
     /** terminalId 自增序号（term-1, term-2, …）。 */
@@ -63,32 +71,29 @@ export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient,
     /** 当前 run 的 session cwd（terminal/create 未给 cwd 时回退用）。 */
     private activeCwd;
     private readonly processStopper;
-    /** Tracker for the in-flight prompt request — needed for cancellation. */
-    private promptSettled;
     constructor(opts: KimiAcpRunnerOptions);
     protected get logTag(): string;
     protected get turnTimeoutErrorMessage(): string;
     protected get turnInterruptedErrorMessage(): string;
-    protected currentSessionId(): string | null;
+    protected get connectionClosedMessage(): string;
     protected shouldDeferStop(): boolean;
-    protected cancelCurrentTurn(): Promise<void>;
-    protected clearTurnState(): void;
-    protected releaseConnection(cwd: string): Promise<void>;
-    protected notifyIdle(cwd: string): void;
-    protected disposeConnections(): Promise<void>;
+    protected createTranslator(): KimiAcpTranslator;
+    protected applyTurnSettings(client: JsonRpcClient, sessionId: string): Promise<void>;
     /**
-     * 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 事故).
      */
-    runCompact(_message: string, opts: SpawnOptions): AsyncGenerator<AgentEvent>;
-    /**
-     * Respond to an approval server request. `response` is the bridge
-     * ApprovalAction (`{ action: 'accept' | 'decline' | 'cancel' }`).
-     */
-    respondApproval(requestId: number | string, response: unknown): Promise<void>;
+    protected compactBaseline(sessionId: string, opts: SpawnOptions): number;
+    protected onCompactPromptFired(promptPromise: Promise<SessionPromptResult>, translator: KimiAcpTranslator, sessionId: string, opts: SpawnOptions, baselineTotalCount: number): void;
+    protected buildApprovalOutcome(action: string, pending: AcpPendingApproval, response: unknown): unknown;
     getStatusInfo(): AgentStatusInfo;
     /**
      * Hot-apply a permission-mode change to the live ACP session (§P5).
@@ -102,12 +107,6 @@ export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient,
     updateApprovalMode(settings: {
         permissionMode?: 'manual' | 'auto' | 'yolo';
     }): Promise<void>;
-    /**
-     * Acquire the connection and set up the turn:
-     * session/new (new session) or session/resume (existing sessionId)
-     * → set permission mode if needed → session/prompt.
-     */
-    protected setupTurn(message: string, opts: SpawnOptions): Promise<void>;
     /**
      * §5.2: 等 wire.jsonl 出现 NEW 压缩终态记录，返回判别结果而非 void。
      *
@@ -123,7 +122,7 @@ export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient,
      * wakeWaiters），避免数分钟的压缩被 consumeTurn 滚动空闲看门狗误杀。
      */
     private waitForCompactionTerminal;
-    private handleNotification;
+    protected handleNotification(method: string, params: unknown): void;
     /**
      * Filter kimi's own Bash tool notifications so the run card doesn't get a
      * duplicate, output-less Bash panel alongside the runner-produced one.
@@ -135,7 +134,7 @@ export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient,
      * Returns true when the notification should be swallowed.
      */
     private filterBashNotifications;
-    private handleServerRequest;
+    protected handleServerRequest(id: number | string, method: string, params: unknown): void;
     /**
      * Handle a kimi terminal/* reverse RPC by spawning a one-shot local process.
      *
@@ -161,4 +160,8 @@ export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient,
     private handleTerminalRelease;
     /** Kill every live terminal (dispose/connection-close 清理钩子)。 */
     private cleanupTerminals;
+    protected onConnectionAcquired(opts: SpawnOptions): void;
+    protected onConnectionClosed(): void;
+    protected onClearTurnState(): void;
+    protected beforeDisposeConnections(): Promise<void>;
 }