lark-remote 0.5.13 → 0.5.14

package/dist/runner/dsh/mux-stream.js

@@ -1,5 +1,23 @@
 import { getLogger } from '../../logger/index.js';
 import { DshError } from './errors.js';
+/**
+ * onerror 的事件对象在 ws 实现之间形态不一（{message} / {error} / {type}）。
+ * 尽力取出可读描述；取不到就不追加，别拿 '[object Object]' 充数。
+ */
+function describeSocketError(event) {
+    if (!event || typeof event !== 'object')
+        return undefined;
+    const e = event;
+    if (typeof e.message === 'string' && e.message)
+        return e.message;
+    if (e.error instanceof Error && e.error.message)
+        return e.error.message;
+    if (typeof e.error === 'string' && e.error)
+        return e.error;
+    if (typeof e.type === 'string' && e.type)
+        return e.type;
+    return undefined;
+}
 export async function* openMuxStream(opts) {
     const cookie = await opts.authCookie();
     const socket = opts.webSocketFactory(`${opts.baseUrl.replace(/^http/, 'ws')}/api/remote.mux`, cookie ? { headers: { cookie } } : undefined);
@@ -87,10 +105,11 @@ export async function* openMuxStream(opts) {
             settle(undefined);
         }
     };
-    socket.onerror = () => {
+    socket.onerror = (event) => {
         if (ended)
             return;
-        failure = new DshError('transport', 'DSH remote mux WebSocket error');
+        const detail = describeSocketError(event);
+        failure = new DshError('transport', `DSH remote mux WebSocket error${detail ? `: ${detail}` : ''}`);
         ended = true;
         settle(undefined);
     };

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

@@ -17,7 +17,8 @@
  * approval on the same card. If `$events` is unavailable, the runner falls
  * back to the Web UI prompt.
  */
-import type { AgentEvent, AgentSessionReader, AgentStatusInfo, SpawnOptions, StopOutcome } from '../types.js';
+import type { AgentSessionReader } from '../../session-contract.js';
+import type { AgentEvent, AgentStatusInfo, SpawnOptions, StopOutcome } from '../types.js';
 import type { AgentRunner } from '../types.js';
 import { DshClient, type WebSocketFactory } from './client.js';
 import type { DshDaemon } from './daemon.js';
@@ -134,6 +135,25 @@ export declare class DshRunner implements AgentRunner {
      * the live catalog for that provider's default (or first) model.
      */
     private resolveModelSelection;
+    /**
+     * 新建 DSH session 并取回 sessionId；run 在挂起期间被 stop 时返回 undefined。
+     *
+     * 红线：不把 run 的 abort signal 直接交给 create —— abort 掉请求会丢掉刚创建的
+     * sessionId，服务端若已完成创建就留下一个无法 cancel 的孤儿 session。改为 abort
+     * 时立即放行 run（队列不被挂起），create 后台落定后再补 cancel。
+     */
+    private acquireSessionId;
+    /**
+     * 把本轮消息交给 DSH 的排队收件箱，返回本轮的身份与起始水位。
+     *
+     * 三条不变量（都关系到「迟到/抢先的 stop 能否被正确撤销」）：
+     * - 起始水位取 prompt **之前**的 latestEventSeq：session/page 返回整个会话，
+     *   从 0 开始会把首轮已完成 turn 在每次后续消息时重放一遍。
+     * - 身份（requestId）在请求发出**之前**就公布：stop 可能落在 session/prompt 的
+     *   在途窗口里，那时它必须知道宿主受理后该撤销哪个收件项。
+     * - `promptAdmitted` 只在宿主接受后置真：撤销路径据此区分「还没进去」与「已排队」。
+     */
+    private submitPrompt;
     run(message: string, opts: SpawnOptions): AsyncGenerator<AgentEvent>;
     /**
      * Consume one turn from both transports. `session/follow` owns transcript

package/dist/runner/dsh/runner.js

@@ -178,6 +178,20 @@ function parseToolArguments(raw) {
         return {};
     }
 }
+/**
+ * 用户 stop 的终态结果（run() 的 5 个中止点各 yield 同一形状）。
+ *
+ * 必须 yield result 而不是裸 return：调用方靠 result 收尾 run 卡，否则卡片
+ * 停留在「运行中」（见 run() 内 startup abort 注释）。
+ */
+function interruptedResult(sessionId) {
+    return {
+        type: 'result',
+        subtype: 'interrupted',
+        session_id: sessionId,
+        errorMessage: 'run stopped',
+    };
+}
 export class DshRunner {
     kind = 'dsh';
     /**
@@ -323,6 +337,57 @@ export class DshRunner {
         }
         return { provider, model, ...(reasoningEffort ? { reasoningEffort } : {}) };
     }
+    /**
+     * 新建 DSH session 并取回 sessionId；run 在挂起期间被 stop 时返回 undefined。
+     *
+     * 红线：不把 run 的 abort signal 直接交给 create —— abort 掉请求会丢掉刚创建的
+     * sessionId，服务端若已完成创建就留下一个无法 cancel 的孤儿 session。改为 abort
+     * 时立即放行 run（队列不被挂起），create 后台落定后再补 cancel。
+     */
+    async acquireSessionId(cwd, signal) {
+        const createPromise = this.client.createSession({
+            cwd,
+            ...(this.agentPreset ? { agentPreset: this.agentPreset } : {}),
+        });
+        const created = await this.awaitOrAbort(createPromise, signal);
+        if (created)
+            return created.sessionId;
+        void createPromise.then((c) => this.cancelSessionQuietly(c.sessionId), () => {
+            /* create failed after stop — nothing to cancel */
+        });
+        getLogger().info('[dsh] run stopped during session/create; will cancel if it settles');
+        return undefined;
+    }
+    /**
+     * 把本轮消息交给 DSH 的排队收件箱，返回本轮的身份与起始水位。
+     *
+     * 三条不变量（都关系到「迟到/抢先的 stop 能否被正确撤销」）：
+     * - 起始水位取 prompt **之前**的 latestEventSeq：session/page 返回整个会话，
+     *   从 0 开始会把首轮已完成 turn 在每次后续消息时重放一遍。
+     * - 身份（requestId）在请求发出**之前**就公布：stop 可能落在 session/prompt 的
+     *   在途窗口里，那时它必须知道宿主受理后该撤销哪个收件项。
+     * - `promptAdmitted` 只在宿主接受后置真：撤销路径据此区分「还没进去」与「已排队」。
+     */
+    async submitPrompt(sessionId, cwd, message, signal) {
+        const prePromptSeq = await this.client.latestEventSeq(sessionId, { signal });
+        const promptRequestId = newPromptRequestId();
+        this.activePromptRequestId = promptRequestId;
+        this.promptAdmitted = false;
+        this.inflight?.record({
+            sessionId,
+            promptRequestId,
+            baseUrl: this.client.baseUrl,
+            cwd,
+        });
+        await this.client.unary('session/prompt', {
+            requestId: promptRequestId,
+            sessionId,
+            mode: 'queue',
+            content: [{ type: 'text', text: message }],
+        }, { signal });
+        this.promptAdmitted = true;
+        return { prePromptSeq, promptRequestId };
+    }
     async *run(message, opts) {
         if (this.running) {
             throw new Error('DshRunner is already running');
@@ -346,29 +411,13 @@ export class DshRunner {
             // session/create 必须包进同一 try/finally，否则创建失败（服务端不可达/报错）
             // 会在进入旧 try 之前抛异常，finally 不执行 → running 恒 true、activeAbort 残留。
             if (!sessionId) {
-                const createPromise = this.client.createSession({
-                    cwd: opts.cwd,
-                    ...(this.agentPreset ? { agentPreset: this.agentPreset } : {}),
-                });
-                // 不把 run 的 abort signal 直接交给 create：abort 掉请求会丢掉刚创建
-                // 的 sessionId，服务端若已完成创建就留下一个无法 cancel 的孤儿 session。
-                // 改为 abort 时立即放行 run（队列不被挂起），create 后台落定后再补 cancel。
-                const created = await this.awaitOrAbort(createPromise, abort.signal);
-                if (!created) {
-                    void createPromise.then((c) => this.cancelSessionQuietly(c.sessionId), () => {
-                        /* create failed after stop — nothing to cancel */
-                    });
-                    getLogger().info('[dsh] run stopped during session/create; will cancel if it settles');
+                const created = await this.acquireSessionId(opts.cwd, abort.signal);
+                if (created === undefined) {
                     terminalEmitted = true;
-                    yield {
-                        type: 'result',
-                        subtype: 'interrupted',
-                        session_id: '',
-                        errorMessage: 'run stopped',
-                    };
+                    yield interruptedResult('');
                     return;
                 }
-                sessionId = created.sessionId;
+                sessionId = created;
             }
             this.activeSessionId = sessionId;
             // Startup abort：createSession 挂起期间 stop() 已 abort（此时 sessionId 尚
@@ -380,12 +429,7 @@ export class DshRunner {
                 await this.cancelSessionQuietly(sessionId);
                 getLogger().info(`[dsh] run aborted during startup, cancelled session ${sessionId}`);
                 terminalEmitted = true;
-                yield {
-                    type: 'result',
-                    subtype: 'interrupted',
-                    session_id: sessionId,
-                    errorMessage: 'run stopped',
-                };
+                yield interruptedResult(sessionId);
                 return;
             }
             // provider/模型/推理强度对齐：会话首次 run 时 selectModel 一次
@@ -403,12 +447,7 @@ export class DshRunner {
                     if (abort.signal.aborted) {
                         getLogger().info(`[dsh] run stopped during selectModel session=${sessionId}`);
                         terminalEmitted = true;
-                        yield {
-                            type: 'result',
-                            subtype: 'interrupted',
-                            session_id: sessionId,
-                            errorMessage: 'run stopped',
-                        };
+                        yield interruptedResult(sessionId);
                         return;
                     }
                     if (this.configuredProvider) {
@@ -425,12 +464,7 @@ export class DshRunner {
             // Abort 可能在上述 unary 完成与检查之间到达：不进入 prompt/turn。
             if (abort.signal.aborted) {
                 terminalEmitted = true;
-                yield {
-                    type: 'result',
-                    subtype: 'interrupted',
-                    session_id: sessionId,
-                    errorMessage: 'run stopped',
-                };
+                yield interruptedResult(sessionId);
                 return;
             }
             yield {
@@ -453,48 +487,17 @@ export class DshRunner {
             if (seedGoal.known && seedGoal.goal)
                 yield goalStateEvent(seedGoal.goal, true);
             try {
-                // Snapshot the pre-prompt high-water mark before mutating the session.
-                // DSH session/page returns the whole session, so starting from seq 0
-                // would replay the first completed turn on every follow-up prompt.
-                const prePromptSeq = await this.client.latestEventSeq(sessionId, {
-                    signal: abort.signal,
-                });
-                // Keep the prompt identity: DSH echoes it into the durable user/message
-                // source.rpcId, which is how runTurn tells this run's turn from a turn
-                // it is merely queued behind.
-                promptRequestId = newPromptRequestId();
-                // Publish the identity before the request leaves: a stop that arrives
-                // while `session/prompt` is in flight must still know which inbox item
-                // (if any) to withdraw once the host admits it.
-                this.activePromptRequestId = promptRequestId;
-                this.promptAdmitted = false;
-                this.inflight?.record({
-                    sessionId,
-                    promptRequestId,
-                    baseUrl: this.client.baseUrl,
-                    cwd: opts.cwd,
-                });
-                await this.client.unary('session/prompt', {
-                    requestId: promptRequestId,
-                    sessionId,
-                    mode: 'queue',
-                    content: [{ type: 'text', text: message }],
-                }, { signal: abort.signal });
-                this.promptAdmitted = true;
+                const submitted = await this.submitPrompt(sessionId, opts.cwd, message, abort.signal);
+                promptRequestId = submitted.promptRequestId;
                 if (abort.signal.aborted) {
                     // stop() 在 prompt 已受理后到达：cancel 由 stop() 发出，这里直接收尾，
                     // 不再打开 mux（否则会看到 cancel 产生的 turn/end 事件）。
                     terminalEmitted = true;
-                    yield {
-                        type: 'result',
-                        subtype: 'interrupted',
-                        session_id: sessionId,
-                        errorMessage: 'run stopped',
-                    };
+                    yield interruptedResult(sessionId);
                     return;
                 }
                 try {
-                    for await (const ev of this.runTurn(sessionId, opts.cwd, prePromptSeq, promptRequestId, abort, { last: lastGoal })) {
+                    for await (const ev of this.runTurn(sessionId, opts.cwd, submitted.prePromptSeq, promptRequestId, abort, { last: lastGoal })) {
                         yield ev;
                         if (ev.type === 'result') {
                             terminalEmitted = true;

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

@@ -24,7 +24,7 @@
  *     cache_creation_tokens (cacheWrite = cache creation) + total_tokens sum.
  */
 import type { AgentEvent, ResultEvent } from '../types.js';
-import type { DshAssistantStreamFrame, DshSessionEvent, DshTokenUsage } from './types.js';
+import type { DshAssistantStreamFrame, DshSessionEvent, DshTokenUsage } from '../../dsh/types.js';
 export declare class DshTranslator {
     /** 本 turn 累计用量：DSH 每次模型调用（step）一条 usage，工具往返 = 多条。 */
     private turnUsage;

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, SessionSummary, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, FinalAnswerEvent, NoticeEvent, SessionInfoEvent, ToolHint, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, GoalView, GoalStateEvent, } from './types.js';
+export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentRunner, TurnStartedEvent, TurnDiffEvent, FinalAnswerEvent, NoticeEvent, SessionInfoEvent, ToolHint, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, GoalView, GoalStateEvent, } 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

@@ -17,7 +17,9 @@
  * - AskUserQuestion flows through elicitation forms + a request_permission
  *   question bridge (buildQuestionResponse)
  */
-import type { AgentKind, AgentSessionReader, AgentStatusInfo, SpawnOptions } from '../../types.js';
+import type { AgentKind } from '../../../agent-kinds.js';
+import type { AgentSessionReader } from '../../../session-contract.js';
+import type { AgentStatusInfo, SpawnOptions } from '../../types.js';
 import { JsonRpcClient } from '../../common/jsonrpc/client.js';
 import { KimiAcpTranslator } from './translator.js';
 import { type SessionPromptResult } from '../../common/acp/protocol-types.js';
@@ -167,6 +169,25 @@ export declare class KimiAcpRunner extends BaseAcpRunner<KimiAcpTranslator> {
      * stdout(+stderr) 到缓冲，立即回 {terminalId}。
      */
     private handleTerminalCreate;
+    /**
+     * 走 shell seam：argv 逐 token 保留，只把「可执行文件在哪」收口——win32 上
+     * Git Bash 缺失时在这里抛 ShellUnavailableError，由 handleTerminalRequest 转成
+     * 明确的 Terminal request failed 回执，而不是一个语焉不详的 spawn ENOENT。
+     */
+    private spawnTerminalProcess;
+    /**
+     * 有界输出缓冲：每个流独立 decoder（多字节字符跨 chunk 拆分时由 decoder 保留
+     * 不完整序列，避免按 chunk 单独 toString 产生 U+FFFD 替换符）。
+     */
+    private attachTerminalOutputBuffer;
+    /**
+     * 退出/错误收尾管线：tool_result 必须先入队，再放行 `wait_for_exit`。
+     */
+    private wireTerminalExit;
+    /** Bash 面板的 tool_result 帧（输出全量 + 是否失败）。 */
+    private pushTerminalToolResult;
+    /** Bash 面板的 tool_use 帧（真实命令 + cwd，create 时立刻可见）。 */
+    private pushTerminalToolUse;
     /** terminal/output: 回累计全量输出 + truncated + 当前退出状态（可未退出）。 */
     private handleTerminalOutput;
     /** terminal/wait_for_exit: 未退出则等 exit promise 再回 {exitCode, signal}。 */

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

@@ -582,11 +582,55 @@ export class KimiAcpRunner extends BaseAcpRunner {
             : undefined;
         const cwd = params.cwd ?? this.activeCwd ?? undefined;
         const outputLimit = params.outputByteLimit ?? TERMINAL_DEFAULT_OUTPUT_LIMIT;
-        // 走 shell seam：argv 逐 token 保留，只把「可执行文件在哪」
-        // 收口——win32 上 Git Bash 缺失时在这里抛 ShellUnavailableError，由
-        // handleTerminalRequest 转成明确的 Terminal request failed 回执，而不是一个
-        // 语焉不详的 spawn ENOENT。
-        const proc = this.shell.spawnArgv(params.command, params.args ?? [], {
+        const proc = this.spawnTerminalProcess(params, cwd, env);
+        // spawn 失败（如 ENOENT）只发 'error' 不发 'exit'——一并 resolve，防止
+        // wait_for_exit 永久挂起（runner 层 ENOENT 兜底红线）。
+        // 用 resolveExit 承接，避免回调在 handle 初始化前引用它（TDZ）。
+        let resolveExit;
+        const exitPromise = new Promise((resolve) => {
+            resolveExit = resolve;
+        });
+        // 与 resolveExit 同款 TDZ 规避：tool_result 发射闭包在 terminalId 初始化
+        // 后赋值，exit/error 回调执行时经 emitResult 间接调用。
+        let emitTerminalResult = undefined;
+        const emitResult = () => {
+            emitTerminalResult?.();
+        };
+        const handle = {
+            proc,
+            output: '',
+            outputBytes: 0,
+            outputLimit,
+            truncated: false,
+            exitCode: null,
+            signal: null,
+            exitPromise,
+        };
+        this.attachTerminalOutputBuffer(proc, handle);
+        this.wireTerminalExit(proc, handle, emitResult, () => resolveExit?.());
+        const terminalId = `term-${++this.terminalSeq}`;
+        this.terminals.set(terminalId, handle);
+        // Bash 工具事件由本 runner 自产（kimi 通知已过滤）：create 即推 tool_use
+        // 带真实命令，让 run 卡立刻出现可识别的 Bash 面板。
+        const script = Array.isArray(params.args) && params.args.length > 1 ? params.args[1] : params.command;
+        let resultEmitted = false;
+        emitTerminalResult = () => {
+            if (resultEmitted)
+                return;
+            resultEmitted = true;
+            this.pushTerminalToolResult(terminalId, handle.output, handle.exitCode);
+        };
+        this.pushTerminalToolUse(terminalId, script, cwd);
+        getLogger().info(`[${this.logTag}] terminal created id=${terminalId} command=${params.command} args=${JSON.stringify(params.args ?? [])}`);
+        this.currentClient?.respond(id, { terminalId });
+    }
+    /**
+     * 走 shell seam：argv 逐 token 保留，只把「可执行文件在哪」收口——win32 上
+     * Git Bash 缺失时在这里抛 ShellUnavailableError，由 handleTerminalRequest 转成
+     * 明确的 Terminal request failed 回执，而不是一个语焉不详的 spawn ENOENT。
+     */
+    spawnTerminalProcess(params, cwd, env) {
+        return this.shell.spawnArgv(params.command, params.args ?? [], {
             cwd,
             options: {
                 // env 覆盖大小写不敏感合并（win32 PATH/Path 双键防护）
@@ -600,8 +644,12 @@ export class KimiAcpRunner extends BaseAcpRunner {
                 windowsHide: true,
             },
         });
-        // 每个流独立 decoder：多字节字符跨 chunk 拆分时由 decoder 保留不完整
-        // 序列，避免按 chunk 单独 toString 产生 U+FFFD 替换符。
+    }
+    /**
+     * 有界输出缓冲：每个流独立 decoder（多字节字符跨 chunk 拆分时由 decoder 保留
+     * 不完整序列，避免按 chunk 单独 toString 产生 U+FFFD 替换符）。
+     */
+    attachTerminalOutputBuffer(proc, handle) {
         const stdoutDecoder = new StringDecoder('utf8');
         const stderrDecoder = new StringDecoder('utf8');
         const append = (chunk, decoder) => {
@@ -624,29 +672,11 @@ export class KimiAcpRunner extends BaseAcpRunner {
         };
         proc.stdout?.on('data', (chunk) => append(chunk, stdoutDecoder));
         proc.stderr?.on('data', (chunk) => append(chunk, stderrDecoder));
-        // spawn 失败（如 ENOENT）只发 'error' 不发 'exit'——一并 resolve，防止
-        // wait_for_exit 永久挂起（runner 层 ENOENT 兜底红线）。
-        // 用 resolveExit 承接，避免回调在 handle 初始化前引用它（TDZ）。
-        let resolveExit;
-        const exitPromise = new Promise((resolve) => {
-            resolveExit = resolve;
-        });
-        // 与 resolveExit 同款 TDZ 规避：tool_result 发射闭包在 terminalId 初始化
-        // 后赋值，exit/error 回调执行时经 emitResult 间接调用。
-        let emitTerminalResult = undefined;
-        const emitResult = () => {
-            emitTerminalResult?.();
-        };
-        const handle = {
-            proc,
-            output: '',
-            outputBytes: 0,
-            outputLimit,
-            truncated: false,
-            exitCode: null,
-            signal: null,
-            exitPromise,
-        };
+    }
+    /**
+     * 退出/错误收尾管线：tool_result 必须先入队，再放行 `wait_for_exit`。
+     */
+    wireTerminalExit(proc, handle, emitResult, resolveExit) {
         proc.once('exit', (code, signal) => {
             handle.exitCode = code;
             handle.signal = signal;
@@ -661,7 +691,7 @@ export class KimiAcpRunner extends BaseAcpRunner {
             const flushThenEmit = () => {
                 clearTimeout(emitTimer);
                 emitResult();
-                resolveExit?.();
+                resolveExit();
             };
             const emitTimer = setTimeout(flushThenEmit, 200);
             emitTimer.unref?.();
@@ -680,35 +710,30 @@ export class KimiAcpRunner extends BaseAcpRunner {
             }
             // 同 exit：tool_result 先入队，再放行 wait_for_exit。
             emitResult();
-            resolveExit?.();
+            resolveExit();
         });
-        const terminalId = `term-${++this.terminalSeq}`;
-        this.terminals.set(terminalId, handle);
-        // Bash 工具事件由本 runner 自产（kimi 通知已过滤）：create 即推 tool_use
-        // 带真实命令，让 run 卡立刻出现可识别的 Bash 面板。
-        const script = Array.isArray(params.args) && params.args.length > 1 ? params.args[1] : params.command;
-        let resultEmitted = false;
-        emitTerminalResult = () => {
-            if (resultEmitted)
-                return;
-            resultEmitted = true;
-            this.pushEvents([
-                {
-                    type: 'user',
-                    message: {
-                        content: [
-                            {
-                                type: 'tool_result',
-                                tool_use_id: terminalId,
-                                content: handle.output,
-                                is_error: handle.exitCode !== 0,
-                            },
-                        ],
-                    },
-                    timestamp: new Date().toISOString(),
+    }
+    /** Bash 面板的 tool_result 帧（输出全量 + 是否失败）。 */
+    pushTerminalToolResult(terminalId, output, exitCode) {
+        this.pushEvents([
+            {
+                type: 'user',
+                message: {
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: terminalId,
+                            content: output,
+                            is_error: exitCode !== 0,
+                        },
+                    ],
                 },
-            ]);
-        };
+                timestamp: new Date().toISOString(),
+            },
+        ]);
+    }
+    /** Bash 面板的 tool_use 帧（真实命令 + cwd，create 时立刻可见）。 */
+    pushTerminalToolUse(terminalId, script, cwd) {
         this.pushEvents([
             {
                 type: 'assistant',
@@ -725,8 +750,6 @@ export class KimiAcpRunner extends BaseAcpRunner {
                 timestamp: new Date().toISOString(),
             },
         ]);
-        getLogger().info(`[${this.logTag}] terminal created id=${terminalId} command=${params.command} args=${JSON.stringify(params.args ?? [])}`);
-        this.currentClient?.respond(id, { terminalId });
     }
     /** terminal/output: 回累计全量输出 + truncated + 当前退出状态（可未退出）。 */
     handleTerminalOutput(id, params) {

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

@@ -45,6 +45,12 @@ export declare class OpencodeLogErrorMonitor {
     private timer;
     private sessionId;
     private onError;
+    /**
+     * IO 故障留痕的节流状态：poll 每 2s 一次，同一条 EACCES 不得刷满日志，
+     * 但也不能像以前那样完全静默（监视器自己坏了没人知道）。
+     */
+    private lastIoError;
+    private lastIoErrorAt;
     constructor(opts: OpencodeLogErrorMonitorOptions);
     /**
      * Start monitoring the given session. Replaces any previous monitor state;
@@ -54,6 +60,11 @@ export declare class OpencodeLogErrorMonitor {
     /** Stop monitoring and clear all state. Safe to call multiple times. */
     stop(): void;
     private currentSize;
+    /**
+     * 监视器自身读不到日志时留痕（同一条最多每分钟一次）。ENOENT 通常是日志
+     * 还没生成，属正常空态，不记。
+     */
+    private noteIoError;
     private poll;
     /** Match a main-turn stream error line for the monitored session with a
      *  limit/quota reason; returns the extracted error text or null. */

package/dist/runner/opencode/acp/error-monitor.js

@@ -27,9 +27,12 @@
 import { closeSync, openSync, readSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { getLogger } from '../../../logger/index.js';
 /** Error text we fail fast on: quota/limit conditions opencode backs off on. */
 const LIMIT_ERROR_RE = /usage limit|quota|rate limit|rate_limit|too many requests|insufficient balance|free usage/i;
 const STREAM_ERROR_RE = /message="stream error"/;
+/** 同一条 IO 故障的日志节流窗口。 */
+const IO_ERROR_LOG_INTERVAL_MS = 60_000;
 const MAIN_TURN_RE = /small=false/;
 const ERROR_MESSAGE_RE = /error\.error="((?:[^"\\]|\\.)*)"/;
 /**
@@ -50,6 +53,12 @@ export class OpencodeLogErrorMonitor {
     timer = null;
     sessionId = null;
     onError = null;
+    /**
+     * IO 故障留痕的节流状态：poll 每 2s 一次，同一条 EACCES 不得刷满日志，
+     * 但也不能像以前那样完全静默（监视器自己坏了没人知道）。
+     */
+    lastIoError = '';
+    lastIoErrorAt = 0;
     constructor(opts) {
         this.logPath = opts.logPath;
         this.pollIntervalMs = opts.pollIntervalMs ?? 2000;
@@ -81,10 +90,28 @@ export class OpencodeLogErrorMonitor {
         try {
             return statSync(this.logPath).size;
         }
-        catch {
+        catch (err) {
+            this.noteIoError(err);
             return 0;
         }
     }
+    /**
+     * 监视器自身读不到日志时留痕（同一条最多每分钟一次）。ENOENT 通常是日志
+     * 还没生成，属正常空态，不记。
+     */
+    noteIoError(err) {
+        if (err.code === 'ENOENT')
+            return;
+        const message = err?.message ?? String(err);
+        const now = Date.now();
+        if (message === this.lastIoError && now - this.lastIoErrorAt < IO_ERROR_LOG_INTERVAL_MS) {
+            return;
+        }
+        this.lastIoError = message;
+        this.lastIoErrorAt = now;
+        getLogger().warn(`[opencode-error-monitor] cannot read ${this.logPath}: ${message}; ` +
+            'limit errors will fall back to the idle watchdog');
+    }
     poll() {
         if (this.sessionId === null || this.onError === null)
             return;
@@ -107,9 +134,11 @@ export class OpencodeLogErrorMonitor {
                     closeSync(fd);
                 }
             }
-            catch {
+            catch (err) {
+                this.noteIoError(err);
                 return;
             }
+            this.lastIoError = '';
             this.offset = size;
             this.pendingTail += chunk;
         }

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

@@ -19,7 +19,9 @@
  * - OpencodeLogErrorMonitor tails opencode's own log for LLM stream errors
  *   the ACP protocol never forwards
  */
-import type { AgentKind, AgentSessionReader, AgentStatusInfo } from '../../types.js';
+import type { AgentKind } from '../../../agent-kinds.js';
+import type { AgentSessionReader } from '../../../session-contract.js';
+import type { AgentStatusInfo } from '../../types.js';
 import { JsonRpcClient } from '../../common/jsonrpc/client.js';
 import { OpencodeAcpTranslator } from './translator.js';
 import { type SessionNewResult, type SessionResumeResult, type SessionPromptResult } from '../../common/acp/protocol-types.js';

package/dist/runner/pi/rpc/runner.d.ts

@@ -17,7 +17,8 @@
  *   - pi，极简风格，没有 Ask User question。
  *   - `prompt` ack ≠ turn completion; the turn ends on `agent_settled`.
  */
-import type { AgentSessionReader, AgentEvent, AgentStatusInfo, SpawnOptions } from '../../types.js';
+import type { AgentSessionReader } from '../../../session-contract.js';
+import type { AgentEvent, AgentStatusInfo, SpawnOptions } from '../../types.js';
 import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
 import { PiRpcClient } from './client.js';
 import { type PiRpcTranslatorEvent } from './translator.js';

package/dist/runner/probe.d.ts

@@ -17,7 +17,7 @@
  *   does PATH + X_OK on posix (same semantics) and PATH × PATHEXT on win32,
  *   with no child process at all.
  */
-import type { AgentKind } from './types.js';
+import type { AgentKind } from '../agent-kinds.js';
 /**
  * Probe a single agent, using cache when fresh.
  * Updates cache on completion.