lark-remote 0.5.9 → 0.5.12

package/dist/runner/common/jsonrpc/transport.d.ts

@@ -54,7 +54,8 @@ export declare class JsonlRpcTransport {
     get closed(): boolean;
     /**
      * Spawn the child process and start reading its stdout.
-     * Returns when the process closes (or immediately if spawn fails).
+     * Resolves once the process has spawned and listeners are wired — it does
+     * NOT wait for the process to close（关闭经 events.onClose 上报）。
      */
     start(events: TransportEvents): Promise<void>;
     /**

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

@@ -62,7 +62,8 @@ export class JsonlRpcTransport {
     }
     /**
      * Spawn the child process and start reading its stdout.
-     * Returns when the process closes (or immediately if spawn fails).
+     * Resolves once the process has spawned and listeners are wired — it does
+     * NOT wait for the process to close（关闭经 events.onClose 上报）。
      */
     async start(events) {
         this.events = events;
@@ -121,6 +122,11 @@ export class JsonlRpcTransport {
         const decoder = new StringDecoder('utf8');
         let remainder = '';
         proc.stdout?.on('data', (chunk) => {
+            // handleClose（超长行/EPIPE/进程 error）判死通道后不再分发：子进程被
+            // terminator 停止前还会吐几帧，把这些帧交给 onMessage 等于向已判死的
+            // run 注入事件。
+            if (this._closed)
+                return;
             remainder += decoder.write(chunk);
             const lines = remainder.split('\n');
             // Lines except the last (incomplete) one

package/dist/runner/dsh/approval.js

@@ -8,6 +8,7 @@
  * `callId`, with an order-independent pairing so either transport may arrive
  * first.
  */
+import { getLogger } from '../../logger/index.js';
 export class DshApprovalTracker {
     audits = new Map();
     waterfallByCallId = new Map();
@@ -22,8 +23,17 @@ export class DshApprovalTracker {
         this.audits.set(audit.approvalId, audit);
         if (audit.callId) {
             const waterfall = this.waterfallByCallId.get(audit.callId);
-            if (waterfall)
-                return this.bind(audit, waterfall);
+            if (waterfall) {
+                const boundTo = this.approvalIdByEventId.get(waterfall.eventId);
+                if (!boundTo || boundTo === audit.approvalId) {
+                    return this.bind(audit, waterfall);
+                }
+                // 该 waterfall 已被兜底配对绑给另一张卡（「无 callId 的 audit 先到 +
+                // waterfall 先到」的乱序组合，见 onWaterfall 的 toolName 启发式）：
+                // 不再二次绑定——两张卡指向同一可答 waterfall 时，先答的生效、
+                // 后答的服务端报错；单卡可答严格好于双卡可答。
+                getLogger().debug(`[dsh] waterfall already bound to ${boundTo}; skip rebind for ${audit.approvalId}`);
+            }
         }
         return undefined;
     }
@@ -86,8 +96,11 @@ export class DshApprovalTracker {
                     this.waterfallByCallId.delete(binding.waterfall.callId);
                 }
             }
-            this.resolveWaiters(approvalId, undefined);
         }
+        // 无论有无 binding 都要唤醒 waiter：approval/decided 落在「audit 已到、
+        // waterfall 未到」的窗口时，waitForBinding 的点击会白等满超时才收到
+        // 「审批通道尚未就绪」——而该审批实际上已被外部决策结束。
+        this.resolveWaiters(approvalId, undefined);
         return binding;
     }
     /** Mark a waterfall cancelled by the Host (another client answered it). */

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

@@ -256,7 +256,20 @@ export declare class DshClient {
      * Fallback probe: the newest durable event's type tells whether a turn is open.
      *
      * 只在拿不到 `running` 时用。名单刻意保守——`job/*`（后台任务可在 turn 外
-     * 结算）、`user/message`、`turn/end` 都不算，判不出来就报告 `unknown`。
+     * 结算）、`turn/end` 都不算，判不出来就报告 `unknown`。
+     *
+     * 落盘顺序已从 DSH 源码验证（packages/core/agent-loop：agent.ts 的 turn()/
+     * step() + inbox.ts 的 mutate()）：prompt 提交只落 `agent/inbox/spliced`，
+     * `turn/start` 由 turn() 在认领前 append，`user/message` 在 step() 认领时才
+     * append——顺序是 spliced → turn/start → user/message。两个边界：
+     *
+     * - 尾部 `agent/inbox/spliced` → closed 是**对的**：turn 尚未打开，cancel
+     *   空闲 session 无害，随后 withdraw 探测会撤走排队 prompt；
+     * - 尾部 `user/message` → **unknown**：step() 里 user/message append 后要等
+     *   一整个 LLM 往返才有下一条 durable 事件（assistant 流帧是 process-local
+     *   的），这个秒级窗口内 turn 已打开；且压缩 checkpoint 也以 turn:null 落
+     *   user/message——两种解释并存时只能报 unknown（stop 按 unconfirmed 处理，
+     *   不假报已停止）。此前报 closed 会让一个 LLM 往返宽的窗口假报干净停止。
      */
     private probeOpenTurnByEvents;
     /**
@@ -290,6 +303,23 @@ export declare class DshClient {
      * keeps the card "running" until this run's turn actually finishes.
      */
     sessionEvents(sessionId: string, signal: AbortSignal, initialSeq?: number, promptRequestId?: string): AsyncGenerator<DshStreamItem>;
+    /**
+     * 快照缺口回填（经 DSH 源码验证后实现）。
+     *
+     * follow 开场快照按**消息**截取：host 的 paginate 只数 user/assistant
+     * message（工具事件随所在消息组搭车进快照，不占预算），`maxMessages` 内
+     * 装不下的更早前缀被截掉并以 `hasMore: true` 标记。断连期间积压超过
+     * FOLLOW_MAX_MESSAGES 条消息时，`lastSeq` 与快照起点之间的缺口若不补，
+     * 这些事件对本次 follow 永久缺失（卡片丢中段工具行；seq 去重只防重放
+     * 不补缺）。`session/page` 的 `throughSeq` 游标正是服务端为此设计的回填
+     * 通道——从缺口尾部向前翻页直到盖住 lastSeq、翻到日志头或达到页数上限。
+     *
+     * best-effort：翻页失败保留已取回的部分（缺口剩余与旧行为一致地丢失，
+     * 但只发生在超出 BACKFILL_MAX_PAGES×PAGE_MESSAGES 条消息的极端断连）。
+     * 返回 seq 升序的完整回放序列（回填 + 快照记录；与 lastSeq 重叠的条目
+     * 由回放循环的 seq 去重兜住）。
+     */
+    private replaySnapshotGap;
     /**
      * Host-wide live projection stream (`session/control`).
      *

package/dist/runner/dsh/client.js

@@ -52,8 +52,19 @@ function isDshAuthError(error) {
 }
 /** Backoff between mux reconnects to avoid a hot loop on a dropping server. */
 const RECONNECT_BACKOFF_MS = 200;
-/** Follow snapshot budget. `session/follow` also stays live after the snapshot. */
+/**
+ * Follow snapshot budget. `session/follow` also stays live after the snapshot.
+ *
+ * 语义（经 DSH 源码验证，packages/api/session-controller/src/history.ts
+ * 的 paginate）：按**消息**计数——只有 user/assistant message 占预算，工具
+ * 事件随所在消息组搭进快照。断连期间积压超过该预算时快照首条会越过
+ * lastSeq，缺口经 {@link replaySnapshotGap} 用 session/page 回填。
+ */
 const FOLLOW_MAX_MESSAGES = 200;
+/** 快照缺口回填的单页消息数（session/page 的 maxMessages）。 */
+const FOLLOW_GAP_BACKFILL_PAGE_MESSAGES = 200;
+/** 快照缺口回填的页数上限（×PAGE_MESSAGES = 单次重连最多回补 4000 条消息）。 */
+const FOLLOW_GAP_BACKFILL_MAX_PAGES = 20;
 /**
  * 只在 turn 内部落盘的会话事件类型：看到它们说明 turn 还没结束。
  * 名单刻意保守——`user/message`（压缩 checkpoint 会以 turn:null 落盘）、
@@ -116,7 +127,15 @@ export function extractDshToken(raw) {
         return value;
     try {
         const url = new URL(value.startsWith('?') ? `http://dsh.invalid/${value}` : value);
-        return url.searchParams.get('token') ?? value;
+        const token = url.searchParams.get('token');
+        if (token)
+            return token;
+        // 带 scheme 却没有 token 参数的输入是误贴的 host URL（如
+        // `http://127.0.0.1:3080`）：整串不是合法 token，参与握手只会得到
+        // 指向性缺失的 401。返回空串让上游走「token 缺失」的诊断路径。
+        if (value.includes('://'))
+            return '';
+        return value;
     }
     catch {
         return value;
@@ -540,7 +559,20 @@ export class DshClient {
      * Fallback probe: the newest durable event's type tells whether a turn is open.
      *
      * 只在拿不到 `running` 时用。名单刻意保守——`job/*`（后台任务可在 turn 外
-     * 结算）、`user/message`、`turn/end` 都不算，判不出来就报告 `unknown`。
+     * 结算）、`turn/end` 都不算，判不出来就报告 `unknown`。
+     *
+     * 落盘顺序已从 DSH 源码验证（packages/core/agent-loop：agent.ts 的 turn()/
+     * step() + inbox.ts 的 mutate()）：prompt 提交只落 `agent/inbox/spliced`，
+     * `turn/start` 由 turn() 在认领前 append，`user/message` 在 step() 认领时才
+     * append——顺序是 spliced → turn/start → user/message。两个边界：
+     *
+     * - 尾部 `agent/inbox/spliced` → closed 是**对的**：turn 尚未打开，cancel
+     *   空闲 session 无害，随后 withdraw 探测会撤走排队 prompt；
+     * - 尾部 `user/message` → **unknown**：step() 里 user/message append 后要等
+     *   一整个 LLM 往返才有下一条 durable 事件（assistant 流帧是 process-local
+     *   的），这个秒级窗口内 turn 已打开；且压缩 checkpoint 也以 turn:null 落
+     *   user/message——两种解释并存时只能报 unknown（stop 按 unconfirmed 处理，
+     *   不假报已停止）。此前报 closed 会让一个 LLM 往返宽的窗口假报干净停止。
      */
     async probeOpenTurnByEvents(sessionId, opts) {
         try {
@@ -555,6 +587,8 @@ export class DshClient {
             const last = value.records.at(-1)?.event;
             if (last === undefined)
                 return 'closed';
+            if (last.type === 'user/message')
+                return 'unknown';
             return last.type === 'turn/start' || IN_TURN_EVENT_TYPES.has(last.type) ? 'open' : 'closed';
         }
         catch (err) {
@@ -575,6 +609,7 @@ export class DshClient {
         let waiter = null;
         let ended = false;
         let failure;
+        let opened = false;
         const settle = (frame) => {
             if (waiter) {
                 const resolve = waiter;
@@ -587,7 +622,27 @@ export class DshClient {
             else
                 ended = true;
         };
+        // 建连/首帧超时：服务器接受 TCP 但不完成 WS 握手时 onopen/onerror/onclose
+        // 都不触发，generator 会永远停在 await next()——unary 挂起有 60s 预算与
+        // 回归测试（test_anchor_dsh_stop_with_hung_unary_releases_run），mux 的
+        // 同型问题此前只能靠 idle 看门狗兜底。超时按传输错误走既有重连路径。
+        const connectTimer = setTimeout(() => {
+            if (opened || ended)
+                return;
+            failure = new DshError('transport', 'DSH remote mux WebSocket connect timeout');
+            ended = true;
+            settle(undefined);
+            try {
+                socket.close();
+            }
+            catch {
+                /* ignore close error */
+            }
+        }, this.requestTimeoutMs);
+        connectTimer.unref?.();
         socket.onopen = () => {
+            opened = true;
+            clearTimeout(connectTimer);
             if (ended)
                 return;
             try {
@@ -694,6 +749,7 @@ export class DshClient {
             }
         }
         finally {
+            clearTimeout(connectTimer);
             signal.removeEventListener('abort', onAbort);
             try {
                 socket.close();
@@ -734,6 +790,12 @@ export class DshClient {
                     const frame = raw;
                     if (frame.type === 'ready') {
                         authRefreshAttempted = false;
+                        // 成功建连后补充重连预算：goal 驱动的 turn 可跑数小时，DSH 重启 +
+                        // 网络抖动累计掉线超过 3 次后，旧实现会让 $events 永久 unavailable
+                        // ——已渲染的提问卡持有过期 clientId（点答案必失败）、Host 的 cancel
+                        // 帧也收不到，违反「同一 waterfall 在 $events 重连后会被重投」的
+                        // 不变量。预算语义是「单次断连窗口内的连续失败上限」，不是终身配额。
+                        reconnectAttempts = 0;
                         sawReady = true;
                         streamClientId = frame.clientId;
                         yield { kind: 'ready', clientId: streamClientId };
@@ -904,9 +966,10 @@ export class DshClient {
                         return;
                     authRefreshAttempted = false;
                     if (frame.type === 'snapshot') {
-                        for (const record of frame.records ?? []) {
-                            const ev = record.event;
-                            if (!ev || ev.seq <= state.lastSeq)
+                        // 快照可能只覆盖尾部窗口（见 replaySnapshotGap）：先补缺口再回放，
+                        // 回放循环与原逻辑逐条相同（去重 / admit / turn/end 早退）。
+                        for (const ev of await this.replaySnapshotGap(sessionId, signal, state.lastSeq, frame)) {
+                            if (ev.seq <= state.lastSeq)
                                 continue;
                             state.lastSeq = ev.seq;
                             if (!admit(ev))
@@ -963,6 +1026,63 @@ export class DshClient {
             await new Promise((resolve) => setTimeout(resolve, RECONNECT_BACKOFF_MS));
         }
     }
+    /**
+     * 快照缺口回填（经 DSH 源码验证后实现）。
+     *
+     * follow 开场快照按**消息**截取：host 的 paginate 只数 user/assistant
+     * message（工具事件随所在消息组搭车进快照，不占预算），`maxMessages` 内
+     * 装不下的更早前缀被截掉并以 `hasMore: true` 标记。断连期间积压超过
+     * FOLLOW_MAX_MESSAGES 条消息时，`lastSeq` 与快照起点之间的缺口若不补，
+     * 这些事件对本次 follow 永久缺失（卡片丢中段工具行；seq 去重只防重放
+     * 不补缺）。`session/page` 的 `throughSeq` 游标正是服务端为此设计的回填
+     * 通道——从缺口尾部向前翻页直到盖住 lastSeq、翻到日志头或达到页数上限。
+     *
+     * best-effort：翻页失败保留已取回的部分（缺口剩余与旧行为一致地丢失，
+     * 但只发生在超出 BACKFILL_MAX_PAGES×PAGE_MESSAGES 条消息的极端断连）。
+     * 返回 seq 升序的完整回放序列（回填 + 快照记录；与 lastSeq 重叠的条目
+     * 由回放循环的 seq 去重兜住）。
+     */
+    async replaySnapshotGap(sessionId, signal, lastSeq, frame) {
+        const records = (frame.records ?? [])
+            .map((record) => record.event)
+            .filter((ev) => !!ev);
+        if (frame.hasMore !== true || signal.aborted)
+            return records;
+        const firstSeq = records[0]?.seq;
+        const gapEnd = firstSeq !== undefined ? firstSeq - 1 : frame.cursor;
+        if (gapEnd <= lastSeq)
+            return records;
+        const pages = [];
+        try {
+            let throughSeq = gapEnd;
+            for (let page = 0; page < FOLLOW_GAP_BACKFILL_MAX_PAGES; page++) {
+                const value = await this.page(sessionId, throughSeq, FOLLOW_GAP_BACKFILL_PAGE_MESSAGES, {
+                    signal,
+                });
+                const events = (value.records ?? [])
+                    .map((record) => record.event)
+                    .filter((ev) => !!ev);
+                if (events.length > 0)
+                    pages.push(events);
+                const oldest = events[0]?.seq;
+                // hasMore=false（日志头）或本页已盖住 lastSeq：缺口补齐，停。
+                if (value.hasMore !== true || oldest === undefined || oldest <= lastSeq + 1)
+                    break;
+                throughSeq = oldest - 1;
+            }
+        }
+        catch (err) {
+            getLogger().warn(`[dsh] follow snapshot gap backfill incomplete sessionId=${sessionId}: ${err.message}`);
+        }
+        // pages 是「从新到旧」收集的；倒序拼接得到 seq 升序回放。
+        const backfill = [];
+        for (let index = pages.length - 1; index >= 0; index--)
+            backfill.push(...pages[index]);
+        if (backfill.length > 0) {
+            getLogger().info(`[dsh] backfilled ${backfill.length} events before follow snapshot sessionId=${sessionId} gapEnd=${gapEnd} lastSeq=${lastSeq}`);
+        }
+        return [...backfill, ...records];
+    }
     /**
      * Host-wide live projection stream (`session/control`).
      *

package/dist/runner/dsh/exit-cancel.js

@@ -12,6 +12,9 @@
  * curl transport the session reader already uses: bounded by `timeoutMs` and
  * never throws.
  */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { getLogger } from '../../logger/index.js';
 import { isWin32 } from '../../platform/select.js';
 import { spawnProcessSync } from '../../platform/spawn.js';
@@ -44,29 +47,65 @@ export function cancelSessionSync(opts) {
         method: 'session/cancel',
         payload: { args: { request: { sessionId: opts.sessionId } } },
     });
-    const res = spawnProcessSync('curl', [
-        '-s',
-        '-o',
-        isWin32() ? 'NUL' : '/dev/null',
-        '-w',
-        '%{http_code}',
-        '-X',
-        'POST',
-        `${opts.baseUrl.replace(/\/$/, '')}/api/session/cancel`,
-        '-H',
-        'content-type: application/json',
-        '-H',
-        `Cookie: ${cookie}`,
-        '--max-time',
-        String(Math.max(1, Math.ceil(timeoutMs / 1000))),
-        '--data',
-        body,
-    ], { encoding: 'utf-8', timeout: timeoutMs, maxBuffer: 1024 * 1024 });
-    const status = String(res.stdout ?? '').trim();
-    const ok = status === '200';
-    if (!ok) {
-        logger.warn(`[dsh] exit-cancel failed for ${opts.sessionId}: ${res.error?.message ?? `http ${status || 'n/a'}`}`);
+    // Cookie 不走 argv（`-H "Cookie: …"` 会在 curl 运行期间对本机任何进程的
+    // ps 可见——1 小时有效的 v1 凭据泄露面）：写 0600 临时文件用 `-H @file`
+    // 传入，用完即删。临时目录必须用 mkdtemp（0700、随机名）：Linux 的 /tmp
+    // 所有用户可写，固定名（如 `<pid>.hdr`）可被本地用户预建软链，而
+    // writeFileSync 会跟随软链把 cookie 写进攻击者可读的文件；后续 chmod
+    // 也救不回已被打开的 fd。文件写失败时回退 argv——退出路径的 cancel
+    // 不能因此放弃。
+    let headerDir;
+    let cookieHeaderArgs;
+    try {
+        headerDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lark-remote-exit-cancel-'));
+        const headerFile = path.join(headerDir, 'cookie.hdr');
+        fs.writeFileSync(headerFile, `Cookie: ${cookie}\n`, { mode: 0o600, flag: 'wx' });
+        cookieHeaderArgs = ['-H', `@${headerFile}`];
+    }
+    catch (err) {
+        logger.warn(`[dsh] exit-cancel header file unavailable: ${err.message}`);
+        removeDir(headerDir);
+        headerDir = undefined;
+        cookieHeaderArgs = ['-H', `Cookie: ${cookie}`];
+    }
+    try {
+        const res = spawnProcessSync('curl', [
+            '-s',
+            '-o',
+            isWin32() ? 'NUL' : '/dev/null',
+            '-w',
+            '%{http_code}',
+            '-X',
+            'POST',
+            `${opts.baseUrl.replace(/\/$/, '')}/api/session/cancel`,
+            '-H',
+            'content-type: application/json',
+            ...cookieHeaderArgs,
+            '--max-time',
+            String(Math.max(1, Math.ceil(timeoutMs / 1000))),
+            '--data',
+            body,
+        ], { encoding: 'utf-8', timeout: timeoutMs, maxBuffer: 1024 * 1024 });
+        const status = String(res.stdout ?? '').trim();
+        const ok = status === '200';
+        if (!ok) {
+            logger.warn(`[dsh] exit-cancel failed for ${opts.sessionId}: ${res.error?.message ?? `http ${status || 'n/a'}`}`);
+        }
+        return ok;
+    }
+    finally {
+        removeDir(headerDir);
+    }
+}
+/** 删除 cookie 临时目录（best-effort）；目录未创建时是空操作。 */
+function removeDir(dir) {
+    if (!dir)
+        return;
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch {
+        /* best-effort cleanup */
     }
-    return ok;
 }
 //# sourceMappingURL=exit-cancel.js.map

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

@@ -230,6 +230,13 @@ export declare class DshRunner implements AgentRunner {
      * that is the only client-side protection against a late orphan turn.
      */
     private findPendingPromptWithin;
+    /**
+     * cancel 确认 closed 后的收尾：cancel 是 keepInbox，prompt 可能仍在 inbox。
+     * 在则撤回（防被下一个 turn 隐形认领），确认不在（已被本 turn 消费）或
+     * 撤回成功才清 inflight 标记；探测/撤回失败保留标记，交给下次启动的
+     * reconcile（findPendingPrompt 落空即自然清除，无副作用）。
+     */
+    private withdrawPendingPromptAfterCancel;
     private removePendingPrompt;
     /** One cancel attempt, then one retry (the request is idempotent when idle). */
     private cancelWithRetry;

package/dist/runner/dsh/runner.js

@@ -1216,8 +1216,14 @@ export class DshRunner {
             const state = await this.waitForClosed(sessionId, deadline);
             if (state === 'closed') {
                 releaseGate();
-                if (promptRequestId)
-                    this.inflight?.clear(sessionId, promptRequestId);
+                // cancel 是 keepInbox：prompt 可能仍在 inbox 里，等下一个无人订阅的
+                // turn 认领（探测超时/迟到 admit 退到 cancel 分支时，
+                // 旧实现直接清 inflight 标记——被停的 prompt 会被后续 turn 隐形执行
+                //（耗 token、改工作区，卡片不可见），启动对账安全网也被解除）。
+                // closed 后补一次撤回：在 inbox 就撤走，确认不在才清标记。
+                if (promptRequestId) {
+                    await this.withdrawPendingPromptAfterCancel(sessionId, promptRequestId, deadline);
+                }
                 getLogger().info(`[dsh] cancelled session ${sessionId}`);
                 return { status: 'cancelled', sessionId };
             }
@@ -1233,8 +1239,9 @@ export class DshRunner {
             const retryState = await this.waitForClosed(sessionId, deadline);
             releaseGate();
             if (retryState === 'closed') {
-                if (promptRequestId)
-                    this.inflight?.clear(sessionId, promptRequestId);
+                if (promptRequestId) {
+                    await this.withdrawPendingPromptAfterCancel(sessionId, promptRequestId, deadline);
+                }
                 return { status: 'cancelled', sessionId };
             }
             getLogger().warn(`[dsh] stop unconfirmed session=${sessionId}: turn still open`);
@@ -1268,12 +1275,42 @@ export class DshRunner {
                     return undefined;
             }
             catch (err) {
+                // 单次探测错误只消耗一次尝试（不提前放弃）：探测失败就 return 会把
+                // 仍在 inbox 的 prompt 交给 cancel 分支处理——cancel 是 keepInbox，
+                // prompt 会留到下一个无人订阅的 turn 被隐形执行。
                 getLogger().warn(`[dsh] stop inbox probe failed session=${sessionId}: ${err.message}`);
-                return undefined;
+                continue;
             }
         }
         return undefined;
     }
+    /**
+     * cancel 确认 closed 后的收尾：cancel 是 keepInbox，prompt 可能仍在 inbox。
+     * 在则撤回（防被下一个 turn 隐形认领），确认不在（已被本 turn 消费）或
+     * 撤回成功才清 inflight 标记；探测/撤回失败保留标记，交给下次启动的
+     * reconcile（findPendingPrompt 落空即自然清除，无副作用）。
+     */
+    async withdrawPendingPromptAfterCancel(sessionId, promptRequestId, deadline) {
+        try {
+            const itemId = await this.client.findPendingPrompt(sessionId, promptRequestId, {
+                timeoutMs: this.stopProbeTimeout(deadline),
+            });
+            if (itemId) {
+                const removed = await this.client.removeQueuedPrompt(sessionId, itemId, {
+                    timeoutMs: this.stopProbeTimeout(deadline),
+                });
+                if (removed) {
+                    getLogger().info(`[dsh] stop withdrew inbox prompt left behind by cancel session=${sessionId}`);
+                    this.inflight?.clear(sessionId, promptRequestId);
+                }
+                return;
+            }
+            this.inflight?.clear(sessionId, promptRequestId);
+        }
+        catch (err) {
+            getLogger().warn(`[dsh] post-cancel withdraw probe failed session=${sessionId}: ${err.message}`);
+        }
+    }
     async removePendingPrompt(sessionId, itemId, deadline) {
         try {
             return await this.client.removeQueuedPrompt(sessionId, itemId, {

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

@@ -144,6 +144,11 @@ export class KimiAcpRunner extends BaseAcpRunner {
      */
     compactBaselineRecords = [];
     /** 存活 terminal（kimi 把 Bash 执行下放客户端）：terminalId → 本地句柄。 */
+    // 已知限制（待验证 kimi 0.4x 契约）：句柄只在
+    // terminal/release 与连接关闭（cleanupTerminals）时删除。若服务端只 kill
+    // 不 release（中断 turn 的场景），已退出进程的句柄（含 ≤4MB output 缓冲）
+    // 会滞留到连接释放。kimi 契约上工具结束会发 release（mock 测试同驱动）；
+    // 若真机确认存在只 kill 不 release 的路径，再补 exit 后延迟回收。
     terminals = new Map();
     /** terminalId 自增序号（term-1, term-2, …）。 */
     terminalSeq = 0;
@@ -422,6 +427,11 @@ export class KimiAcpRunner extends BaseAcpRunner {
         while (true) {
             if (this.forceFinish || this.stopRequested)
                 return 'stopped';
+            // turn 已死亡（failTurn，如连接关闭）时不再轮询：forceFinish 与
+            // stopRequested 均为 false 的死亡路径会让循环空转到 10 分钟沉默超时，
+            // 结果还被 isCurrent() 丢弃——纯浪费的每秒文件读。
+            if (!this._isRunning)
+                return 'unknown';
             const records = reader.call(this.sessionReader, sessionId, opts.cwd);
             if (records.length !== lastTotalCount) {
                 lastTotalCount = records.length;
@@ -506,8 +516,15 @@ export class KimiAcpRunner extends BaseAcpRunner {
             // (error = "rejected"), otherwise the server hangs waiting for a
             // response. For question elicitation (§5.4), auto-respond cancelled.
             const rpParams = params;
-            if (method === ServerRequestMethod.REQUEST_PERMISSION &&
-                (rpParams.isQuestion || !rpParams.toolCall)) {
+            // elicitation/create 的表单属性全不可解析时（translator 返回 []）同样回
+            // cancelled 而不是 METHOD_NOT_FOUND：§5.4 的不变量是「识别到非工具审批
+            // 形态 → 自动回应 cancelled，防止服务端挂起」；错误响应虽也能解悬挂，
+            // 但 kimi 侧可能把 JSON-RPC error 当工具级失败让整个 turn 报错，而不是
+            // 跳过提问继续。
+            const isQuestionElicitation = method === ServerRequestMethod.REQUEST_PERMISSION &&
+                (rpParams.isQuestion || !rpParams.toolCall);
+            const isUnparseableElicitationForm = method === ServerRequestMethod.ELICITATION_CREATE;
+            if (isQuestionElicitation || isUnparseableElicitationForm) {
                 this.currentClient?.respond(id, { outcome: { outcome: 'cancelled' } });
                 getLogger().info(`[${this.logTag}] auto-responded cancelled to question elicitation requestId=${id}`);
             }
@@ -633,8 +650,27 @@ export class KimiAcpRunner extends BaseAcpRunner {
         proc.once('exit', (code, signal) => {
             handle.exitCode = code;
             handle.signal = signal;
-            resolveExit?.();
-            emitResult();
+            // 'exit' 可先于 stdout 缓冲派发：立刻 emit 会按旧快照推送 tool_result，
+            // 卡片面板丢尾部输出（terminal/output 反向 RPC 读到的是补齐后的全量，
+            // 只影响卡片）。等流 end 或 200ms 宽限——不等 'close'：它要等所有共享
+            // 管道的子孙进程退出，`nohup &` 类后台任务会把它拖到永远。
+            //
+            // wait_for_exit 必须在 tool_result 入队之后才 resolve：服务端拿到响应
+            // 后会立刻 release + end_turn，先 resolve 会让回合结果早于延迟推送的
+            // tool_result 到达，Bash 输出被丢弃（卡片面板空输出）。
+            const flushThenEmit = () => {
+                clearTimeout(emitTimer);
+                emitResult();
+                resolveExit?.();
+            };
+            const emitTimer = setTimeout(flushThenEmit, 200);
+            emitTimer.unref?.();
+            if (proc.stdout && !proc.stdout.destroyed) {
+                proc.stdout.once('end', flushThenEmit);
+            }
+            else {
+                flushThenEmit();
+            }
         });
         proc.once('error', (err) => {
             getLogger().warn(`[${this.logTag}] terminal process error: ${err.message}`);
@@ -642,8 +678,9 @@ export class KimiAcpRunner extends BaseAcpRunner {
                 handle.exitCode = 1;
                 handle.signal = null;
             }
-            resolveExit?.();
+            // 同 exit：tool_result 先入队，再放行 wait_for_exit。
             emitResult();
+            resolveExit?.();
         });
         const terminalId = `term-${++this.terminalSeq}`;
         this.terminals.set(terminalId, handle);

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

@@ -29,6 +29,14 @@ import { type RequestPermissionParams, type AgentMessageChunkEvent, type AgentTh
 import { BaseAcpTranslator, type AcpTranslatorEvent } from '../../common/acp/base-translator.js';
 export declare class KimiAcpTranslator extends BaseAcpTranslator {
     protected readonly logTag = "kimi-acp-translator";
+    /**
+     * 非终态 tool_call_update 不附带空 tool_result：kimi 非 Bash 工具的
+     * in-progress 只带流式 args（rawOutput 缺省 → content ''），空 tool_result
+     * 会让 reducer 把运行中的工具提前置 ✅ + 空输出（终态到达后自愈，但终态
+     * 丢失时面板停在错误的「已完成」）。opencode 走基类默认 true（其
+     * in-progress 带输出快照，seam 契约钉死要发）。
+     */
+    protected emitToolResultForNonTerminalUpdate(content: unknown): boolean;
     /** Accumulated text per tool-call or message (keyed by a logical item id). */
     private textByItem;
     /** Accumulated thinking per item. */

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

@@ -42,6 +42,16 @@ const THINKING_ITEM_ID = 'thinking';
 // =============================================================================
 export class KimiAcpTranslator extends BaseAcpTranslator {
     logTag = 'kimi-acp-translator';
+    /**
+     * 非终态 tool_call_update 不附带空 tool_result：kimi 非 Bash 工具的
+     * in-progress 只带流式 args（rawOutput 缺省 → content ''），空 tool_result
+     * 会让 reducer 把运行中的工具提前置 ✅ + 空输出（终态到达后自愈，但终态
+     * 丢失时面板停在错误的「已完成」）。opencode 走基类默认 true（其
+     * in-progress 带输出快照，seam 契约钉死要发）。
+     */
+    emitToolResultForNonTerminalUpdate(content) {
+        return !(content === undefined || content === null || content === '');
+    }
     /** Accumulated text per tool-call or message (keyed by a logical item id). */
     textByItem = new Map();
     /** Accumulated thinking per item. */