lark-remote 0.5.10 → 0.5.12

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

@@ -269,6 +269,10 @@ export class BaseAcpTranslator {
     }
     /**
      * tool_call_update → user/tool_result. status:'failed' → is_error:true.
+     *
+     * 终态（completed/failed）产出 tool_result；非终态的 tool_result 由
+     * {@link emitToolResultForNonTerminalUpdate} 裁定（reducer 见到 tool_result
+     * 即置 status:'ok'——无内容的非终态 tool_result 会把运行中的工具提前翻成 ✅）。
      */
     handleToolCallUpdate(event, _sessionId) {
         const isError = event.status === 'failed';
@@ -293,6 +297,13 @@ export class BaseAcpTranslator {
             else if (event.rawInput !== undefined && event.rawInput !== null) {
                 this.trackToolCallArgs(event.toolCallId, stringifyUnknown(event.rawInput));
             }
+            // 非终态是否发 tool_result 由子类裁定（emitToolResultForNonTerminalUpdate）：
+            // opencode 的 in-progress 带输出快照，seam 契约钉死「patch + tool_result」
+            // 都要发（面板在工具运行时显示部分输出）；kimi 的 in-progress 只带流式
+            // args，空 tool_result 会让 reducer 把运行中的工具提前置 ✅ + 空输出。
+            if (!this.emitToolResultForNonTerminalUpdate(content)) {
+                return useUpdate ? [useUpdate] : [];
+            }
         }
         const events = [];
         if (useUpdate)
@@ -390,6 +401,17 @@ export class BaseAcpTranslator {
     extractToolResultContent(event) {
         return event.rawOutput ?? '';
     }
+    /**
+     * 非终态 tool_call_update 是否附带 tool_result。默认 true（opencode seam
+     * 契约：in-progress 的输出快照随 tool_result 进面板）。kimi 覆写为
+     * 「有内容才发」——它的 in-progress 只带流式 args，空 tool_result 会让
+     * reducer 把运行中的工具提前置 ✅ + 空输出（终态丢失时面板停在错误的
+     * 「已完成」）。
+     */
+    emitToolResultForNonTerminalUpdate(content) {
+        void content;
+        return true;
+    }
     /**
      * usage_update → context occupancy bookkeeping. The wire shape is
      * {used, size} (+ opencode: cost:{amount}) — context occupancy, not

package/dist/runner/common/jsonl-stream.js

@@ -1,4 +1,5 @@
 import { getLogger } from '../../logger/index.js';
+import { StringDecoder } from 'node:string_decoder';
 /**
  * Parse JSONL (newline-delimited JSON) from a readable stream.
  *
@@ -30,6 +31,8 @@ export function createJSONLStream(stdout, options) {
     // and push complete lines; the residual tail stays as array fragments until
     // the next newline or stream end. Net allocation: O(n) instead of O(n²).
     const partialFragments = [];
+    // 跨 chunk 多字节字符的边界安全解码器（见 stdout 'data' 处理）。
+    const decoder = new StringDecoder('utf8');
     // accumulated byte length of partialFragments. Backpressure (above)
     // only counts COMPLETE lines in lineQueue; a never-newline stream (malformed
     // output, binary garbage) accumulates fragments without ever completing a
@@ -60,6 +63,11 @@ export function createJSONLStream(stdout, options) {
     // Flush any trailing partial line and mark the stream finished. Shared by the
     // 'end'/'close'/'error' handlers so flush logic lives in one place (nit).
     function flushAndFinish() {
+        // decoder.end() 吐出被 chunk 边界切开的最后一个多字节字符的残余字节
+        //（无残尾时返回空串）：不加这句，末尾被切开的字符会凭空丢失。
+        const tail = decoder.end();
+        if (tail)
+            partialFragments.push(tail);
         if (partialFragments.length > 0) {
             const trimmed = partialFragments.join('').trim();
             if (trimmed)
@@ -109,7 +117,10 @@ export function createJSONLStream(stdout, options) {
         }
     }
     stdout.on('data', (chunk) => {
-        const text = chunk.toString('utf-8');
+        // StringDecoder 按字节边界解码：多字节字符（中文/emoji）被 chunk 边界
+        // 切开时，裸 toString 会产出不可逆的 U+FFFD（同族修复见
+        // jsonrpc/transport.ts，claude 的中文输出走本流）。
+        const text = decoder.write(chunk);
         // split on newlines. The first segment continues the pending partial
         // line (joined with accumulated fragments — one join per chunk, not per
         // byte); subsequent segments are complete lines. The last segment is the

package/dist/runner/common/jsonrpc/connection-manager.js

@@ -84,7 +84,17 @@ export class ConnectionManager {
             if (existing) {
                 // If a create is in flight, wait for it
                 if (existing.createPromise) {
-                    return existing.createPromise;
+                    const client = await existing.createPromise;
+                    // 快速路径复核（与下方建槽方的竞态复核对称）：await 期间槽位被
+                    // release()/disposeAll() 删掉时，建槽方会 dispose 该连接并重试——
+                    // 直接返回会把「已被建槽方 dispose 的连接」交给本调用方（表现为
+                    // setupTurn 抛 ConnectionLostError 走 respawn-retry 自愈）。槽位
+                    // 不再持有该 client 时与本轮创建同路：重试。
+                    const current = this.slots.get(cwd);
+                    if (current && current.client === client) {
+                        return client;
+                    }
+                    continue;
                 }
                 // Reuse when the (session-aware) reuse predicate holds — e.g. the client
                 // is ready and its transport is alive (default), or it is bound to the

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, {