lark-remote 0.5.13 → 0.5.15

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

@@ -1,4 +1,17 @@
-import { type AgentEvent, type SpawnOptions, type AgentSessionReader, type AgentRunner, type AgentStatusInfo } from '../types.js';
+/**
+ * Claude Runner 实现
+ *
+ * ClaudeRunner 从「一次一跑」（claude -p <msg> --permission-mode
+ * bypassPermissions）升级为长驻交互会话（--input-format stream-json 双向
+ * 通道），同时复用本项目已有的 ApprovalCoordinator + run 卡审批区。
+ *
+ * 架构：ClaudeRunner 是 workspace-lifetime 的薄包装，进程与协议细节在
+ * ClaudeSession（src/runner/claude/session.ts，extends SpawningRunner 复用
+ * pid 文件/killOrphan/Terminator/心跳/退出分发器机制）。每次 run() 委托
+ * session：确保进程（可 --resume）→ 写 user 消息 → 消费事件直到本 turn result。
+ */
+import type { AgentSessionReader } from '../../session-contract.js';
+import { type AgentEvent, type SpawnOptions, type AgentRunner, type AgentStatusInfo } from '../types.js';
 /**
  * Claude Agent Runner（长驻交互模式）。
  *
@@ -23,7 +36,12 @@ export declare class ClaudeRunner implements AgentRunner {
         pidDir?: string;
         cwd: string;
         spawnHeartbeatMs?: number;
-        sessionReader?: AgentSessionReader;
+        /**
+         * 由组合根（`src/index.ts`）注入，与 sessionReaderRegistry 里的**同一个**实例。
+         * claude 不在此处自己 new：那会让 runner 反向依赖 session 层（runner ↔ session
+         * 循环的一半）；其余 agent 从一开始就是注入的。
+         */
+        sessionReader: AgentSessionReader;
         /** Claude 权限模式（官方 --permission-mode 枚举；'default'=省略参数）。 */
         permissionMode?: string;
         /** 会话级空闲回收 TTL（ms）；0=禁用。 */

package/dist/runner/claude/runner.js

@@ -1,18 +1,5 @@
-/**
- * Claude Runner 实现
- *
- * ClaudeRunner 从「一次一跑」（claude -p <msg> --permission-mode
- * bypassPermissions）升级为长驻交互会话（--input-format stream-json 双向
- * 通道），同时复用本项目已有的 ApprovalCoordinator + run 卡审批区。
- *
- * 架构：ClaudeRunner 是 workspace-lifetime 的薄包装，进程与协议细节在
- * ClaudeSession（src/runner/claude/session.ts，extends SpawningRunner 复用
- * pid 文件/killOrphan/Terminator/心跳/退出分发器机制）。每次 run() 委托
- * session：确保进程（可 --resume）→ 写 user 消息 → 消费事件直到本 turn result。
- */
-import { ClaudeSessionReader } from '../../session/claude/index.js';
 import { ClaudeSession } from './session.js';
-import { MODEL_ID_TO_ALIAS } from '../../config/index.js';
+import { MODEL_ID_TO_ALIAS } from '../../model-catalog.js';
 /**
  * Claude 内建压缩命令。stream-json 输入模式下该文本会被 CLI 本地拦截为
  * slash 命令（不会作为模型提示词转发），压缩 turn 以普通 result 收尾
@@ -40,7 +27,7 @@ export class ClaudeRunner {
         this.defaultModel = opts.model ?? 'claude-opus-4-8';
         this.defaultEffort = opts.effort ?? 'medium';
         this.permissionMode = opts.permissionMode ?? 'auto';
-        this.sessionReader = opts.sessionReader ?? new ClaudeSessionReader();
+        this.sessionReader = opts.sessionReader;
         this.session = new ClaudeSession({
             pidDir: opts.pidDir,
             cwd: opts.cwd,

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

@@ -10,7 +10,9 @@
  * queue + waitResolve pump, forceFinish/stopRequested semantics, turn idle
  * watchdog, and ConnectionLostError respawn-and-retry-once.
  */
