lark-remote 0.1.11 → 0.1.13

package/dist/runner/claude/session.d.ts

@@ -142,9 +142,6 @@ export declare class ClaudeSession extends SpawningRunner {
      * streamEnded 唤醒等待中的 turn 循环。
      */
     private startStreamReader;
-    /** 最近一次进程退出的 code/signal（流结束错误结果构造用）。 */
-    private exitCode;
-    private exitSignal;
     /**
      * 消费事件队列直到本 turn 的 result 事件（非 compact/compaction）。
      * 消费者提前关闭生成器（bridge 循环体抛错）→ 杀进程防孤儿（P1-11 语义）。

package/dist/runner/claude/session.js

@@ -337,8 +337,6 @@ export class ClaudeSession extends SpawningRunner {
         this.processExitPromise = new Promise((resolve) => {
             proc.once('close', (code, signal) => {
                 this.spawnHeartbeat.clear();
-                this.exitCode = code;
-                this.exitSignal = signal;
                 if (code !== null && code !== 0 && !this.stoppedByUser) {
                     getLogger().error(`[${this.logTag}] non-zero exit code=${code} signal=${signal} stderr=${this.spawnStderr.slice(-500)}`);
                 }
@@ -379,9 +377,6 @@ export class ClaudeSession extends SpawningRunner {
             }
         })();
     }
-    /** 最近一次进程退出的 code/signal（流结束错误结果构造用）。 */
-    exitCode = null;
-    exitSignal = null;
     // =========================================================================
     // Internal: turn consumption
     // =========================================================================

package/dist/runner/codex/app-server/runner.d.ts

@@ -13,7 +13,7 @@
 import type { AgentKind, AgentSessionReader, AgentEvent, AgentStatusInfo, SpawnOptions } from '../../types.js';
 import { JsonRpcClient } from '../../common/jsonrpc/client.js';
 import { type TranslatorEvent } from './translator.js';
-import { type AskForApproval, type SandboxMode, type SandboxPolicy, type InitializeResult } from './protocol-types.js';
+import { type AskForApproval, type SandboxMode, type InitializeResult } from './protocol-types.js';
 import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
 export interface CodexAppServerRunnerOptions {
     kind: AgentKind;
@@ -38,21 +38,6 @@ export interface CodexAppServerRunnerOptions {
     /** Configured approval policy (Codex 官方 AskForApproval 标准值). */
     approvalPolicy?: AskForApproval;
 }
-/**
- * Map the client-side SandboxMode enum to the response-side SandboxPolicy
- * object used by `thread/settings/update` (`sandboxPolicy`).
- */
-export declare function sandboxModeToSandboxPolicy(mode: SandboxMode): SandboxPolicy;
-/**
- * Codex 官方 feature override（thread/start·resume 的 `config` 字段）：
- * 让 `request_user_input` 在 Default 协作模式下也可用，无需改 codex
- * config.toml。协议键与 openai/codex 的 feature registry 一致
- * （key `default_mode_request_user_input`），app-server 官方测试
- * （turn_start.rs）验证同一路径。
- */
-export declare const THREAD_CONFIG_DEFAULT_MODE_REQUEST_USER_INPUT: {
-    readonly 'features.default_mode_request_user_input': true;
-};
 export declare class CodexAppServerRunner extends ConnectionBasedRunner<JsonRpcClient<InitializeResult>, TranslatorEvent> {
     private connectionManager;
     private currentTranslator;

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

@@ -72,7 +72,7 @@ function buildRequestUserInputResponse(action, questions, response) {
  * Map the client-side SandboxMode enum to the response-side SandboxPolicy
  * object used by `thread/settings/update` (`sandboxPolicy`).
  */
-export function sandboxModeToSandboxPolicy(mode) {
+function sandboxModeToSandboxPolicy(mode) {
     switch (mode) {
         case 'read-only':
             return { type: 'readOnly', networkAccess: false };
@@ -95,7 +95,7 @@ export function sandboxModeToSandboxPolicy(mode) {
  * （key `default_mode_request_user_input`），app-server 官方测试
  * （turn_start.rs）验证同一路径。
  */
-export const THREAD_CONFIG_DEFAULT_MODE_REQUEST_USER_INPUT = {
+const THREAD_CONFIG_DEFAULT_MODE_REQUEST_USER_INPUT = {
     'features.default_mode_request_user_input': true,
 };
 export class CodexAppServerRunner extends ConnectionBasedRunner {

package/dist/runner/common/acp/protocol-helpers.d.ts

@@ -12,3 +12,34 @@ import type { PermissionOption } from './protocol-types.js';
  * the documented names and the observed real names (§2.3).
  */
 export declare function findOptionIdByKind(options: PermissionOption[], candidateKinds: string[]): string | undefined;
+/** 各 ACP 服务端的 option kind 候选表（kimi/opencode 观测名不同，语义对齐）。 */
+export interface AcpApprovalKinds {
+    accept: string[];
+    acceptForSession: string[];
+    decline: string[];
+}
+/** kimi 观测 kind（approval.ts:28-29 + 2026-08-15 live：approve_once/approve_always/reject）。 */
+export declare const KIMI_APPROVAL_KINDS: AcpApprovalKinds;
+/** opencode kind（permission.ts:219-223：once/always → approve，其余 → reject）。 */
+export declare const OPENCODE_APPROVAL_KINDS: AcpApprovalKinds;
+/**
+ * 把 bridge 审批动作（accept/accept_for_session/decline/cancel）映射为 ACP
+ * request_permission 响应：按 kind 候选表查 optionId 回显；找不到一律
+ * cancelled（安全兜底——服务端视为拒绝，不会悬挂）。
+ */
+export declare function buildAcpPermissionOutcome(action: string, options: PermissionOption[], kinds: AcpApprovalKinds): {
+    outcome: {
+        outcome: 'cancelled';
+    } | {
+        outcome: 'selected';
+        optionId: string;
+    };
+};
+/**
+ * 从服务端 options kind 派生审批决定列表：accept/decline/cancel 恒有；
+ * 带 always 类 option（kimi approve_always / opencode allow_always）才提供
+ * acceptForSession（§P4「本会话总是允许」）。kimi/opencode 两侧共用。
+ */
+export declare function deriveAcpAvailableDecisions(options: PermissionOption[]): string[];
+/** 截断长文本并追加省略号（translator 审批 reason 用，原先两份相同拷贝）。 */
+export declare function truncateWithEllipsis(text: string, maxLen: number): string;

package/dist/runner/common/acp/protocol-helpers.js

@@ -18,4 +18,52 @@ export function findOptionIdByKind(options, candidateKinds) {
     }
     return undefined;
 }
+/** kimi 观测 kind（approval.ts:28-29 + 2026-08-15 live：approve_once/approve_always/reject）。 */
+export const KIMI_APPROVAL_KINDS = {
+    accept: ['approve_once', 'approve_always', 'allow_once'],
+    acceptForSession: ['approve_always', 'allow_always'],
+    decline: ['reject', 'reject_once'],
+};
+/** opencode kind（permission.ts:219-223：once/always → approve，其余 → reject）。 */
+export const OPENCODE_APPROVAL_KINDS = {
+    accept: ['allow_once', 'allow_always'],
+    acceptForSession: ['allow_always', 'approve_always'],
+    decline: ['reject_once', 'reject'],
+};
+/**
+ * 把 bridge 审批动作（accept/accept_for_session/decline/cancel）映射为 ACP
+ * request_permission 响应：按 kind 候选表查 optionId 回显；找不到一律
+ * cancelled（安全兜底——服务端视为拒绝，不会悬挂）。
+ */
+export function buildAcpPermissionOutcome(action, options, kinds) {
+    if (action === 'cancel') {
+        return { outcome: { outcome: 'cancelled' } };
+    }
+    const candidates = action === 'accept'
+        ? kinds.accept
+        : action === 'accept_for_session'
+            ? kinds.acceptForSession
+            : kinds.decline;
+    const optionId = findOptionIdByKind(options, candidates);
+    return optionId
+        ? { outcome: { outcome: 'selected', optionId } }
+        : { outcome: { outcome: 'cancelled' } };
+}
+/**
+ * 从服务端 options kind 派生审批决定列表：accept/decline/cancel 恒有；
+ * 带 always 类 option（kimi approve_always / opencode allow_always）才提供
+ * acceptForSession（§P4「本会话总是允许」）。kimi/opencode 两侧共用。
+ */
+export function deriveAcpAvailableDecisions(options) {
+    const decisions = ['accept', 'decline', 'cancel'];
+    const hasAlwaysOption = options.some((opt) => opt.kind === 'allow_always' || opt.kind === 'approve_always');
+    if (hasAlwaysOption) {
+        decisions.push('acceptForSession');
+    }
+    return decisions;
+}
+/** 截断长文本并追加省略号（translator 审批 reason 用，原先两份相同拷贝）。 */
+export function truncateWithEllipsis(text, maxLen) {
+    return text.length <= maxLen ? text : text.slice(0, maxLen) + '…';
+}
 //# sourceMappingURL=protocol-helpers.js.map

package/dist/runner/common/connection-based-runner.d.ts

@@ -15,8 +15,6 @@
  * updateApprovalMode, getStatusInfo) and provide the small abstract hooks below.
  */
 import type { AgentKind, AgentSessionReader, AgentEvent, AgentRunner, AgentStatusInfo, SpawnOptions } from '../types.js';
-/** How long to wait for turn output notifications before failing. */
-export declare const TURN_IDLE_TIMEOUT_MS: number;
 export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent> implements AgentRunner {
     readonly kind: AgentKind;
     readonly sessionReader: AgentSessionReader;

package/dist/runner/common/connection-based-runner.js

@@ -2,7 +2,7 @@ import { ConnectionLostError } from './jsonrpc/client.js';
 import { getLogger } from '../../logger/index.js';
 import { syntheticInitEvent } from './runner-utils.js';
 /** How long to wait for turn output notifications before failing. */
-export const TURN_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+const TURN_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
 export class ConnectionBasedRunner {
     kind;
     sessionReader;

package/dist/runner/dsh/index.d.ts

@@ -1,3 +1 @@
 export { DshRunner, type DshRunnerOptions } from './runner.js';
-export { DshClient, DshError } from './client.js';
-export { DshTranslator, mapUsage } from './translator.js';

package/dist/runner/dsh/index.js

@@ -1,4 +1,2 @@
 export { DshRunner } from './runner.js';
-export { DshClient, DshError } from './client.js';
-export { DshTranslator, mapUsage } from './translator.js';
 //# sourceMappingURL=index.js.map

package/dist/runner/dsh/runner.d.ts

@@ -15,8 +15,6 @@
 import type { AgentEvent, AgentSessionReader, AgentStatusInfo, SpawnOptions } from '../types.js';
 import type { AgentRunner } from '../types.js';
 import { DshClient, type WebSocketFactory } from './client.js';
-/** DSH selectModel provider（deepseek-official 是 rc.7 模型目录的 provider）。 */
-export declare const DSH_MODEL_PROVIDER = "deepseek-official";
 export interface DshRunnerOptions {
     kind: 'dsh';
     sessionReader: AgentSessionReader;

package/dist/runner/dsh/runner.js

@@ -16,7 +16,7 @@ import { DshClient } from './client.js';
 import { DshTranslator } from './translator.js';
 import { getLogger } from '../../logger/index.js';
 /** DSH selectModel provider（deepseek-official 是 rc.7 模型目录的 provider）。 */
-export const DSH_MODEL_PROVIDER = 'deepseek-official';
+const DSH_MODEL_PROVIDER = 'deepseek-official';
 export class DshRunner {
     kind = 'dsh';
     sessionReader;

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, 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, 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

@@ -30,9 +30,11 @@ export interface KimiAcpRunnerOptions {
     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;
+    /** §5.2: compaction 等待的沉默超时——距上次观察到任何新 compaction 记录
+     *  （begin/terminal）超过该时长仍未终态才放弃（outcome unknown，卡片 error，
+     *  不再「超时=成功」）。默认 10 分钟（对齐 turnIdleTimeoutMs）。压缩是完整
+     *  LLM 请求（引擎带重试），时长无上限，旧的固定 30s 轮询超时已删除。 */
+    compactIdleTimeoutMs?: number;
     model?: string;
     /** Kimi permission mode (user-facing: manual/auto/yolo). */
     permissionMode?: 'manual' | 'auto' | 'yolo';
@@ -43,7 +45,7 @@ export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient,
     private activeSessionId;
     private model?;
     private permissionMode;
-    private readonly compactPollTimeoutMs;
+    private readonly compactIdleTimeoutMs;
     /** Pending approval requests: requestId → kind + view + options. */
     private pendingApprovals;
     /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
@@ -107,15 +109,20 @@ export declare class KimiAcpRunner extends ConnectionBasedRunner<KimiAcpClient,
      */
     protected setupTurn(message: string, opts: SpawnOptions): Promise<void>;
     /**
-     * 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 滚动空闲看门狗误杀。
      */
-    private waitForCompactionRecord;
+    private waitForCompactionTerminal;
     private handleNotification;
     /**
      * Filter kimi's own Bash tool notifications so the run card doesn't get a

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

@@ -16,15 +16,13 @@ import { StringDecoder } from 'node:string_decoder';
 import { ConnectionManager as KimiAcpConnectionManager, } 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 { 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 +34,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 +66,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}}（多选数组/
@@ -171,7 +132,7 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
     activeSessionId = null;
     model;
     permissionMode;
-    compactPollTimeoutMs;
+    compactIdleTimeoutMs;
     /** Pending approval requests: requestId → kind + view + options. */
     pendingApprovals = new Map();
     /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
@@ -195,7 +156,7 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         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;
+        this.compactIdleTimeoutMs = opts.compactIdleTimeoutMs ?? COMPACT_IDLE_TIMEOUT_MS;
         const managerOpts = {
             binary: opts.binary ?? 'kimi',
             args: opts.acpArgs ?? ['acp'],
@@ -316,17 +277,21 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
                 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 打回复现).
+            // §5.2: compaction is a BACKGROUND task — the prompt settles before the
+            // wire.jsonl terminal record lands. Baseline the terminal record count,
+            // fire the prompt without awaiting (notifications flow through
+            // consumeTurn), then wait for a NEW terminal (complete/apply →
+            // completed; cancel → cancelled) before producing the result. There is
+            // NO total timeout — silence beyond compactIdleTimeoutMs yields
+            // 'unknown' (never a fake success). Keeps the connection alive while the
+            // background compaction finishes — otherwise dispose/exit kills it and
+            // the record never lands (S5/S6 打回复现 / 2026-08-31 事故).
             const compactionReader = this.sessionReader.readCompactionRecords;
-            const baselineCount = compactionReader
-                ? compactionReader.call(this.sessionReader, sessionId, opts.cwd).length
-                : 0;
+            const baselineRecords = compactionReader
+                ? compactionReader.call(this.sessionReader, sessionId, opts.cwd)
+                : [];
+            const baselineTerminalCount = baselineRecords.filter(isCompactionTerminalLike).length;
+            const baselineTotalCount = baselineRecords.length;
             this.promptSettled = false;
             // ACP holds the session/prompt response for the ENTIRE turn (unlike
             // codex turn/start), so the RPC-level timeout must not apply here —
@@ -337,13 +302,37 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
                 if (this.stopRequested)
                     return; // already cancelled
                 if (compactionReader) {
-                    await this.waitForCompactionRecord(compactionReader, opts, baselineCount);
+                    // §5.4 可选防线（日志探针）：prompt settle 后既无新 begin 也无新
+                    // terminal → compact 未被引擎接受（可能已在跑或被拒绝）。不解析
+                    // "already running" 文本、不影响卡片。
+                    const totalNow = compactionReader.call(this.sessionReader, sessionId, opts.cwd).length;
+                    if (totalNow === baselineTotalCount) {
+                        getLogger().warn(`[${this.logTag}] compact 未被引擎接受（无新 begin/terminal 记录，可能已在跑或被拒绝）`);
+                    }
+                    const outcome = await this.waitForCompactionTerminal(compactionReader, opts, baselineTerminalCount);
+                    if (this.forceFinish)
+                        return; // stopped while polling
+                    if (outcome === 'completed') {
+                        // 压缩完成：正常翻译 prompt 结果（subtype success）。
+                        const resultEvent = translator.handlePromptResponse(sessionId, result);
+                        this.pushEvents([resultEvent]);
+                    }
+                    else if (outcome === 'cancelled') {
+                        this.pushEvents([
+                            translator.produceErrorResult(sessionId, '压缩未完成：已被取消或压缩请求失败（可重试）'),
+                        ]);
+                    }
+                    else if (outcome === 'unknown') {
+                        this.pushEvents([
+                            translator.produceErrorResult(sessionId, `压缩状态未知：超过 ${formatIdleWindow(this.compactIdleTimeoutMs)} 未观察到完成/取消记录，压缩可能仍在后台进行`),
+                        ]);
+                    }
+                    // outcome === 'stopped'：不推 result，由 consumeTurn 的 interrupted 兜底。
+                }
+                else {
+                    const resultEvent = translator.handlePromptResponse(sessionId, result);
+                    this.pushEvents([resultEvent]);
                 }
-                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) {
@@ -367,7 +356,7 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         const action = response?.action ?? 'decline';
         const acpResponse = pending.kind === 'question'
             ? buildQuestionResponse(action, pending, response)
-            : buildApprovalResponse(action, pending);
+            : buildAcpPermissionOutcome(action, pending.options, KIMI_APPROVAL_KINDS);
         client.respond(requestId, acpResponse);
         this.pendingApprovals.delete(requestId);
         getLogger().info(`[${this.logTag}] approval responded requestId=${requestId} action=${action}`);
@@ -447,8 +436,8 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         }
         this.activeSessionId = sessionId;
         // CC-07: 下发配置的模型（provider/model）。session/new|resume 只带 cwd/mcpServers，
-        // 不带 model；不主动下发则实际跑 kimi 服务端默认模型（旧 KimiRunner 通过 -m 传模型，
-        // 迁移到纯 ACP 后丢失）。仿 opencode 用 session/set_config_option。失败仅告警不阻断。
+        // 不带 model；不主动下发则实际跑 kimi 服务端默认模型。
+        // 仿 opencode 用 session/set_config_option。失败仅告警不阻断。
         if (this.model) {
             try {
                 await client.request('session/set_config_option', {
@@ -511,28 +500,47 @@ export class KimiAcpRunner extends ConnectionBasedRunner {
         });
     }
     /**
-     * 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），

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

@@ -127,7 +127,6 @@ export declare class KimiAcpTranslator {
      * accept/decline/cancel are universal; acceptForSession requires an
      * always-class option (kimi `approve_always`, opencode `allow_always`).
      */
-    private deriveAvailableDecisions;
     /**
      * ResultEvent.usage requires input_tokens/output_tokens: number, but the
      * ACP wire has no such split — the live snapshot is context occupancy only.

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

@@ -30,6 +30,7 @@
  */
 import { makeQuestionApprovalEvent } from '../../question-common.js';
 import { NotificationMethod, ServerRequestMethod, SessionEventType, } from '../../common/acp/protocol-types.js';
+import { deriveAcpAvailableDecisions, truncateWithEllipsis, } from '../../common/acp/protocol-helpers.js';
 import { getLogger } from '../../../logger/index.js';
 /**
  * Fixed snapshot item ids: ACP has exactly one text stream and one thinking
@@ -328,10 +329,12 @@ export class KimiAcpTranslator {
             requestId,
             kind: 'command',
             command: params.toolCall?.title ?? undefined,
-            reason: params.toolCall?.rawInput ? truncate(params.toolCall.rawInput, 200) : undefined,
+            reason: params.toolCall?.rawInput
+                ? truncateWithEllipsis(params.toolCall.rawInput, 200)
+                : undefined,
             // §P4: 从服务端 options kind 派生——带 approve_always（或 allow_always）
             // 才提供「本会话总是允许」（acceptForSession）；否则与旧行为一致。
-            availableDecisions: this.deriveAvailableDecisions(params),
+            availableDecisions: deriveAcpAvailableDecisions(params.options ?? []),
         };
         return [
             {
@@ -372,14 +375,6 @@ export class KimiAcpTranslator {
      * accept/decline/cancel are universal; acceptForSession requires an
      * always-class option (kimi `approve_always`, opencode `allow_always`).
      */
-    deriveAvailableDecisions(params) {
-        const decisions = ['accept', 'decline', 'cancel'];
-        const hasAlwaysOption = (params.options ?? []).some((opt) => opt.kind === 'approve_always' || opt.kind === 'allow_always');
-        if (hasAlwaysOption) {
-            decisions.push('acceptForSession');
-        }
-        return decisions;
-    }
     // =========================================================================
     // Private helpers
     // =========================================================================
@@ -396,9 +391,6 @@ export class KimiAcpTranslator {
 // =============================================================================
 // Helpers
 // =============================================================================
-function truncate(text, maxLen) {
-    return text.length <= maxLen ? text : text.slice(0, maxLen) + '…';
-}
 /** elicitation schema property → UserQuestion（无法解析返回 null）。 */
 function elicitationPropertyToQuestion(prop) {
     const title = prop.title?.trim();