lark-remote 0.5.4 → 0.5.5

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

@@ -12,17 +12,57 @@
  *       completed → success; aborted/interrupted → interrupted;
  *       blocked/error/max-tokens → error (errorMessage carries the reason)
  *
+ * Token accounting (ccusage 口径, AGENTS.md §9.21): DSH emits ONE usage per model
+ * call (per step) — a tool-looping turn has several `assistant/message` events.
+ * The result event therefore carries **the sum of the turn's samplings**, not the
+ * last one (codex `token_count` has the same shape). `lastUsage` is kept only as
+ * the message/stream watermark and as a fallback when no durable message usage
+ * was persisted (e.g. an interrupted attempt).
+ *
  * DSH TokenUsage: {inputTokens, outputTokens, cacheReadTokens?, cacheWriteTokens?}
  *   → ResultEvent.usage: input_tokens/output_tokens/cache_read_tokens/
  *     cache_creation_tokens (cacheWrite = cache creation) + total_tokens sum.
  */
 import type { AgentEvent, ResultEvent } from '../types.js';
-import type { DshSessionEvent, DshTokenUsage } from './types.js';
+import type { DshAssistantStreamFrame, DshSessionEvent, DshTokenUsage } from './types.js';
+/** 本 turn 各采样用量之和（input 是非缓存输入，与 ccusage/ResultEvent 口径一致）。 */
+interface UsageTotals {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
 export declare class DshTranslator {
-    private liveUsage?;
-    private hasUsage;
+    /** 本 turn 累计用量：DSH 每次模型调用（step）一条 usage，工具往返 = 多条。 */
+    private turnUsage;
+    /** 末次采样的 usage：上下文水位，或只有 live chunk 时的兜底值。 */
+    private lastUsage?;
+    /** 是否收到过 durable assistant/message.usage（唯一累加来源）。 */
+    private hasMessageUsage;
+    /** 是否只收到过 live usage chunk（无 durable message usage 时的兜底）。 */
+    private hasStreamUsage;
+    /** 当前 attempt 的 id（start 帧携带，chunk 帧也带；断开重连重放时不变）。 */
+    private attemptId;
+    /** Translate one live assistant-stream chunk into AgentEvents. */
+    streamFrameToAgentEvents(frame: DshAssistantStreamFrame, _sessionId: string): AgentEvent[];
+    /**
+     * Record durable per-step usage — the accumulation source. assistant/message
+     * carries exactly one usage per model call and is seq-deduped by the client,
+     * so summing it gives the turn total without double counting.
+     */
+    private recordMessageUsage;
+    /**
+     * Record a live usage chunk. Never summed: the same step also arrives as a
+     * durable assistant/message.usage, so summing both would double count. It only
+     * refreshes the watermark and covers a turn whose messages never persisted.
+     */
+    private recordStreamUsage;
+    private chunkToAgentEvents;
     /** Translate one session event into AgentEvents (may be empty). */
     eventToAgentEvents(ev: DshSessionEvent, sessionId: string): AgentEvent[];
 }
 /** Map DSH TokenUsage → ResultEvent.usage (cacheWrite = cache creation). */
 export declare function mapUsage(u: DshTokenUsage): NonNullable<ResultEvent['usage']>;
+/** Map a turn's summed usage → ResultEvent.usage (cacheWrite = cache creation). */
+export declare function mapAggregatedUsage(t: UsageTotals): NonNullable<ResultEvent['usage']>;
+export {};

package/dist/runner/dsh/translator.js

@@ -12,13 +12,96 @@
  *       completed → success; aborted/interrupted → interrupted;
  *       blocked/error/max-tokens → error (errorMessage carries the reason)
  *
+ * Token accounting (ccusage 口径, AGENTS.md §9.21): DSH emits ONE usage per model
+ * call (per step) — a tool-looping turn has several `assistant/message` events.
+ * The result event therefore carries **the sum of the turn's samplings**, not the
+ * last one (codex `token_count` has the same shape). `lastUsage` is kept only as
+ * the message/stream watermark and as a fallback when no durable message usage
+ * was persisted (e.g. an interrupted attempt).
+ *
  * DSH TokenUsage: {inputTokens, outputTokens, cacheReadTokens?, cacheWriteTokens?}
  *   → ResultEvent.usage: input_tokens/output_tokens/cache_read_tokens/
  *     cache_creation_tokens (cacheWrite = cache creation) + total_tokens sum.
  */
 export class DshTranslator {
-    liveUsage;
-    hasUsage = false;
+    /** 本 turn 累计用量：DSH 每次模型调用（step）一条 usage，工具往返 = 多条。 */
+    turnUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    /** 末次采样的 usage：上下文水位，或只有 live chunk 时的兜底值。 */
+    lastUsage;
+    /** 是否收到过 durable assistant/message.usage（唯一累加来源）。 */
+    hasMessageUsage = false;
+    /** 是否只收到过 live usage chunk（无 durable message usage 时的兜底）。 */
+    hasStreamUsage = false;
+    /** 当前 attempt 的 id（start 帧携带，chunk 帧也带；断开重连重放时不变）。 */
+    attemptId = '0';
+    /** Translate one live assistant-stream chunk into AgentEvents. */
+    streamFrameToAgentEvents(frame, _sessionId) {
+        if (frame.type === 'start') {
+            if (frame.attemptId)
+                this.attemptId = frame.attemptId;
+            return [];
+        }
+        if (frame.type !== 'chunk' || !frame.chunk)
+            return [];
+        return this.chunkToAgentEvents(frame.chunk, frame.time ?? Date.now(), frame.attemptId ?? this.attemptId);
+    }
+    /**
+     * Record durable per-step usage — the accumulation source. assistant/message
+     * carries exactly one usage per model call and is seq-deduped by the client,
+     * so summing it gives the turn total without double counting.
+     */
+    recordMessageUsage(usage) {
+        this.turnUsage.input += usage.inputTokens ?? 0;
+        this.turnUsage.output += usage.outputTokens ?? 0;
+        this.turnUsage.cacheRead += usage.cacheReadTokens ?? 0;
+        this.turnUsage.cacheWrite += usage.cacheWriteTokens ?? 0;
+        this.lastUsage = usage;
+        this.hasMessageUsage = true;
+    }
+    /**
+     * Record a live usage chunk. Never summed: the same step also arrives as a
+     * durable assistant/message.usage, so summing both would double count. It only
+     * refreshes the watermark and covers a turn whose messages never persisted.
+     */
+    recordStreamUsage(usage) {
+        this.lastUsage = usage;
+        this.hasStreamUsage = true;
+    }
+    chunkToAgentEvents(chunk, time, attemptId = '0') {
+        if (chunk.type === 'usage' && chunk.usage && typeof chunk.usage === 'object') {
+            this.recordStreamUsage(chunk.usage);
+            return [];
+        }
+        const ts = new Date(time).toISOString();
+        if (chunk.type === 'text-delta' && typeof chunk.text === 'string' && chunk.text) {
+            return [
+                {
+                    type: 'assistant',
+                    message: { content: [{ type: 'text', text: chunk.text }] },
+                    timestamp: ts,
+                },
+            ];
+        }
+        if (chunk.type === 'reasoning-delta' && typeof chunk.text === 'string' && chunk.text) {
+            return [
+                {
+                    type: 'assistant',
+                    message: {
+                        content: [
+                            {
+                                type: 'thinking',
+                                thinking: chunk.text,
+                                // 同一 attempt 的同一 reasoning block：token delta 共享 itemId。
+                                itemId: `r:${attemptId}:${chunk.index}`,
+                            },
+                        ],
+                    },
+                    timestamp: ts,
+                },
+            ];
+        }
+        return [];
+    }
     /** Translate one session event into AgentEvents (may be empty). */
     eventToAgentEvents(ev, sessionId) {
         switch (ev.type) {
@@ -26,40 +109,21 @@ export class DshTranslator {
                 const chunk = ev.data.chunk;
                 if (!chunk)
                     return [];
-                const ts = new Date(ev.time).toISOString();
-                if (chunk.type === 'text-delta' && chunk.text) {
-                    return [
-                        {
-                            type: 'assistant',
-                            message: { content: [{ type: 'text', text: chunk.text }] },
-                            timestamp: ts,
-                        },
-                    ];
-                }
-                if (chunk.type === 'reasoning-delta' && chunk.text) {
-                    return [
-                        {
-                            type: 'assistant',
-                            message: { content: [{ type: 'thinking', thinking: chunk.text }] },
-                            timestamp: ts,
-                        },
-                    ];
-                }
-                return [];
+                return this.chunkToAgentEvents(chunk, ev.time);
             }
             case 'assistant/message': {
                 const raw = ev.data.usage;
                 if (raw && typeof raw === 'object') {
-                    this.liveUsage = raw;
-                    this.hasUsage = true;
+                    this.recordMessageUsage(raw);
                 }
                 return [];
             }
             case 'turn/end': {
-                const reason = ev.data.reason?.kind;
+                const turnReason = ev.data.reason;
+                const reason = turnReason?.kind;
                 const subtype = reason === 'completed'
                     ? 'success'
-                    : reason === 'aborted' || reason === 'interrupted'
+                    : reason === 'aborted' || reason === 'interrupted' || reason === 'forked'
                         ? 'interrupted'
                         : 'error';
                 const result = {
@@ -68,11 +132,19 @@ export class DshTranslator {
                     session_id: sessionId,
                     timestamp: new Date(ev.time).toISOString(),
                 };
-                if (this.hasUsage && this.liveUsage) {
-                    result.usage = mapUsage(this.liveUsage);
+                if (this.hasMessageUsage) {
+                    // 本 turn 各采样之和（多步工具往返 = 多条 assistant/message）。
+                    result.usage = mapAggregatedUsage(this.turnUsage);
+                }
+                else if (this.hasStreamUsage && this.lastUsage) {
+                    // 只有 live usage chunk（消息未落盘，如启动期中断）：退回末次采样。
+                    result.usage = mapUsage(this.lastUsage);
                 }
                 if (subtype === 'error') {
-                    result.errorMessage = `turn ended with reason: ${reason}`;
+                    const detail = turnReason?.error?.message;
+                    result.errorMessage = detail
+                        ? `turn ended with reason: ${reason}: ${detail}`
+                        : `turn ended with reason: ${reason}`;
                 }
                 return [result];
             }
@@ -83,16 +155,21 @@ export class DshTranslator {
 }
 /** Map DSH TokenUsage → ResultEvent.usage (cacheWrite = cache creation). */
 export function mapUsage(u) {
-    const input = u.inputTokens ?? 0;
-    const output = u.outputTokens ?? 0;
-    const cacheRead = u.cacheReadTokens ?? 0;
-    const cacheWrite = u.cacheWriteTokens ?? 0;
+    return mapAggregatedUsage({
+        input: u.inputTokens ?? 0,
+        output: u.outputTokens ?? 0,
+        cacheRead: u.cacheReadTokens ?? 0,
+        cacheWrite: u.cacheWriteTokens ?? 0,
+    });
+}
+/** Map a turn's summed usage → ResultEvent.usage (cacheWrite = cache creation). */
+export function mapAggregatedUsage(t) {
     return {
-        input_tokens: input,
-        output_tokens: output,
-        cache_read_tokens: cacheRead,
-        cache_creation_tokens: cacheWrite,
-        total_tokens: input + output + cacheRead + cacheWrite,
+        input_tokens: t.input,
+        output_tokens: t.output,
+        cache_read_tokens: t.cacheRead,
+        cache_creation_tokens: t.cacheWrite,
+        total_tokens: t.input + t.output + t.cacheRead + t.cacheWrite,
     };
 }
 //# sourceMappingURL=translator.js.map

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

@@ -1,14 +1,20 @@
 /**
  * DSH wire type shapes (DeepSeek Harness HTTP proxy contract).
  *
- * Source of truth: packages/host/apiproxy/src/api/{rpc,sessions,events}.ts and
- * packages/core/session/src/types.ts in the deepseek-harness repo. Only the
- * fields DshClient/DshRunner/DshSessionReader consume are declared here.
+ * Source of truth: @deepseek-ai/dsh-client-connection (unary envelope),
+ * @deepseek-ai/dsh-api-gateway (Remote stream mux) and
+ * @deepseek-ai/dsh-api-session-controller (session Remote methods) in DSH
+ * 0.2.x. Only the fields DshClient/DshRunner/DshSessionReader consume are
+ * declared here.
  *
  * Unary: POST /api/<method>, body `{type:'client-request',rpcId,method,payload}`,
  * response `{type:'server-response',rpcId,result:{ok:true,value}|{ok:false,error}}`.
- * Stream: SSE GET /api/events.mux, frames `data: {type:'server-request',rpcId,
- * method:<frame.type>, payload:<MuxFrame>}\n\n`.
+ * Auth: a signed `dsh-auth-*` cookie is required on every `/api/*` request and
+ * the `/api/remote.mux` WebSocket. The v1 cookie is minted from DSH's durable
+ * browser-session secret, or bootstrapped with `GET /?token=<launch token>`.
+ * Stream: WebSocket `/api/remote.mux` logical streams
+ * `{type:'open',streamId,endpoint:'session/follow',payload}` →
+ * `{type:'item',streamId,value}` / `{type:'end',streamId}`.
  */
 /** One SessionEvent entry (core SessionEvent<T> — seq/time/data discriminated on type). */
 export interface DshSessionEvent {
@@ -16,6 +22,9 @@ export interface DshSessionEvent {
     seq: number;
     time: number;
     data: Record<string, unknown>;
+    ignorable?: true;
+    sourceEventSeqs?: unknown;
+    surfaceOp?: unknown;
 }
 /** TokenUsage from assistant/message.usage (dsh-llm TokenUsage). */
 export interface DshTokenUsage {
@@ -25,31 +34,43 @@ export interface DshTokenUsage {
     cacheWriteTokens?: number;
     reasoningTokens?: number;
 }
-/** SessionSummary row from session.list items[]. */
+/** Projection block returned by session/list / session/projections / follow. */
+export interface DshProjections {
+    kind?: 'cached' | 'sequenced';
+    asOfSeq: number;
+    values: {
+        agentPreset?: string | null;
+        title?: string | null;
+        [key: string]: unknown;
+    };
+}
+/** SessionSummary row from session/list items[]. */
 export interface DshSessionSummary {
     sessionId: string;
     updatedAt: number;
     running: boolean;
     blank: boolean;
     cwd?: string;
-    /** 创建时固定的 preset（/resume preset 一致性校验用）。 */
+    /** Legacy top-level preset (pre-0.2 DSH). */
     agentPreset?: string;
+    /** 0.2.x exposes preset/title through projections. */
+    projections?: DshProjections;
 }
-/** session.list → value. */
+/** session/list → value. */
 export interface DshSessionListValue {
     items: DshSessionSummary[];
 }
-/** session.history → value.events[].event. */
-export interface DshHistoryEntry {
+/** session/page → value.records[]. */
+export interface DshPageRecord {
     event: DshSessionEvent;
     view?: unknown;
 }
-/** session.history → value. */
-export interface DshSessionHistoryValue {
-    events: DshHistoryEntry[];
+/** session/page → value. */
+export interface DshSessionPageValue {
+    records: DshPageRecord[];
     hasMore: boolean;
 }
-/** One model entry inside a provider group (llm.models / session.models groups[].models[]). */
+/** One model entry inside a provider group (session/modelCatalog / session/selectModel groups[].models[]). */
 export interface DshCatalogModel {
     id: string;
     name: string;
@@ -62,14 +83,16 @@ export interface DshCatalogModel {
         defaultEffort?: string;
     };
 }
-/** One provider group of the model catalog (llm.models groups[]). */
+/** One provider group of the model catalog (session/modelCatalog groups[]). */
 export interface DshModelGroup {
     id: string;
     name: string;
     models: DshCatalogModel[];
 }
-/** llm.models → value. */
+/** session/modelCatalog → value. */
 export interface DshModelCatalogValue {
+    default?: DshModelSelection;
+    routableProviders?: string[];
     groups: DshModelGroup[];
     failures?: Array<{
         id: string;
@@ -77,13 +100,13 @@ export interface DshModelCatalogValue {
         message: string;
     }>;
 }
-/** Current model selection (session.models current / session.selectModel selected). */
+/** Current model selection (session/selectModel current / session/selectModel selected). */
 export interface DshModelSelection {
     provider: string;
     model: string;
     reasoningEffort?: string;
 }
-/** One preset row of agentPreset.list. */
+/** One preset row of agentPresets/list. */
 export interface DshPresetEntry {
     id: string;
     trust: 'system' | 'user';
@@ -92,28 +115,167 @@ export interface DshPresetEntry {
     description?: string;
     broken?: string;
 }
-/** agentPreset.list → value. */
+/** agentPresets/list → value. */
 export interface DshPresetListValue {
     presets: DshPresetEntry[];
-    authorable: boolean;
-    hasDocument: boolean;
+    authorable?: boolean;
+    hasDocument?: boolean;
+}
+/** One permission preset from `permissionPresets/catalog`. */
+export interface DshPermissionPresetOption {
+    value: string;
+    name: string;
+    description?: string;
+}
+/** `permissionPresets/catalog` → value. */
+export interface DshPermissionCatalogValue {
+    options: DshPermissionPresetOption[];
+    /** Presets that may be selected as the default for future sessions. */
+    defaultOptions: DshPermissionPresetOption[];
+    defaultPreset: string;
+}
+/** One durable event record inside a follow snapshot / event frame. */
+export interface DshFollowRecord {
+    type: 'event';
+    event: DshSessionEvent;
+}
+/** Opening frame of `session/follow`. */
+export interface DshFollowSnapshot {
+    type: 'snapshot';
+    header?: Record<string, unknown>;
+    cursor: number;
+    records: DshFollowRecord[];
+    hasMore?: boolean;
+    projections?: DshProjections;
+}
+/** Assistant stream chunk emitted while the model is still generating. */
+export type DshStreamChunk = {
+    type: 'text-delta';
+    index: number;
+    text: string;
+} | {
+    type: 'reasoning-delta';
+    index: number;
+    text: string;
+} | {
+    type: 'usage';
+    usage: DshTokenUsage;
+} | {
+    type: string;
+    [key: string]: unknown;
+};
+/** One `assistant-stream` item of the follow stream. */
+export interface DshAssistantStreamFrame {
+    type: 'start' | 'chunk' | 'end';
+    attemptId?: string;
+    revision?: number;
+    index?: number;
+    time?: number;
+    chunk?: DshStreamChunk;
+    outcome?: Record<string, unknown>;
+}
+/** First item of the Gateway-owned `$events` stream. */
+export interface DshRemoteEventReadyFrame {
+    type: 'ready';
+    clientId: string;
+    host: {
+        home: string;
+    };
+}
+/** One pending Agent-scoped approval waterfall delivered by `$events`. */
+export interface DshRemoteEventWaterfallFrame {
+    type: 'waterfall';
+    event: string;
+    eventId: string;
+    agentId: string;
+    request: Record<string, unknown>;
+}
+/** Cancellation of a previously delivered waterfall. */
+export interface DshRemoteEventCancelFrame {
+    type: 'cancel';
+    eventId: string;
+}
+/** Ordinary forwarded notification (not used by the DSH approval path). */
+export interface DshRemoteEventEmitFrame {
+    type: 'emit';
+    event: string;
+    args: unknown[];
 }
-/** ServerRequest envelope (frame.method === frame.payload.type). */
-export interface DshServerRequest {
-    type: 'server-request';
-    rpcId: string;
-    method: string;
-    payload: unknown;
+/** One item of the Gateway-owned `$events` logical stream. */
+export type DshRemoteEventFrame = DshRemoteEventReadyFrame | DshRemoteEventWaterfallFrame | DshRemoteEventCancelFrame | DshRemoteEventEmitFrame;
+/** Answer accepted by `$events/result` for one approval waterfall. */
+export type DshRemoteEventOutcome = {
+    kind: 'next';
+} | {
+    kind: 'result';
+    value?: unknown;
+} | {
+    kind: 'rejected';
+    error: {
+        name: string;
+        message: string;
+        code?: string;
+        details?: unknown;
+    };
+};
+/** Approval-related items yielded while consuming `$events`. */
+export type DshApprovalStreamItem = {
+    kind: 'ready';
+    clientId: string;
+} | {
+    kind: 'request';
+    eventId: string;
+    clientId: string;
+    toolName: string;
+    callId?: string;
+    reason?: string;
+} | {
+    kind: 'cancelled';
+    eventId: string;
+} | {
+    kind: 'unavailable';
+    message: string;
+};
+/** One value yielded by a `session/follow` logical stream. */
+export type DshFollowFrame = DshFollowSnapshot | {
+    type: 'event';
+    event: DshSessionEvent;
+} | {
+    type: 'assistant-stream';
+    frame: DshAssistantStreamFrame;
+};
+/**
+ * Normalized `commands/execute` result.
+ *
+ * DSH's wire value is `CommandExecution { commandId, result: CommandResult }`.
+ * The client flattens that envelope so every caller (compact, permission
+ * alignment) sees one stable shape. The RPC settles only after the command
+ * handler finishes — for `/compact` that means after the compaction completes.
+ * `kind:'error'` is an expected outcome (idle-only violation, no compactable
+ * history, summary failure), not a transport failure, so callers must surface
+ * `text` instead of throwing. `undefined` means the line was not admitted as a
+ * known command at all (admission miss logs nothing and runs nothing).
+ */
+export interface DshCommandResult {
+    commandId?: string;
+    kind?: 'success' | 'error';
+    text?: string;
+    sourceEventSeq?: number;
 }
 /** Unified per-session subscription item: a session event or an approval notice. */
 export type DshStreamItem = {
     kind: 'event';
     sessionId: string;
     event: DshSessionEvent;
+} | {
+    kind: 'assistant-stream';
+    sessionId: string;
+    frame: DshAssistantStreamFrame;
 } | {
     kind: 'approval';
     sessionId: string;
     approvalId: string;
     toolName: string;
+    callId?: string;
     reason?: string;
 };

package/dist/runner/dsh/types.js

@@ -1,14 +1,20 @@
 /**
  * DSH wire type shapes (DeepSeek Harness HTTP proxy contract).
  *
- * Source of truth: packages/host/apiproxy/src/api/{rpc,sessions,events}.ts and
- * packages/core/session/src/types.ts in the deepseek-harness repo. Only the
- * fields DshClient/DshRunner/DshSessionReader consume are declared here.
+ * Source of truth: @deepseek-ai/dsh-client-connection (unary envelope),
+ * @deepseek-ai/dsh-api-gateway (Remote stream mux) and
+ * @deepseek-ai/dsh-api-session-controller (session Remote methods) in DSH
+ * 0.2.x. Only the fields DshClient/DshRunner/DshSessionReader consume are
+ * declared here.
  *
  * Unary: POST /api/<method>, body `{type:'client-request',rpcId,method,payload}`,
  * response `{type:'server-response',rpcId,result:{ok:true,value}|{ok:false,error}}`.
- * Stream: SSE GET /api/events.mux, frames `data: {type:'server-request',rpcId,
- * method:<frame.type>, payload:<MuxFrame>}\n\n`.
+ * Auth: a signed `dsh-auth-*` cookie is required on every `/api/*` request and
+ * the `/api/remote.mux` WebSocket. The v1 cookie is minted from DSH's durable
+ * browser-session secret, or bootstrapped with `GET /?token=<launch token>`.
+ * Stream: WebSocket `/api/remote.mux` logical streams
+ * `{type:'open',streamId,endpoint:'session/follow',payload}` →
+ * `{type:'item',streamId,value}` / `{type:'end',streamId}`.
  */
 export {};
 //# sourceMappingURL=types.js.map

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

@@ -294,6 +294,11 @@ export class KimiAcpRunner extends BaseAcpRunner {
         return this.compactBaselineRecords.length;
     }
     onCompactPromptFired(promptPromise, translator, sessionId, opts, baselineTotalCount) {
+        // 本轮归属锚点（代际 + client），所有 settle 回调落地前复核；
+        // 旧轮迟到的 prompt 结算不得写进新轮的共享队列。
+        const generation = this.turnGeneration;
+        const client = this.currentClient;
+        const isCurrent = () => this.isCurrentTurn(generation, client);
         const compactionReader = this.sessionReader.readCompactionRecords;
         // Derived from the pre-fire snapshot captured by compactBaseline() —
         // re-reading here would race the prompt fire and misclassify new records.
@@ -302,6 +307,8 @@ export class KimiAcpRunner extends BaseAcpRunner {
         // prompt 结算只供两样东西：成功 result 的翻译素材（stopReason/usage）与 §5.4
         // 探针。终态判定不再挂在它后面。
         const promptSettled = promptPromise.then((result) => {
+            if (!isCurrent())
+                return undefined;
             this.promptSettled = true;
             if (compactionReader) {
                 // §5.4 可选防线（日志探针）：prompt settle 后既无新 begin 也无新
@@ -314,6 +321,8 @@ export class KimiAcpRunner extends BaseAcpRunner {
             }
             return result;
         }, (err) => {
+            if (!isCurrent())
+                return undefined;
             promptRejected = true;
             this.handlePromptRejected(err, translator, sessionId, 'compact');
             return undefined;
@@ -321,8 +330,9 @@ export class KimiAcpRunner extends BaseAcpRunner {
         if (!compactionReader) {
             // 读不到 compaction 记录（reader 未实现）：沿用「prompt 结算即成功」的口径。
             void promptSettled.then((result) => {
-                if (result)
-                    this.pushEvents([translator.handlePromptResponse(sessionId, result)]);
+                if (!result || !isCurrent())
+                    return;
+                this.pushEvents([translator.handlePromptResponse(sessionId, result)]);
             });
             return;
         }
@@ -331,6 +341,8 @@ export class KimiAcpRunner extends BaseAcpRunner {
         // 用户拖到通用 turnIdleTimeout（默认 30min），拿到的还是一个语义泛化的 turn
         // 超时，而不是「压缩状态未知 / 可重试」。
         void this.waitForCompactionTerminal(compactionReader, opts, baselineTerminalCount).then(async (outcome) => {
+            if (!isCurrent())
+                return;
             // outcome === 'stopped'：不推 result，由 consumeTurn 的 interrupted 兜底。
             if (outcome === 'stopped' || this.forceFinish || this.stopRequested)
                 return;
@@ -351,7 +363,7 @@ export class KimiAcpRunner extends BaseAcpRunner {
             const result = await promptSettled;
             if (!result || promptRejected)
                 return; // handlePromptRejected 已产 error result
-            if (this.forceFinish || this.stopRequested)
+            if (!isCurrent() || this.forceFinish || this.stopRequested)
                 return;
             this.pushEvents([translator.handlePromptResponse(sessionId, result)]);
         });

package/dist/runner/opencode/acp/error-monitor.d.ts

@@ -2,7 +2,7 @@
  * OpencodeLogErrorMonitor: watches opencode's own log file for LLM stream
  * errors of the active ACP session and reports them immediately.
  *
- * Why this exists: opencode ACP (v1.18.x) does NOT forward retry/error state
+ * Why this exists: opencode ACP (v1.18.x and v2.0.x) does NOT forward retry/error state
  * to the client over the ACP protocol. Its session/update notifications are
  * limited to content deltas (agent_message_chunk / agent_thought_chunk /
  * tool_call / tool_call_update), usage and available-commands updates — there
@@ -34,7 +34,7 @@ export interface OpencodeLogErrorMonitorOptions {
  * Resolve opencode's log file path from the XDG data dir
  * (`$XDG_DATA_HOME/opencode/log/opencode.log`, default
  * `~/.local/share/opencode/log/opencode.log`). Matches opencode's own
- * data-dir layout (open source v1.18.x: `opencode/src/cli/global.ts`).
+ * data-dir layout (verified against v1.18.x and v2.0.32 `debug paths`).
  */
 export declare function resolveOpencodeLogPath(): string;
 export declare class OpencodeLogErrorMonitor {