lark-remote 0.1.5 → 0.1.7

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

@@ -23,6 +23,8 @@ interface NormalizedResultUsage {
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
     totalTokens?: number;
+    /** Model context window limit (codex app-server `modelContextWindow` passthrough). */
+    contextLimit?: number;
     /** Reconstructed or agent-declared context length (see JSDoc above). */
     contextLength: number;
 }

package/dist/runner/common/usage.js

@@ -14,6 +14,7 @@ export function normalizeResultUsage(usage) {
     const cacheRead = usage.cache_read_tokens ?? usage.cache_read_input_tokens;
     const cacheCreation = usage.cache_creation_tokens ?? usage.cache_creation_input_tokens;
     const totalTokens = usage.total_tokens;
+    const contextLimit = usage.context_limit;
     // 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;
@@ -23,6 +24,7 @@ export function normalizeResultUsage(usage) {
         cacheReadTokens: cacheRead,
         cacheCreationTokens: cacheCreation,
         totalTokens,
+        contextLimit,
         contextLength,
     };
 }

package/dist/runner/index.d.ts

@@ -8,12 +8,12 @@
  * （共享工具由消费方直接 import `common/*` 具体模块，不走 barrel）
  */
 export { ClaudeRunner } from './claude/index.js';
-export { CodexExecRunner } from './codex/index.js';
-export { OpencodeExecRunner } from './opencode/index.js';
-export { PiRunner } from './pi/index.js';
-export { KimiRunner } from './kimi/index.js';
+export { CodexAppServerRunner } from './codex/index.js';
+export { OpencodeAcpRunner } from './opencode/index.js';
+export { PiRpcRunner } from './pi/index.js';
+export { KimiAcpRunner } from './kimi/index.js';
 export { BashProcessRunner, type BashRunner } from './bash/index.js';
 export { AgentRegistry } from './registry.js';
-export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, AgentSessionReader, AgentRunner, } from './types.js';
+export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, } from './types.js';
 export { resolveAgentChoices } from './resolve-agent-choices.js';
 export { syncAgentChoices } from './sync-agent-choices.js';

package/dist/runner/index.js

@@ -9,10 +9,10 @@
  */
 // Re-export AgentRunner 实现（从各 agent 目录）
 export { ClaudeRunner } from './claude/index.js';
-export { CodexExecRunner } from './codex/index.js';
-export { OpencodeExecRunner } from './opencode/index.js';
-export { PiRunner } from './pi/index.js';
-export { KimiRunner } from './kimi/index.js';
+export { CodexAppServerRunner } from './codex/index.js';
+export { OpencodeAcpRunner } from './opencode/index.js';
+export { PiRpcRunner } from './pi/index.js';
+export { KimiAcpRunner } from './kimi/index.js';
 export { BashProcessRunner } from './bash/index.js';
 // Re-export registry
 export { AgentRegistry } from './registry.js';

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

@@ -0,0 +1,106 @@
+/**
+ * KimiAcpRunner: workspace-lifetime runner using the Kimi ACP protocol
+ * (`kimi acp`, JSON-RPC over stdio).
+ *
+ * Flow per run: acquire persistent connection → session/new or session/resume
+ * → 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.
+ */
+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';
+export interface KimiAcpRunnerOptions {
+    kind: AgentKind;
+    sessionReader: AgentSessionReader;
+    /** Path to the kimi binary. Defaults to `kimi`. */
+    binary?: string;
+    /** Environment variables. */
+    env?: Record<string, string | undefined>;
+    /** Args to spawn the ACP server with. Defaults to `['acp']`. */
+    acpArgs?: string[];
+    /** Request timeout in milliseconds. */
+    requestTimeoutMs?: number;
+    /** Idle TTL for connection manager. */
+    idleTtlMs?: number;
+    /** How long to wait for turn output before failing. Defaults to 10 min. */
+    turnIdleTimeoutMs?: number;
+    /** R2: how long to poll wire.jsonl for the compaction record after the
+     *  /compact prompt settles. Defaults to 30s; WARN (not fail) on timeout. */
+    compactPollTimeoutMs?: number;
+    model?: string;
+    /** 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?;
+    private permissionMode;
+    private readonly compactPollTimeoutMs;
+    /** Pending approval requests: requestId → kind + view + options. */
+    private pendingApprovals;
+    /** 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 shouldDeferStop(): boolean;
+    protected cancelCurrentTurn(): Promise<void>;
+    protected clearTurnState(): void;
+    protected releaseConnection(cwd: string): Promise<void>;
+    protected notifyIdle(cwd: string): void;
+    protected disposeConnections(): 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.
+     */
+    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>;
+    getStatusInfo(): AgentStatusInfo;
+    /**
+     * Hot-apply a permission-mode change to the live ACP session (§P5).
+     *
+     * The local cache is always updated so `getStatusInfo()` (and therefore
+     * `/s`) reflects the new mode immediately. When a session is connected,
+     * re-sends `session/set_mode` so the running session picks up the new mode
+     * without waiting for the runner to be evicted/recreated. Failure is
+     * non-fatal: the next setupTurn re-applies the cached mode unconditionally.
+     */
+    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>;
+    /**
+     * R2: poll wire.jsonl until a NEW compaction record
+     * (context.apply_compaction / full_compaction.complete) appears.
+     *
+     * 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.
+     */
+    private waitForCompactionRecord;
+    private handleNotification;
+    private handleServerRequest;
+}

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