-import type { AgentKind, AgentSessionReader, AgentEvent, AgentStatusInfo, SpawnOptions } from '../../types.js';
+import type { AgentKind } from '../../../agent-kinds.js';
+import type { AgentSessionReader } from '../../../session-contract.js';
+import type { 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 InitializeResult } from './protocol-types.js';

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

@@ -105,6 +105,17 @@ export declare class CodexAppServerTranslator {
     private handleCommandApproval;
     private handleFileApproval;
     private handleItemStarted;
+    /**
+     * turn_diff 的统一信封：`type` + threadId/turnId/timestamp 三个公共字段在此
+     * 一次装配（十余个构造点原本各抄一遍，还得挂 `as TurnDiffEvent`）。
+     */
+    private turnDiffEvent;
+    /**
+     * 工具型 item 的 started 处理（commandExecution / webSearch / mcpToolCall /
+     * dynamicToolCall 四个分支同形）：登记「已开始」锚点 + 记录工具身份 meta，
+     * 再发一帧空的 turn_diff 把工具块按真实时序插进卡片。
+     */
+    private beginToolItem;
     private handlePermissionsApproval;
     private buildPermissionItems;
     /** Get (or lazily create) the reasoning accumulator for one item. */

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

@@ -152,15 +152,10 @@ export class CodexAppServerTranslator {
                             complete: true,
                             timestamp: this.now(),
                         }
-                        : {
-                            type: 'turn_diff',
-                            text,
-                            itemId: item.id,
-                            complete: true,
+                        : this.turnDiffEvent({
                             threadId: params?.threadId ?? this.threadId,
                             turnId: params?.turn?.id ?? this.turnId,
-                            timestamp: this.now(),
-                        });
+                        }, { text, itemId: item.id, complete: true }));
                 }
             }
             else if (item.type === 'plan') {
@@ -169,15 +164,10 @@ export class CodexAppServerTranslator {
                 const planText = item.text ?? '';
                 if (planText && this.planByItem.get(item.id) !== planText) {
                     this.planByItem.set(item.id, planText);
-                    events.push({
-                        type: 'turn_diff',
-                        plan: planText,
-                        itemId: item.id,
-                        complete: true,
+                    events.push(this.turnDiffEvent({
                         threadId: params?.threadId ?? this.threadId,
                         turnId: params?.turn?.id ?? this.turnId,
-                        timestamp: this.now(),
-                    });
+                    }, { plan: planText, itemId: item.id, complete: true }));
                 }
             }
         }
@@ -272,30 +262,17 @@ export class CodexAppServerTranslator {
                 },
             ];
         }
