lark-remote 0.5.19 → 0.5.21

package/dist/runner/common/acp/base-acp-runner.js

@@ -65,7 +65,7 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
      * 自身半死：opencode v2 的 location 在每轮拉起的 `opencode acp` 子进程里 boot，
      * boot 期间后台服务不可用会让它长期停在未激活，后续轮次复用同一连接只会重复
      * 失败——用户重启 opencode service 也治不好，因为连接缓存在本进程里
-     * （2026-10-30 现场：4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
+     * （4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
      * 后下一轮重新 spawn，拿到的是新进程的新状态。
      *
      * 只对声明为可重试的错误生效：kimi 等沿用默认 `isRetryableSessionSetupError`
@@ -123,6 +123,21 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
     notifyIdle(cwd) {
         this.connectionManager.notifyIdle(cwd);
     }
+    notifyConnectionActivity(cwd) {
+        this.connectionManager.notifyActivity(cwd);
+    }
+    /** Wire the acquired client's hooks into the turn dispatcher (anchor-guarded). */
+    installTurnHooks(anchor) {
+        anchor.client.setHooks({
+            onNotification: this.forCurrentTurn(anchor, 'notification', (method, params) => this.handleNotification(method, params)),
+            onServerRequest: this.forCurrentTurn(anchor, 'server request', (id, method, params) => this.handleServerRequest(id, method, params)),
+            onClose: this.forCurrentTurn(anchor, 'connection close', () => {
+                getLogger().warn(`[${this.logTag}] client connection closed`);
+                this.onConnectionClosed();
+                this.failTurn(this.connectionClosedMessage);
+            }),
+        });
+    }
     async disposeConnections() {
         await this.beforeDisposeConnections();
         await this.connectionManager.disposeAll();
@@ -201,36 +216,12 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
      * session/resume (existing sessionId) → applyTurnSettings → session/prompt.
      */
     async setupTurn(message, opts) {
-        // 本轮回调归属锚点：代际 + client 都不可变。旧轮迟到的 prompt
-        // 结果/通知在新轮开始时 stopRequested 已被重置，只有这两个值能识别它。
-        const generation = this.turnGeneration;
-        const client = await this.connectionManager.acquire(opts.cwd);
-        this.connectionManager.notifyActivity(opts.cwd);
-        this.currentClient = client;
+        // 本轮回调归属锚点（代际 + client）由 acquireForTurn 捕获：旧轮迟到的
+        // prompt 结果/通知在新轮开始时 stopRequested 已被重置，只有这对值能识别它。
+        const anchor = await this.acquireForTurn(opts.cwd, () => this.connectionManager.acquire(opts.cwd));
         this.onConnectionAcquired(opts);
-        client.setHooks({
-            onNotification: (method, params) => {
-                if (!this.isCurrentTurn(generation, client)) {
-                    getLogger().debug(`[${this.logTag}] dropped notification from a finished turn`);
-                    return;
-                }
-                this.handleNotification(method, params);
-            },
-            onServerRequest: (id, method, params) => {
-                if (!this.isCurrentTurn(generation, client)) {
-                    getLogger().debug(`[${this.logTag}] dropped server request from a finished turn`);
-                    return;
-                }
-                this.handleServerRequest(id, method, params);
-            },
-            onClose: () => {
-                if (!this.isCurrentTurn(generation, client))
-                    return;
-                getLogger().warn(`[${this.logTag}] client connection closed`);
-                this.onConnectionClosed();
-                this.failTurn(this.connectionClosedMessage);
-            },
-        });
+        this.installTurnHooks(anchor);
+        const { client } = anchor;
         let sessionId;
         if (opts.sessionId) {
             const resumeParams = {
@@ -267,19 +258,7 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
         this.promptSettled = false;
         const promptPromise = client.request('session/prompt', promptParams, Number.POSITIVE_INFINITY);
         this.promptSent = true;
-        promptPromise.then((result) => {
-            if (!this.isCurrentTurn(generation, client)) {
-                getLogger().debug(`[${this.logTag}] dropped late prompt result from a finished turn`);
-                return;
-            }
-            this.handlePromptResolved(result, translator, sessionId);
-        }, (err) => {
-            if (!this.isCurrentTurn(generation, client)) {
-                getLogger().debug(`[${this.logTag}] dropped late prompt rejection from a finished turn`);
-                return;
-            }
-            this.handlePromptRejected(err, translator, sessionId, '');
-        });
+        promptPromise.then(this.forCurrentTurn(anchor, 'late prompt result', (result) => this.handlePromptResolved(result, translator, sessionId)), this.forCurrentTurn(anchor, 'late prompt rejection', (err) => this.handlePromptRejected(err, translator, sessionId, '')));
     }
     /**
      * Run a compact operation on the current session: resume → '/compact'
@@ -287,29 +266,11 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
      */
     async *runCompact(_message, opts) {
         yield* this.executeTurn(opts, async () => {
-            const generation = this.turnGeneration;
-            const client = await this.connectionManager.acquire(opts.cwd);
-            this.connectionManager.notifyActivity(opts.cwd);
-            this.currentClient = client;
+            // 同 setupTurn：acquireForTurn 捕获代际锚点，installTurnHooks 守卫 dispatch。
+            const anchor = await this.acquireForTurn(opts.cwd, () => this.connectionManager.acquire(opts.cwd));
             this.onConnectionAcquired(opts);
-            client.setHooks({
-                onNotification: (method, params) => {
-                    if (!this.isCurrentTurn(generation, client))
-                        return;
-                    this.handleNotification(method, params);
-                },
-                onServerRequest: (id, method, params) => {
-                    if (!this.isCurrentTurn(generation, client))
-                        return;
-                    this.handleServerRequest(id, method, params);
-                },
-                onClose: () => {
-                    if (!this.isCurrentTurn(generation, client))
-                        return;
-                    this.onConnectionClosed();
-                    this.failTurn(this.connectionClosedMessage);
-                },
-            });
+            this.installTurnHooks(anchor);
+            const { client } = anchor;
             const sessionId = opts.sessionId;
             if (!sessionId) {
                 throw new Error('compact requires a sessionId');

package/dist/runner/common/acp/base-translator.d.ts

@@ -4,7 +4,7 @@
  * Both agents' session/update notification envelopes, prompt-response
  * stopReason mapping, tool_call/tool_call_update normalization, usage_update
  * occupancy bookkeeping and self-produced turn_started events are
- * line-for-line identical — extracted here in the 2026-09 round-2
+ * line-for-line identical — extracted here in the round-2
  * simplification. What genuinely diverges is the content channel:
  * kimi accumulates wire deltas into turn_diff snapshots (snapshot semantics,
  * see KimiAcpTranslator header), opencode forwards `assistant` deltas
@@ -21,6 +21,16 @@
  */
 import type { AgentEvent, ApprovalRequestedEvent, ApprovalView, ResultEvent, TurnStartedEvent } from '../../types.js';
 import { type AgentMessageChunkEvent, type AgentThoughtChunkEvent, type ToolCallEvent, type ToolCallUpdateEvent, type UsageUpdateEvent, type RequestPermissionParams, type AcpPlanEvent } from './protocol-types.js';
+/**
+ * Plan entries → 「图标 + 标题」markdown 清单（每行一条，`\n` join）。
+ * ACP 与 codex 双抄收编（R5）；subtitle 拼接、trim、空清单语义等差异留在
+ * 各自调用点。
+ */
+export declare function renderPlanMarkdown(entries: ReadonlyArray<{
+    title: string;
+    subtitle?: string;
+    status?: string;
+}>): string;
 /** Self-produced turn_started event (no wire equivalent — produced on prompt start). */
 export type AcpTurnStartedEvent = TurnStartedEvent;
 /**
@@ -58,7 +68,7 @@ export declare abstract class BaseAcpTranslator {
     /**
      * Latest streaming-args text per tool call (keyed by wire toolCallId).
      * kimi ACP sends the permission request BEFORE tool.call.started (verified
-     * live against kimi 0.42.0, 2026-09-13): the request_permission toolCall
+     * against kimi 0.42.0): the request_permission toolCall
      * carries only title + a truncated summary in content, NO rawInput — the
      * full args only ever reach the client as accumulated text in the
      * tool_call/tool_call_update streaming deltas. Tracking them here lets the

package/dist/runner/common/acp/base-translator.js

@@ -1,4 +1,4 @@
-import { makeTurnStartedEvent } from '../turn-started.js';
+import { produceTurnStartedEvent } from '../turn-started.js';
 import { NotificationMethod, ServerRequestMethod, SessionEventType, } from './protocol-types.js';
 /**
  * ACP tool kind → 常用工具名映射（信息保真，数据驱动无 agent 分支）。
@@ -12,6 +12,32 @@ const KIND_TO_TOOL = {
     search: 'Grep',
     fetch: 'WebFetch',
 };
+/**
+ * Plan 条目 status → 渲染图标。未知/缺省 status 一律按 pending 渲染——
+ * 两处调用点（ACP handlePlan / codex handleTurnPlanUpdated）注释都点名防
+ * wire 枚举漂移，新增枚举值时只改这张表。
+ */
+const PLAN_STATUS_ICONS = {
+    completed: '✅',
+    in_progress: '🔄',
+    pending: '⬜',
+    error: '❌',
+};
+/**
+ * Plan entries → 「图标 + 标题」markdown 清单（每行一条，`\n` join）。
+ * ACP 与 codex 双抄收编（R5）；subtitle 拼接、trim、空清单语义等差异留在
+ * 各自调用点。
+ */
+export function renderPlanMarkdown(entries) {
+    return entries
+        .map((entry) => {
+        const status = entry.status && entry.status in PLAN_STATUS_ICONS
+            ? entry.status
+            : 'pending';
+        return `${PLAN_STATUS_ICONS[status]} ${entry.title}${entry.subtitle ? ` — ${entry.subtitle}` : ''}`;
+    })
+        .join('\n');
+}
 /**
  * Join the text payloads of a tool_call(/_update) content array
  * (`[{type:'content', content:{type:'text', text}}]` entries). Returns
@@ -42,6 +68,19 @@ function stringifyUnknown(value) {
         return String(value);
     }
 }
+/**
+ * 记录最新值并给 map 封顶（删最老 key，近似 LRU）。
+ * `trackToolCallArgs` 与 `trackToolCallName` 曾是逐字相同的两段，合并到这里。
+ */
+function trackBounded(map, key, value) {
+    map.delete(key);
+    map.set(key, value);
+    if (map.size > 100) {
+        const oldest = map.keys().next().value;
+        if (oldest !== undefined)
+            map.delete(oldest);
+    }
+}
 // =============================================================================
 // Translator base class
 // =============================================================================
@@ -59,7 +98,7 @@ export class BaseAcpTranslator {
     /**
      * Latest streaming-args text per tool call (keyed by wire toolCallId).
      * kimi ACP sends the permission request BEFORE tool.call.started (verified
-     * live against kimi 0.42.0, 2026-09-13): the request_permission toolCall
+     * against kimi 0.42.0): the request_permission toolCall
      * carries only title + a truncated summary in content, NO rawInput — the
      * full args only ever reach the client as accumulated text in the
      * tool_call/tool_call_update streaming deltas. Tracking them here lets the
@@ -145,8 +184,9 @@ export class BaseAcpTranslator {
      * is sent (no wire notification for this — self-produced).
      */
     produceTurnStarted(sessionId, turnId) {
-        this.currentTurnId = turnId;
-        return makeTurnStartedEvent(sessionId, turnId, this.operationKind);
+        return produceTurnStartedEvent(sessionId, turnId, this.operationKind, (_sessionId, t) => {
+            this.currentTurnId = t;
+        });
     }
     approvalRequestedEvents(requestId, sessionId, view) {
         return [
@@ -213,16 +253,12 @@ export class BaseAcpTranslator {
      * completed）。基类具体方法：kimi/opencode wire 结构相同，直接复用。
      */
     handlePlan(event) {
-        const ICON = { completed: '✅', in_progress: '🔄', pending: '⬜', error: '❌' };
         const entries = Array.isArray(event.entries) ? event.entries : [];
-        const markdown = entries
-            .map((e) => {
+        const markdown = renderPlanMarkdown(entries.map((e) => {
             const entry = e;
-            const status = entry.status && entry.status in ICON ? entry.status : 'pending';
-            return `${ICON[status]} ${entry.content ?? ''}`;
-        })
-            .join('\n')
-            .trim();
+            // ACP 条目的正文字段是 content（codex 是 title），无 subtitle。
+            return { title: entry.content ?? '', status: entry.status };
+        })).trim();
         if (!markdown)
             return [];
         return [{ type: 'plan', plan: markdown, timestamp: new Date().toISOString() }];
@@ -384,23 +420,11 @@ export class BaseAcpTranslator {
     }
     /** Record latest args text, bounded so a long session cannot grow it forever. */
     trackToolCallArgs(toolCallId, argsText) {
-        this.toolCallArgsByCallId.delete(toolCallId);
-        this.toolCallArgsByCallId.set(toolCallId, argsText);
-        if (this.toolCallArgsByCallId.size > 100) {
-            const oldest = this.toolCallArgsByCallId.keys().next().value;
-            if (oldest !== undefined)
-                this.toolCallArgsByCallId.delete(oldest);
-        }
+        trackBounded(this.toolCallArgsByCallId, toolCallId, argsText);
     }
     /** Record tool_use name, bounded to keep a long session from growing it. */
     trackToolCallName(toolCallId, name) {
-        this.toolCallNameByCallId.delete(toolCallId);
-        this.toolCallNameByCallId.set(toolCallId, name);
-        if (this.toolCallNameByCallId.size > 100) {
-            const oldest = this.toolCallNameByCallId.keys().next().value;
-            if (oldest !== undefined)
-                this.toolCallNameByCallId.delete(oldest);
-        }
+        trackBounded(this.toolCallNameByCallId, toolCallId, name);
     }
     /**
      * tool_result content extraction. Default: rawOutput passthrough (kimi

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

@@ -238,7 +238,7 @@ export interface PermissionOption {
 export interface RequestPermissionParams {
     sessionId: string;
     /**
-     * Approval target. Divergence by server (2026-09-13 live probes):
+     * Approval target. Divergence by server:
      *  - kimi 0.42: {toolCallId, title: toolName, content: [truncated summary
      *    text]} — NO rawInput; the approval gate fires BEFORE tool.call.started,
      *    so the full args only exist in the pre-approval tool_call/_update

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

@@ -43,7 +43,7 @@ export const RpcErrorCode = {
 // =============================================================================
 // Notifications (server → client, via session/update)
 // Shape source: kimi-code/packages/acp-server/src/events-map.ts
-//   (each constructor below) + 2026-08-15 live smoke test against kimi 0.36.0
+//   (each constructor below) + verified against kimi 0.36.0
 //
 // REAL envelope: {sessionId, update: {sessionUpdate: '<kind>', ...}}.
 // The discriminator field is `update.sessionUpdate` — there is NO nested
@@ -72,7 +72,7 @@ export const SessionEventType = {
 // Server Requests (approval — reverse RPC)
 // Shape source: kimi-code/packages/acp-server/src/approval.ts:28-29
 //   options: [{optionId, name, kind}]; optionId is opaque, echo back as-is
-//   + 2026-08-15 live smoke test: approve_once / approve_always / reject
+//   + verified against kimi 0.36.0: approve_once / approve_always / reject
 // =============================================================================
 export const ServerRequestMethod = {
     REQUEST_PERMISSION: 'session/request_permission',

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

@@ -18,6 +18,18 @@ import type { AgentKind } from '../../agent-kinds.js';
 import type { AgentSessionReader } from '../../session-contract.js';
 import type { AgentEvent, AgentRunner, AgentStatusInfo, SpawnOptions } from '../types.js';
 import type { AgentStopper } from '../../platform/agent-stopper.js';
+/**
+ * 本轮回调的归属锚点（generation + client），由 {@link ConnectionBasedRunner.acquireForTurn}
+ * 捕获。两个值在整轮内不可变：旧轮迟到的回调（prompt 结果 / 通知 / onClose）在
+ * 新轮开始时 `stopRequested` 已被重置，只有这对值能识别它们——pi 的教训是旧 client
+ * 上残留的上一轮 onClose 闭包会把假错误推进新 turn 的共享队列（用户消息未发出即
+ * 丢失），迟到的 agent_settled 同理（新 turn 空转立即「成功」）。所有 hook 的事件
+ * 落地前必须过 {@link ConnectionBasedRunner.isCurrentTurn} 守卫。
+ */
+export interface TurnAnchor<TClient> {
+    readonly client: TClient;
+    readonly generation: number;
+}
 export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent> implements AgentRunner {
     readonly kind: AgentKind;
     readonly sessionReader: AgentSessionReader;
@@ -115,7 +127,7 @@ export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent
     /**
      * Mark this runner as evicted from the bridge's runner cache while a run may
      * still be holding/creating connections on it (queue-advance race during
-     * interruptCurrentRun's await window, 2026-10-11). The active run's finally
+     * interruptCurrentRun's await window). The active run's finally
      * disposes connections eagerly instead of arming the idle TTL timer —
      * otherwise the agent server process lingers for up to 30 minutes holding
      * its session write lock (codex: "thread already has an active writer").
@@ -145,6 +157,25 @@ export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent
      * server request 一律只记 debug，不得进入共享 notificationQueue。
      */
     protected isCurrentTurn(generation: number, client: TClient | null): boolean;
+    /**
+     * Acquire the per-turn connection and capture the callback anchor
+     * ({@link TurnAnchor}): acquire → activity ping → currentClient → anchor.
+     * Shared preamble of every setupTurn / runCompact; the acquired anchor is
+     * what the turn's hooks (and prompt-settle callbacks) validate against.
+     *
+     * `acquire` is a closure so subclasses keep their own acquire signatures
+     * (pi passes the spawn-bound `{ sessionId }`).
+     */
+    protected acquireForTurn(cwd: string, acquire: () => Promise<TClient>): Promise<TurnAnchor<TClient>>;
+    /** Per-cwd activity ping on the subclass connection manager (mirror of notifyIdle). */
+    protected abstract notifyConnectionActivity(cwd: string): void;
+    /**
+     * Wrap a per-turn callback with the isCurrentTurn guard: events from a
+     * finished turn are dropped with a debug log and never reach the turn
+     * dispatcher. 6 处守卫原有的日志粒度不一（ACP setupTurn 记 debug，其余静默），
+     * 统一为最详细版本：dropped 一律 debug，便于事后追溯。
+     */
+    protected forCurrentTurn<A extends unknown[]>(anchor: TurnAnchor<TClient>, label: string, handler: (...args: A) => void): (...args: A) => void;
     protected failTurn(message: string): void;
     protected resetRunState(): void;
     /** Release the connection + detach stale client hooks after a lost connection. */

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

@@ -150,7 +150,7 @@ export class ConnectionBasedRunner {
                 // 已被缓存层除名（evictRunnerSlot → markOrphaned）：本次 run 创建的
                 // 连接挂在无人托管的实例上。主动收掉而不是挂 idle timer——否则 agent
                 // server 进程残留至 idle TTL，期间持有 agent 侧会话写锁（codex
-                // "thread already has an active writer"，2026-10-11 线上实测）。
+                // "thread already has an active writer"）。
                 // dispose() 内部自带 try/catch，这里 fire-and-forget 不阻塞事件流收尾。
                 void this.disposeConnections().catch((err) => {
                     getLogger().warn(`[${this.logTag}] orphan dispose error: ${err.message}`);
@@ -209,7 +209,7 @@ export class ConnectionBasedRunner {
     /**
      * Mark this runner as evicted from the bridge's runner cache while a run may
      * still be holding/creating connections on it (queue-advance race during
-     * interruptCurrentRun's await window, 2026-10-11). The active run's finally
+     * interruptCurrentRun's await window). The active run's finally
      * disposes connections eagerly instead of arming the idle TTL timer —
      * otherwise the agent server process lingers for up to 30 minutes holding
      * its session write lock (codex: "thread already has an active writer").
@@ -331,6 +331,36 @@ export class ConnectionBasedRunner {
     isCurrentTurn(generation, client) {
         return this._isRunning && generation === this.turnGeneration && client === this.currentClient;
     }
+    /**
+     * Acquire the per-turn connection and capture the callback anchor
+     * ({@link TurnAnchor}): acquire → activity ping → currentClient → anchor.
+     * Shared preamble of every setupTurn / runCompact; the acquired anchor is
+     * what the turn's hooks (and prompt-settle callbacks) validate against.
+     *
+     * `acquire` is a closure so subclasses keep their own acquire signatures
+     * (pi passes the spawn-bound `{ sessionId }`).
+     */
+    async acquireForTurn(cwd, acquire) {
+        const client = await acquire();
+        this.notifyConnectionActivity(cwd);
+        this.currentClient = client;
+        return { client, generation: this.turnGeneration };
+    }
+    /**
+     * Wrap a per-turn callback with the isCurrentTurn guard: events from a
+     * finished turn are dropped with a debug log and never reach the turn
+     * dispatcher. 6 处守卫原有的日志粒度不一（ACP setupTurn 记 debug，其余静默），
+     * 统一为最详细版本：dropped 一律 debug，便于事后追溯。
+     */
+    forCurrentTurn(anchor, label, handler) {
+        return (...args) => {
+            if (!this.isCurrentTurn(anchor.generation, anchor.client)) {
+                getLogger().debug(`[${this.logTag}] dropped ${label} from a finished turn`);
+                return;
+            }
+            handler(...args);
+        };
+    }
     failTurn(message) {
         this.pushEvents([
             {