@@ -0,0 +1,448 @@
+/**
+ * KimiAcpRunner: workspace-lifetime runner using the Kimi ACP protocol
+ * (`kimi acp`, JSON-RPC over stdio).
+ *
+ * Flow per run: acquire persistent connection → session/new or session/resume
+ * → 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.
+ */
+import { ConnectionManager as KimiAcpConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
+import { KimiAcpTranslator } from './translator.js';
+import { RpcErrorCode, ServerRequestMethod, } from '../../common/acp/protocol-types.js';
+import { findOptionIdByKind } from '../../common/acp/protocol-helpers.js';
+import { getLogger } from '../../../logger/index.js';
+import { ConnectionBasedRunner } from '../../common/connection-based-runner.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;
+/** Poll interval for the wire.jsonl compaction record. */
+const COMPACT_POLL_INTERVAL_MS = 1_000;
+/**
+ * Map user-facing permission mode to ACP mode id.
+ *
+ * ACP layer mode ids (acp-server/src/modes.ts:49):
+ *   default → permission manual
+ *   auto    → permission auto
+ *   yolo    → permission yolo
+ *   plan    → not exposed in v1
+ *
+ * This is not self-invented naming — both are official enums at their
+ * respective layers. The mapping happens only at the ACP boundary.
+ */
+function toAcpMode(mode) {
+    switch (mode) {
+        case 'manual':
+            return 'default';
+        case 'auto':
+            return 'auto';
+        case 'yolo':
+            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' } };
+}
+// =============================================================================
+// Runner
+// =============================================================================
+export class KimiAcpRunner extends ConnectionBasedRunner {
+    connectionManager;
+    currentTranslator = null;
+    activeSessionId = null;
+    model;
+    permissionMode;
+    compactPollTimeoutMs;
+    /** Pending approval requests: requestId → kind + view + options. */
+    pendingApprovals = new Map();
+    /** 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'],
+            env: opts.env,
+            requestTimeoutMs: opts.requestTimeoutMs,
+            idleTtlMs: opts.idleTtlMs,
+            initializeParams: {
+                protocolVersion: 1,
+                clientCapabilities: {
+                    fs: { readTextFile: false, writeTextFile: false },
+                    terminal: false,
+                },
+            },
+        };
+        this.connectionManager = new KimiAcpConnectionManager(managerOpts);
+    }
+    get logTag() {
+        return 'kimi-acp-runner';
+    }
+    get turnTimeoutErrorMessage() {
+        return 'Kimi ACP turn timed out';
+    }
+    get turnInterruptedErrorMessage() {
+        return 'Kimi ACP turn interrupted';
+    }
+    currentSessionId() {
+        return this.activeSessionId;
+    }
+    shouldDeferStop() {
+        return !this.promptSettled;
+    }
+    async cancelCurrentTurn() {
+        if (!this.currentClient || !this.activeSessionId)
+            return;
+        try {
+            // session/cancel is a NOTIFICATION (no id, no response) per ACP spec.
+            const cancelParams = { sessionId: this.activeSessionId };
+            this.currentClient.notify('session/cancel', cancelParams);
+        }
+        catch (err) {
+            getLogger().warn(`[${this.logTag}] session/cancel failed: ${err.message}`);
+        }
+    }
+    clearTurnState() {
+        this.currentTranslator = null;
+        this.promptSettled = false;
+        this.activeSessionId = null;
+    }
+    async releaseConnection(cwd) {
+        await this.connectionManager.release(cwd);
+    }
+    notifyIdle(cwd) {
+        this.connectionManager.notifyIdle(cwd);
+    }
+    async disposeConnections() {
+        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.
+     */
+    async *runCompact(_message, opts) {
+        yield* this.executeTurn(opts, async () => {
+            const client = await this.connectionManager.acquire(opts.cwd);
+            this.connectionManager.notifyActivity(opts.cwd);
+            this.currentClient = client;
+            client.setHooks({
+                onNotification: (method, params) => this.handleNotification(method, params),
+                onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
+                onClose: () => this.failTurn('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);
+                }
+                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;
+                }
+                const resultEvent = translator.produceErrorResult(sessionId, err.message);
+                this.pushEvents([resultEvent]);
+            });
+        });
+    }
+    /**
+     * 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 = buildApprovalResponse(action, pending);
+        client.respond(requestId, acpResponse);
+        this.pendingApprovals.delete(requestId);
+        getLogger().info(`[${this.logTag}] approval responded requestId=${requestId} action=${action}`);
+    }
+    getStatusInfo() {
+        return {
+            kind: this.kind,
+            model: this.model ?? '(kimi-acp)',
+            extras: {
+                mode: 'acp',
+                permissionMode: this.permissionMode,
+            },
+        };
+    }
+    /**
+     * Hot-apply a permission-mode change to the live ACP session (§P5).
+     *
+     * The local cache is always updated so `getStatusInfo()` (and therefore
+     * `/s`) reflects the new mode immediately. When a session is connected,
+     * re-sends `session/set_mode` so the running session picks up the new mode
+     * without waiting for the runner to be evicted/recreated. Failure is
+     * non-fatal: the next setupTurn re-applies the cached mode unconditionally.
+     */
+    async updateApprovalMode(settings) {
+        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}`);
+        }
+    }
+    // =========================================================================
+    // 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;
+        client.setHooks({
+            onNotification: (method, params) => this.handleNotification(method, params),
+            onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
+            onClose: () => {
+                getLogger().warn(`[${this.logTag}] client connection closed`);
+                this.failTurn('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;
+        // 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.
+     *
+     * 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.
+     */
+    async waitForCompactionRecord(reader, opts, baselineCount) {
+        const sessionId = this.activeSessionId ?? opts.sessionId ?? '';
+        const deadline = Date.now() + this.compactPollTimeoutMs;
+        while (Date.now() < deadline) {
+            if (this.forceFinish || this.stopRequested)
+                return;
+            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;
+            }
+            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) {
+        const events = this.currentTranslator?.handleNotification(method, params) ?? [];
+        this.pushEvents(events);
+    }
+    handleServerRequest(id, method, params) {
+        const events = this.currentTranslator?.handleServerRequest(id, method, params) ?? [];
+        if (events.length === 0) {
+            // Unhandled/unsupported server request must be explicitly responded to
+            // (error = "rejected"), otherwise the server hangs waiting for a
+            // response. For question elicitation (§5.4), auto-respond cancelled.
+            const rpParams = params;
+            if (method === ServerRequestMethod.REQUEST_PERMISSION &&
+                (rpParams.isQuestion || !rpParams.toolCall)) {
+                this.currentClient?.respond(id, { outcome: { outcome: 'cancelled' } });
+                getLogger().info(`[${this.logTag}] auto-responded cancelled to question elicitation requestId=${id}`);
+            }
+            else {
+                this.currentClient?.respondError(id, RpcErrorCode.METHOD_NOT_FOUND, `Unsupported server request: ${method}`);
+            }
+            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,
+                });
+                getLogger().info(`[${this.logTag}] approval requested requestId=${ev.requestId} kind=${ev.kind}`);
+            }
+        }
+        this.pushEvents(events);
+    }
+}
+//# sourceMappingURL=runner.js.map