-        return [
-            {
-                type: 'turn_diff',
-                text: next,
-                itemId: params.itemId,
-                threadId: params.threadId,
-                turnId: params.turnId,
-                timestamp: this.now(),
-            },
-        ];
+        return [this.turnDiffEvent(params, { text: next, itemId: params.itemId })];
     }
     handleReasoningDelta(params) {
         // summaryTextDelta 流的是摘要文本；与 content 段落分开累积，避免段落交错。
         const entry = this.reasoningEntry(params.itemId);
         entry.summary += params.delta;
         return [
-            {
-                type: 'turn_diff',
+            this.turnDiffEvent(params, {
                 reasoning: this.reasoningSnapshotFor(entry),
                 itemId: params.itemId,
-                threadId: params.threadId,
-                turnId: params.turnId,
-                timestamp: this.now(),
-            },
+            }),
         ];
     }
     handleReasoningPartAdded() {
@@ -310,15 +287,11 @@ export class CodexAppServerTranslator {
             // 权威文件变更（含聚合后的 diff）；以快照语义替换本 item 的变更列表。
             this.fileChangeItems.set(item.id, item.changes);
             return [
-                {
-                    type: 'turn_diff',
+                this.turnDiffEvent(params, {
                     fileChanges: normalizeFileChanges(item.changes),
                     itemId: item.id,
                     complete: true,
-                    threadId: params.threadId,
-                    turnId: params.turnId,
-                    timestamp: this.now(),
-                },
+                }),
             ];
         }
         if (item.type === 'reasoning') {
@@ -330,15 +303,11 @@ export class CodexAppServerTranslator {
                 entry.content = new Map(content.map((c, i) => [i, c]));
                 entry.summary = summary.join('\n');
                 return [
-                    {
-                        type: 'turn_diff',
+                    this.turnDiffEvent(params, {
                         reasoning: this.reasoningSnapshotFor(entry),
                         itemId: item.id,
                         complete: true,
-                        threadId: params.threadId,
-                        turnId: params.turnId,
-                        timestamp: this.now(),
-                    },
+                    }),
                 ];
             }
         }
@@ -358,17 +327,13 @@ export class CodexAppServerTranslator {
             const meta = this.toolItemMeta.get(item.id);
             this.toolItemMeta.delete(item.id);
             return [
-                {
-                    type: 'turn_diff',
+                this.turnDiffEvent(params, {
                     toolOutput: authoritative,
                     ...meta,
                     itemId: item.id,
                     complete: true,
                     toolStatus: commandExecutionStatusToToolStatus(item.status),
-                    threadId: params.threadId,
-                    turnId: params.turnId,
-                    timestamp: this.now(),
-                },
+                }),
             ];
         }
         if (item.type === 'agentMessage') {
@@ -395,15 +360,11 @@ export class CodexAppServerTranslator {
                     ];
                 }
                 return [
-                    {
-                        type: 'turn_diff',
+                    this.turnDiffEvent(params, {
                         text: finalText,
                         itemId: item.id,
                         complete: true,
-                        threadId: params.threadId,
-                        turnId: params.turnId,
-                        timestamp: this.now(),
-                    },
+                    }),
                 ];
             }
         }
@@ -412,15 +373,11 @@ export class CodexAppServerTranslator {
             if (text) {
                 this.planByItem.set(item.id, text);
                 return [
-                    {
-                        type: 'turn_diff',
+                    this.turnDiffEvent(params, {
                         plan: text,
                         itemId: item.id,
                         complete: true,
-                        threadId: params.threadId,
-                        turnId: params.turnId,
-                        timestamp: this.now(),
-                    },
+                    }),
                 ];
             }
         }
@@ -432,16 +389,12 @@ export class CodexAppServerTranslator {
             this.toolItemMeta.delete(item.id);
             this.startedToolItems.delete(item.id);
             return [
-                {
-                    type: 'turn_diff',
+                this.turnDiffEvent(params, {
                     toolOutput: this.toolOutputByItem.get(item.id) ?? '',
                     ...meta,
                     itemId: item.id,
                     complete: true,
-                    threadId: params.threadId,
-                    turnId: params.turnId,
-                    timestamp: this.now(),
-                },
+                }),
             ];
         }
         return [];
@@ -452,14 +405,10 @@ export class CodexAppServerTranslator {
         const prev = entry.content.get(index) ?? '';
         entry.content.set(index, prev + params.delta);
         return [
-            {
-                type: 'turn_diff',
+            this.turnDiffEvent(params, {
                 reasoning: this.reasoningSnapshotFor(entry),
                 itemId: params.itemId,
-                threadId: params.threadId,
-                turnId: params.turnId,
-                timestamp: this.now(),
-            },
+            }),
         ];
     }
     handleCommandOutputDelta(params) {
@@ -467,15 +416,11 @@ export class CodexAppServerTranslator {
         const next = prev + params.delta;
         this.toolOutputByItem.set(params.itemId, next);
         return [
-            {
-                type: 'turn_diff',
+            this.turnDiffEvent(params, {
                 toolOutput: next,
                 ...this.toolItemMeta.get(params.itemId),
                 itemId: params.itemId,
-                threadId: params.threadId,
-                turnId: params.turnId,
-                timestamp: this.now(),
-            },
+            }),
         ];
     }
     handlePlanUpdated(params) {
@@ -485,14 +430,10 @@ export class CodexAppServerTranslator {
         const next = prev + params.delta;
         this.planByItem.set(params.itemId, next);
         return [
-            {
-                type: 'turn_diff',
+            this.turnDiffEvent(params, {
                 plan: next,
                 itemId: params.itemId,
-                threadId: params.threadId,
-                turnId: params.turnId,
-                timestamp: this.now(),
-            },
+            }),
         ];
     }
     handleTokenUsageUpdated(params) {
@@ -705,112 +646,78 @@ export class CodexAppServerTranslator {
                             view: { ...pending.view, fileChanges },
                             timestamp: new Date().toISOString(),
                         },
-                        {
-                            type: 'turn_diff',
+                        this.turnDiffEvent(params, {
                             fileChanges,
                             itemId: item.id,
-                            threadId: params.threadId,
-                            turnId: params.turnId,
-                            timestamp: this.now(),
-                        },
+                        }),
                     ];
                 }
             }
             return [
-                {
-                    type: 'turn_diff',
+                this.turnDiffEvent(params, {
                     fileChanges: normalizeFileChanges(item.changes),
                     itemId: item.id,
-                    threadId: params.threadId,
-                    turnId: params.turnId,
-                    timestamp: this.now(),
-                },
+                }),
             ];
         }
         if (item.type === 'commandExecution') {
             // item/started 锚定工具块位置（真实时序）：命令开始时即创建工具块，
             // 而不是等到首个输出 delta——否则后续 reasoning item 会插到 command 之前。
-            this.startedToolItems.add(item.id);
-            // 信息保真 记录工具身份，随 turn_diff 透传（run-state 首见时写入）。
-            this.toolItemMeta.set(item.id, {
+            return this.beginToolItem(item.id, params, {
                 toolName: 'Bash',
                 toolInput: { command: item.command, ...(item.cwd ? { cwd: item.cwd } : {}) },
                 toolHint: 'shell',
             });
-            return [
-                {
-                    type: 'turn_diff',
-                    toolOutput: '',
-                    ...this.toolItemMeta.get(item.id),
-                    itemId: item.id,
-                    threadId: params.threadId,
-                    turnId: params.turnId,
-                    timestamp: this.now(),
-                },
-            ];
         }
         if (item.type === 'webSearch') {
-            this.startedToolItems.add(item.id);
-            this.toolItemMeta.set(item.id, {
+            return this.beginToolItem(item.id, params, {
                 toolName: 'WebSearch',
                 toolInput: { query: item.query },
                 toolHint: 'web',
             });
-            return [
-                {
-                    type: 'turn_diff',
-                    toolOutput: '',
-                    ...this.toolItemMeta.get(item.id),
-                    itemId: item.id,
-                    threadId: params.threadId,
-                    turnId: params.turnId,
-                    timestamp: this.now(),
-                },
-            ];
         }
         if (item.type === 'mcpToolCall') {
             // ThreadItem union 含 catch-all 成员，判别收窄会与泛型成员并集；
             // 显式断言到具体 interface（字段名已经 v2 schema 确认）。
             const mcpItem = item;
-            this.startedToolItems.add(item.id);
-            this.toolItemMeta.set(item.id, {
+            return this.beginToolItem(item.id, params, {
                 toolName: `mcp__${mcpItem.server}__${mcpItem.tool}`,
                 toolInput: mcpItem.arguments ?? {},
                 toolHint: 'search',
             });
-            return [
-                {
-                    type: 'turn_diff',
-                    toolOutput: '',
-                    ...this.toolItemMeta.get(item.id),
-                    itemId: item.id,
-                    threadId: params.threadId,
-                    turnId: params.turnId,
-                    timestamp: this.now(),
-                },
-            ];
         }
         if (item.type === 'dynamicToolCall') {
             const dynItem = item;
-            this.startedToolItems.add(item.id);
-            this.toolItemMeta.set(item.id, {
+            return this.beginToolItem(item.id, params, {
                 toolName: dynItem.tool,
                 toolInput: dynItem.arguments ?? {},
             });
-            return [
-                {
-                    type: 'turn_diff',
-                    toolOutput: '',
-                    ...this.toolItemMeta.get(item.id),
-                    itemId: item.id,
-                    threadId: params.threadId,
-                    turnId: params.turnId,
-                    timestamp: this.now(),
-                },
-            ];
         }
         return [];
     }
+    /**
+     * turn_diff 的统一信封：`type` + threadId/turnId/timestamp 三个公共字段在此
+     * 一次装配（十余个构造点原本各抄一遍，还得挂 `as TurnDiffEvent`）。
+     */
+    turnDiffEvent(ids, fields) {
+        return {
+            type: 'turn_diff',
+            ...fields,
+            threadId: ids.threadId,
+            turnId: ids.turnId,
+            timestamp: this.now(),
+        };
+    }
+    /**
+     * 工具型 item 的 started 处理（commandExecution / webSearch / mcpToolCall /
+     * dynamicToolCall 四个分支同形）：登记「已开始」锚点 + 记录工具身份 meta，
+     * 再发一帧空的 turn_diff 把工具块按真实时序插进卡片。
+     */
+    beginToolItem(itemId, params, meta) {
+        this.startedToolItems.add(itemId);
+        this.toolItemMeta.set(itemId, meta);
+        return [this.turnDiffEvent(params, { toolOutput: '', ...meta, itemId })];
+    }
     handlePermissionsApproval(requestId, params) {
         const permItems = this.buildPermissionItems(params.permissions);
         const view = {

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

@@ -18,7 +18,9 @@
  *     Bash notifications and serves terminal/* reverse RPC; opencode is plain
  *   - getStatusInfo / updateApprovalMode: agent-specific extras & mode vocab
  */
-import type { AgentEvent, AgentKind, AgentSessionReader, SpawnOptions } from '../../types.js';
+import type { AgentKind } from '../../../agent-kinds.js';
+import type { AgentSessionReader } from '../../../session-contract.js';
+import type { AgentEvent, SpawnOptions } from '../../types.js';
 import { ConnectionManager } from '../jsonrpc/connection-manager.js';
 import { JsonRpcClient } from '../jsonrpc/client.js';
 import { type SessionNewResult, type SessionResumeResult, type SessionPromptResult, type RequestPermissionParams } from './protocol-types.js';
@@ -71,6 +73,22 @@ export declare abstract class BaseAcpRunner<TTranslator extends BaseAcpTranslato
      */
     protected abstract onCompactPromptFired(promptPromise: Promise<SessionPromptResult>, translator: TTranslator, sessionId: string, opts: SpawnOptions, baselineTotalCount: number): void;
     private withSessionSetupRetry;
+    /**
+     * 建立会话（session/new|resume），重试耗尽后丢弃该 cwd 缓存的连接。
+     *
+     * 「服务端未就绪」类错误（isRetryableSessionSetupError）说明这个 agent server
+     * 自身半死：opencode v2 的 location 在每轮拉起的 `opencode acp` 子进程里 boot，
+     * boot 期间后台服务不可用会让它长期停在未激活，后续轮次复用同一连接只会重复
+     * 失败——用户重启 opencode service 也治不好，因为连接缓存在本进程里
+     * （2026-10-30 现场：4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
+     * 后下一轮重新 spawn，拿到的是新进程的新状态。
+     *
+     * 只对声明为可重试的错误生效：kimi 等沿用默认 `isRetryableSessionSetupError`
+     * = false，行为不变（session id 不存在之类的确定性失败不踢连接）。
+     */
+    private setupSessionWithRetry;
+    /** Dispose the cached connection for `cwd`; never mask the setup error. */
+    private discardConnection;
     protected currentSessionId(): string | null;
     protected cancelCurrentTurn(): Promise<void>;
     protected clearTurnState(): void;

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

@@ -58,6 +58,40 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
             }
         }
     }
+    /**
+     * 建立会话（session/new|resume），重试耗尽后丢弃该 cwd 缓存的连接。
+     *
+     * 「服务端未就绪」类错误（isRetryableSessionSetupError）说明这个 agent server
+     * 自身半死：opencode v2 的 location 在每轮拉起的 `opencode acp` 子进程里 boot，
+     * boot 期间后台服务不可用会让它长期停在未激活，后续轮次复用同一连接只会重复
+     * 失败——用户重启 opencode service 也治不好，因为连接缓存在本进程里
+     * （2026-10-30 现场：4 次重试全失败，重启服务与 lark-remote 都无效）。丢掉连接
+     * 后下一轮重新 spawn，拿到的是新进程的新状态。
+     *
+     * 只对声明为可重试的错误生效：kimi 等沿用默认 `isRetryableSessionSetupError`
+     * = false，行为不变（session id 不存在之类的确定性失败不踢连接）。
+     */
+    async setupSessionWithRetry(cwd, fn) {
+        try {
+            return await this.withSessionSetupRetry(fn);
+        }
+        catch (err) {
+            if (this.isRetryableSessionSetupError(err)) {
+                await this.discardConnection(cwd);
+            }
+            throw err;
+        }
+    }
+    /** Dispose the cached connection for `cwd`; never mask the setup error. */
+    async discardConnection(cwd) {
+        try {
+            await this.connectionManager.release(cwd);
+            getLogger().warn(`[${this.logTag}] dropped cached connection after session setup failure cwd=${cwd}`);
+        }
+        catch (err) {
+            getLogger().warn(`[${this.logTag}] failed to drop cached connection cwd=${cwd}: ${err.message}`);
+        }
+    }
     currentSessionId() {
         return this.activeSessionId;
     }
@@ -203,13 +237,13 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
                 sessionId: opts.sessionId,
                 cwd: opts.cwd,
             };
-            const resumeResult = await this.withSessionSetupRetry(() => client.request('session/resume', resumeParams));
+            const resumeResult = await this.setupSessionWithRetry(opts.cwd, () => client.request('session/resume', resumeParams));
             this.onSessionEstablished(resumeResult);
             sessionId = opts.sessionId;
         }
         else {
             const newParams = { cwd: opts.cwd, mcpServers: [] };
-            const newResult = await this.withSessionSetupRetry(() => client.request('session/new', newParams));
+            const newResult = await this.setupSessionWithRetry(opts.cwd, () => client.request('session/new', newParams));
             this.onSessionEstablished(newResult);
             sessionId = newResult.sessionId;
         }
@@ -286,7 +320,7 @@ export class BaseAcpRunner extends ConnectionBasedRunner {
             // memory. On a reused connection the session is already loaded —
             // resume is idempotent and harmless.
             const resumeParams = { sessionId, cwd: opts.cwd };
-            const resumeResult = await this.withSessionSetupRetry(() => client.request('session/resume', resumeParams));
+            const resumeResult = await this.setupSessionWithRetry(opts.cwd, () => client.request('session/resume', resumeParams));
             this.onSessionEstablished(resumeResult);
             const translator = this.createTranslator();
             translator.setOperationKind('compact');

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

@@ -14,7 +14,9 @@
  * handleNotification/handleServerRequest, respondApproval, pendingApprovals,
  * updateApprovalMode, getStatusInfo) and provide the small abstract hooks below.
  */
-import type { AgentKind, AgentSessionReader, AgentEvent, AgentRunner, AgentStatusInfo, SpawnOptions } from '../types.js';
+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';
 export declare abstract class ConnectionBasedRunner<TClient, TEvent = AgentEvent> implements AgentRunner {
     readonly kind: AgentKind;

package/dist/runner/common/jsonrpc/transport.js

@@ -12,6 +12,10 @@ import { binaryName } from '../../../platform/identity.js';
 import { createTerminator } from '../../../platform/terminator.js';
 import { agentStopperRegistry, } from '../../../platform/agent-stopper.js';
 import { getLogger } from '../../../logger/index.js';
+/** 日志用的错误摘要（onClose 的 reason 仍是稳定分类码）。 */
+function describeErr(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 /** Max bytes for a single line before we disconnect (10MB). */
 const MAX_LINE_BYTES = 10 * 1024 * 1024;
 /** Max bytes retained from stderr for diagnostics (64KB). */
@@ -205,8 +209,8 @@ export class JsonlRpcTransport {
             this.writeQueue.push(Buffer.from(JSON.stringify(msg) + '\n', 'utf8'));
             this.flush();
         }
-        catch {
-            this.handleClose('epipe');
+        catch (err) {
+            this.handleClose('epipe', describeErr(err));
         }
     }
     /** Send queued lines to stdin, pausing on backpressure until drain. */
@@ -229,7 +233,7 @@ export class JsonlRpcTransport {
             try {
                 const ok = stdin.write(chunk, (err) => {
                     if (err) {
-                        this.handleClose('epipe');
+                        this.handleClose('epipe', describeErr(err));
                     }
                 });
                 if (!ok) {
@@ -240,8 +244,8 @@ export class JsonlRpcTransport {
                     next();
                 }
             }
-            catch {
-                this.handleClose('epipe');
+            catch (err) {
+                this.handleClose('epipe', describeErr(err));
             }
         };
         next();
@@ -288,10 +292,11 @@ export class JsonlRpcTransport {
         this.registration = null;
         this.stoppers.unregister(this.agent, reg.pid, reg.stopper);
     }
-    handleClose(reason) {
+    handleClose(reason, detail) {
         if (this._closed)
             return;
         this._closed = true;
+        const dropped = this.writeQueue.length;
         this.writeQueue = [];
         // Remove the exit listener to avoid double-firing
         if (this.proc) {
@@ -319,7 +324,12 @@ export class JsonlRpcTransport {
         // 统一关闭出口：EPIPE/超长行/进程 error 都必须通知上层（connection-manager
         // 靠 onClose 删除 slot、client 靠它 failPending），否则 slot 悬挂死连接。
         this.events?.onClose(reason);
-        getLogger().info(`[jsonrpc-transport] closed: ${reason}`);
+        // reason 是给上层的稳定分类码；原始 err 与被丢弃的排队条数只进日志，
+        // 否则「stdin 写失败」到底写了什么、丢了什么都查不出来。
+        const suffix = [detail, dropped > 0 ? `${dropped} queued message(s) dropped` : undefined]
+            .filter(Boolean)
+            .join('; ');
+        getLogger().info(`[jsonrpc-transport] closed: ${reason}${suffix ? ` (${suffix})` : ''}`);
     }
 }
 //# sourceMappingURL=transport.js.map

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

@@ -19,7 +19,7 @@
  * `sessionEvents()` adds per-session filtering, reconnect + follow-snapshot
  * replay, and seq-based dedup.
  */
-import type { DshApprovalStreamItem, DshCommandResult, DshModelCatalogValue, DshModelSelection, DshOpenTurnState, DshPermissionCatalogValue, DshJobView, DshPresetListValue, DshProjectionItem, DshProjectionSnapshot, DshQuestion, DshRemoteEventOutcome, DshSessionPageValue, DshStreamItem, DshTokenUsage } from './types.js';
+import type { DshApprovalStreamItem, DshCommandResult, DshModelCatalogValue, DshModelSelection, DshOpenTurnState, DshPermissionCatalogValue, DshJobView, DshPresetListValue, DshProjectionItem, DshProjectionSnapshot, DshQuestion, DshRemoteEventOutcome, DshSessionPageValue, DshStreamItem, DshTokenUsage } from '../../dsh/types.js';
 import type { GoalView } from '../types.js';
 export { DshError } from './errors.js';
 interface WebSocketMessageEvent {
@@ -72,9 +72,6 @@ export interface DshClientOptions {
      */
     requestTimeoutMs?: number;
 }
-/** Extract the `token` query parameter from a pasted `dsh web` URL. */
-export declare function extractDshToken(raw: string | undefined): string;
-export declare function dshArgs(method: string, payload: unknown): Record<string, unknown>;
 export declare class DshClient {
     readonly baseUrl: string;
     private readonly token;