lark-remote 0.5.6 → 0.5.8

package/dist/runner/dsh/runner.js

@@ -6,8 +6,10 @@
  * alignment → synthetic system/init (DSH has no init event) → session/prompt
  * (mode:'queue') → consume `session/follow` + `$events` until turn/end.
  *
- * stop() → session/cancel + abort the mux subscription. killOrphan /
- * registerExitHandlers are no-ops (no local process). DSH approvals are
+ * stop() → session/cancel + abort the mux subscription. killOrphan is a no-op
+ * (no local process); registerExitHandlers cancels the in-flight turn
+ * synchronously on process exit, because the turn lives in the shared host and
+ * would otherwise keep running with no subscriber. DSH approvals are
  * two-channel: durable `approval/asked` / `approval/decided` drive the Feishu
  * card, while the answerable `$events` waterfall supplies eventId/clientId.
  * `ask_user_question` prompts arrive only as a `user-questions/request`
@@ -20,6 +22,9 @@ import { DshTranslator } from './translator.js';
 import { DshApprovalTracker } from './approval.js';
 import { mergeAsync } from './merge.js';
 import { getLogger } from '../../logger/index.js';
+import { registerExitCleanup, unregisterExitCleanup } from '../common/spawning-runner.js';
+import { cancelSessionSync } from './exit-cancel.js';
+import { DshInflightStore } from './inflight.js';
 /**
  * Legacy provider for configs written before `agents.dsh.provider` existed.
  * New configs pin the provider explicitly; the card reads the live catalog.
@@ -74,8 +79,85 @@ function buildQuestionAnswers(questions, response) {
             : { id: question.id, selected: [], custom: selected };
     });
 }
-/** Budget for the fire-and-forget session/cancel on stop (never block /stop). */
+/** Budget for one session/cancel attempt on stop. */
 const CANCEL_TIMEOUT_MS = 5_000;
+/** Total stop budget: withdraw + cancel + verify must not hold the lane forever. */
+const STOP_BUDGET_MS = 5_000;
+/** A prompt request that was still in flight can land after stop's abort. */
+const STOP_ADMIT_ATTEMPTS = 5;
+const STOP_ADMIT_DELAY_MS = 250;
+/** Cancel is applied synchronously; give the turn a moment to unwind. */
+const STOP_VERIFY_ATTEMPTS = 4;
+const STOP_VERIFY_DELAY_MS = 350;
+/** Per-read budget for inbox/status probes on the stop path. */
+const STOP_PROBE_TIMEOUT_MS = 2_000;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * 把一帧 `session/control` 投影写进状态条累计值。
+ * @returns 本仓库消费的字段是否真的变了（未变不必刷新卡片）。
+ */
+function applyProjection(live, key, value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    if (key === 'contextPressure') {
+        const pressure = value;
+        // 官方 UI 的口径：优先 projectedTokens（下一次请求的预估），退回实际占用。
+        const used = pressure.projectedTokens ?? pressure.pressureTokens;
+        let changed = false;
+        if (typeof used === 'number' && used !== live.contextUsed) {
+            live.contextUsed = used;
+            changed = true;
+        }
+        if (typeof pressure.contextWindow === 'number' &&
+            pressure.contextWindow > 0 &&
+            pressure.contextWindow !== live.contextLimit) {
+            live.contextLimit = pressure.contextWindow;
+            changed = true;
+        }
+        return changed;
+    }
+    if (key === 'sessionStats') {
+        const stats = value;
+        let changed = false;
+        if (typeof stats.steps === 'number' && stats.steps !== live.steps) {
+            live.steps = stats.steps;
+            changed = true;
+        }
+        if (typeof stats.toolMs === 'number' && stats.toolMs !== live.toolMs) {
+            live.toolMs = stats.toolMs;
+            changed = true;
+        }
+        return changed;
+    }
+    return false;
+}
+/** Build the `run_status` event for the card's status strip. */
+function statusEventOf(live) {
+    return {
+        type: 'run_status',
+        ...(live.contextUsed === undefined ? {} : { contextUsed: live.contextUsed }),
+        ...(live.contextLimit === undefined ? {} : { contextLimit: live.contextLimit }),
+        ...(live.steps === undefined ? {} : { steps: live.steps }),
+        ...(live.toolMs === undefined ? {} : { toolMs: live.toolMs }),
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Attach the context window to the result usage.
+ *
+ * DSH 的会话读取端只产出占用、不产出窗口上限，终态卡因此只能显示绝对量；
+ * 控制流拿到的 `contextWindow` 是唯一的百分比来源。已有上限（未来 DSH 自带）
+ * 时不覆盖。
+ */
+function attachContextLimit(ev, limit) {
+    if (ev.type !== 'result' || limit === undefined || !ev.usage)
+        return ev;
+    if (ev.usage.context_limit !== undefined)
+        return ev;
+    return { ...ev, usage: { ...ev.usage, context_limit: limit } };
+}
 /** Parse tool-call arguments without letting malformed JSON crash the run. */
 function parseToolArguments(raw) {
     if (!raw)
@@ -112,6 +194,19 @@ export class DshRunner {
     activeAbort = null;
     activeSessionId = null;
     running = false;
+    /** This run's prompt identity (`source.rpcId`); null outside a submitted prompt. */
+    activePromptRequestId = null;
+    /** Whether the current prompt request was accepted by the host. */
+    promptAdmitted = false;
+    /**
+     * Releases the next run's prompt only after this stop's withdraw/cancel has
+     * been applied. Aborting the local mux lets the queue advance immediately;
+     * without the gate the successor's prompt can reach the host before the
+     * cancel, and a session-scoped cancel would then hit the *new* turn.
+     */
+    pendingStopGate = null;
+    pendingStopSessionId = null;
+    inflight;
     daemon;
     /**
      * 已对齐模型的 session 集合：同一 session 二次 run 不再重发 selectModel
@@ -135,6 +230,8 @@ export class DshRunner {
     toolCalls = new Map();
     /** False after `$events` is unavailable; approval/asked then falls back to text. */
     approvalChannelAvailable = true;
+    /** 退出路径的取消实现（默认同步 curl，见 `cancelSessionSync`）。 */
+    cancelOnExit;
     constructor(opts) {
         this.sessionReader = opts.sessionReader;
         this.daemon = opts.daemon;
@@ -143,6 +240,7 @@ export class DshRunner {
         this.agentPreset = opts.agentPreset;
         this.configuredPermissionPreset = opts.permissionPreset;
         this.reasoningEffort = opts.reasoningEffort;
+        this.inflight = opts.inflightPath ? new DshInflightStore(opts.inflightPath) : null;
         this.client = new DshClient(opts.host ?? 'http://127.0.0.1:3080', {
             dshHome: opts.dshHome,
             token: opts.token,
@@ -151,6 +249,16 @@ export class DshRunner {
             webSocketImpl: opts.webSocketImpl,
             requestTimeoutMs: opts.requestTimeoutMs,
         });
+        this.cancelOnExit =
+            opts.cancelOnExit ??
+                (({ baseUrl, sessionId }) => {
+                    cancelSessionSync({
+                        baseUrl,
+                        sessionId,
+                        dshHome: opts.dshHome,
+                        credentialsFile: opts.credentialsFile,
+                    });
+                });
     }
     get isRunning() {
         return this.running;
@@ -216,8 +324,13 @@ export class DshRunner {
         const abort = new AbortController();
         this.activeAbort = abort;
         this.running = true;
+        // A stop releases the local lane before its cancel has been applied; the
+        // next prompt must not race that cancel (see `pendingStopGate`). State is
+        // already published above so an immediate stop can abort this run too.
+        await this.awaitStopGate(opts.sessionId);
         let sessionId = opts.sessionId;
         let terminalEmitted = false;
+        let promptRequestId = null;
         try {
             // DSH is a shared, machine-wide process. Reuse it when it is already
             // listening; otherwise start it detached so lark-remote exiting does not
@@ -269,7 +382,7 @@ export class DshRunner {
                 };
                 return;
             }
-            // provider/模型/推理强度对齐（§4.3）：会话首次 run 时 selectModel 一次
+            // provider/模型/推理强度对齐：会话首次 run 时 selectModel 一次
             // （该调用同时写服务端全局默认，故不重复写）；同一 session 后续 run
             // 跳过。显式配置 provider 时失败必须 fail closed：静默回退到其他
             // provider 会让用户以为切换成功，实际模型与账单都错。
@@ -328,12 +441,28 @@ export class DshRunner {
                 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: newPromptRequestId(),
+                    requestId: promptRequestId,
                     sessionId,
                     mode: 'queue',
                     content: [{ type: 'text', text: message }],
                 }, { signal: abort.signal });
+                this.promptAdmitted = true;
                 if (abort.signal.aborted) {
                     // stop() 在 prompt 已受理后到达：cancel 由 stop() 发出，这里直接收尾，
                     // 不再打开 mux（否则会看到 cancel 产生的 turn/end 事件）。
@@ -347,7 +476,7 @@ export class DshRunner {
                     return;
                 }
                 try {
-                    for await (const ev of this.runTurn(sessionId, opts.cwd, prePromptSeq, abort)) {
+                    for await (const ev of this.runTurn(sessionId, opts.cwd, prePromptSeq, promptRequestId, abort)) {
                         yield ev;
                         if (ev.type === 'result') {
                             terminalEmitted = true;
@@ -398,6 +527,14 @@ export class DshRunner {
             this.running = false;
             this.activeSessionId = null;
             this.activeAbort = null;
+            this.activePromptRequestId = null;
+            this.promptAdmitted = false;
+            // On abort the stop path decides whether the marker is settled (verified
+            // stop) or must survive for startup reconciliation (cancel failed). A
+            // naturally finished run owns its terminal result, so drop it here.
+            if (!abort.signal.aborted && sessionId && promptRequestId) {
+                this.inflight?.clear(sessionId, promptRequestId);
+            }
         }
         if (!terminalEmitted) {
             yield {
@@ -413,7 +550,7 @@ export class DshRunner {
      * events; `$events` owns the answerable approval waterfall. The merged
      * stream keeps either transport from starving the other.
      */
-    async *runTurn(sessionId, cwd, prePromptSeq, abort) {
+    async *runTurn(sessionId, cwd, prePromptSeq, promptRequestId, abort) {
         const streamAbort = new AbortController();
         const signal = AbortSignal.any([abort.signal, streamAbort.signal]);
         const translator = new DshTranslator();
@@ -422,14 +559,32 @@ export class DshRunner {
         this.pendingQuestions.clear();
         this.toolCalls.clear();
         this.approvalChannelAvailable = true;
+        // 状态条累计值（contextPressure / sessionStats 投影）。`contextWindow` 同时
+        // 用于给 result.usage.context_limit 兜底：DSH 的会话读取端不产出上限，
+        // 没有它终态卡只能显示绝对量、算不出百分比。
+        const live = {};
         try {
             const sources = [
-                this.client.sessionEvents(sessionId, signal, prePromptSeq),
+                this.client.sessionEvents(sessionId, signal, prePromptSeq, promptRequestId),
                 this.client.approvalEvents(sessionId, signal),
+                this.client.controlFrames(signal),
             ];
             for await (const item of mergeAsync(sources)) {
                 if (abort.signal.aborted)
                     return;
+                if (item.kind === 'projection') {
+                    // 全 Host 流：只认本 session。未知 key 直接忽略（投影是能力发现式
+                    // 扩展的，不能因为多了个 key 就报错）。
+                    if (item.sessionId !== sessionId)
+                        continue;
+                    // 只在消费字段真的变了时才产出事件：投影帧本身按 key 去重推送，
+                    // 这里再挡掉"值没变"的重复帧。不需要时间节流——卡片更新本来就有
+                    // 100ms 合批窗口，与正文 delta 共用同一条节流路径。
+                    if (!applyProjection(live, item.key, item.value))
+                        continue;
+                    yield statusEventOf(live);
+                    continue;
+                }
                 if (item.kind === 'ready') {
                     this.approvalChannelAvailable = true;
                     continue;
@@ -513,7 +668,9 @@ export class DshRunner {
                                 this.toolCalls.delete(oldest);
                         }
                     }
-                    continue;
+                    // 记账后继续往下走：tool/call 同时是卡片工具行的来源（translator 翻
+                    // 译成 assistant.tool_use）。早期版本在这里 `continue`，把调用轨迹整个
+                    // 吞掉——卡片因此只有正文、没有任何工具行。
                 }
                 if (event.type === 'approval/decided') {
                     const data = event.data;
@@ -524,9 +681,16 @@ export class DshRunner {
                     continue;
                 }
                 for (const ev of translator.eventToAgentEvents(event, sessionId)) {
-                    yield ev;
-                    if (ev.type === 'result')
+                    if (ev.type === 'result') {
+                        if (!abort.signal.aborted) {
+                            for (const jobsEvent of await this.collectBackgroundJobs(sessionId, abort.signal)) {
+                                yield jobsEvent;
+                            }
+                        }
+                        yield attachContextLimit(ev, live.contextLimit);
                         return;
+                    }
+                    yield ev;
                 }
             }
         }
@@ -537,6 +701,37 @@ export class DshRunner {
             this.toolCalls.clear();
         }
     }
+    /**
+     * 收尾时仍在跑的后台任务。
+     *
+     * 只保留非终态（running/stopping）：已完成的任务由 agent 自己的 output 呈
+     * 现，卡片列出来只会误导"还没跑完"。`job/list` 拿不到时返回空数组——没有
+     * 任务列表不等于有任务在跑。
+     */
+    async collectBackgroundJobs(sessionId, signal) {
+        const rows = await this.client.jobRows(sessionId, { signal });
+        if (!rows)
+            return [];
+        const live = rows.filter((job) => job.status === 'running' || job.status === 'stopping');
+        if (live.length === 0)
+            return [];
+        return [
+            {
+                type: 'background_jobs',
+                jobs: live.map((job) => ({
+                    id: job.id,
+                    label: job.label ?? job.id,
+                    ...(job.status === undefined ? {} : { status: job.status }),
+                    ...(job.progress === undefined ? {} : { progress: job.progress }),
+                })),
+                timestamp: new Date().toISOString(),
+            },
+        ];
+    }
+    /** Kill one background job of this runner's session (card button path). */
+    async killJob(sessionId, jobId) {
+        return await this.client.jobKill(sessionId, jobId);
+    }
     /** Apply the configured permission preset once per session, before prompt. */
     async alignPermissionPreset(sessionId, signal) {
         const preset = this.configuredPermissionPreset;
@@ -751,6 +946,9 @@ export class DshRunner {
         this.running = true;
         this.activeSessionId = sessionId;
         let terminalEmitted = false;
+        // Same barrier as run(): a stop of this session must reach the host before
+        // the next compact is submitted.
+        await this.awaitStopGate(sessionId);
         try {
             if (this.daemon)
                 await this.daemon.ensure();
@@ -761,6 +959,19 @@ export class DshRunner {
                 cwd: opts.cwd,
                 model: this.configuredModel ?? 'DSH',
             };
+            // 桥接重启后内存里没有在途 run，但服务端可能还在跑上一轮：先用只读
+            // 探测兜底，别把注定被拒的 /compact 发出去（DSH 只回一句把「有压缩
+            // 在跑」和「agent 不空闲」合并在一起的文案，用户看不出真实原因）。
+            if (await this.client.hasOpenTurn(sessionId, { signal: abort.signal })) {
+                terminalEmitted = true;
+                yield {
+                    type: 'result',
+                    subtype: 'error',
+                    session_id: sessionId,
+                    errorMessage: '当前会话还有一轮在跑（DSH 服务端未空闲），等它结束后再压缩',
+                };
+                return;
+            }
             const outcome = await this.client.executeCommand(sessionId, DSH_COMPACT_COMMAND, {
                 signal: abort.signal,
                 // 压缩是一次长 unary（服务端等压缩结束才回），60s 默认预算会误杀；
@@ -871,26 +1082,233 @@ export class DshRunner {
             getLogger().warn(`[dsh] session/cancel failed for ${sessionId}: ${err.message}`);
         }
     }
+    /**
+     * Stop this run's work in the shared host.
+     *
+     * Two distinct things can be running, and DSH needs a different call for each:
+     *
+     * 1. A prompt that was accepted but not claimed yet still sits in the host
+     *    inbox. `session/cancel` would NOT drop it (`keepInbox`), so the turn would
+     *    start later with no subscriber — an orphan. Withdraw it by `rpcId` via
+     *    `session/updateQueue` instead, and leave the (foreign) active turn alone.
+     * 2. An already-claimed turn (or a compact) can only be stopped with
+     *    `session/cancel`. Since that request is session-scoped and only an
+     *    acknowledgement, verify the session went idle before reporting success.
+     *
+     * The gate is held until the host-side action has landed. For a cancel that
+     * includes the verification (and possible retry), because a retry cancel is
+     * session-scoped and would otherwise hit the successor's new turn.
+     */
     async stop(_opts) {
         const sessionId = this.activeSessionId;
+        const promptRequestId = this.activePromptRequestId;
+        const promptAdmitted = this.promptAdmitted;
         const abort = this.activeAbort;
+        // Free the local mux/queue first; the host-side stop continues below.
         if (abort && !abort.signal.aborted)
             abort.abort();
-        if (sessionId) {
-            // Do NOT reuse the run's (already aborted) signal: cancel must be sent,
-            // but bounded — a hung server must not block /stop or the queue.
-            await this.cancelSessionQuietly(sessionId);
-            getLogger().info(`[dsh] cancelled session ${sessionId}`);
+        if (!sessionId)
+            return { status: 'noop' };
+        let releaseGate = () => { };
+        const gate = new Promise((resolve) => {
+            releaseGate = resolve;
+        });
+        this.pendingStopGate = gate;
+        this.pendingStopSessionId = sessionId;
+        let settled = false;
+        const release = () => {
+            if (settled)
+                return;
+            settled = true;
+            releaseGate();
+        };
+        try {
+            return await this.performStop(sessionId, promptRequestId, promptAdmitted, release);
         }
+        finally {
+            // Safety net for early returns/throws; performStop normally releases first.
+            release();
+            if (this.pendingStopGate === gate) {
+                this.pendingStopGate = null;
+                this.pendingStopSessionId = null;
+            }
+        }
+    }
+    /** Wait for a concurrent stop to reach the host before submitting a new prompt. */
+    async awaitStopGate(sessionId) {
+        const gate = this.pendingStopGate;
+        if (!gate)
+            return;
+        if (sessionId === undefined ||
+            this.pendingStopSessionId === null ||
+            sessionId !== this.pendingStopSessionId) {
+            return;
+        }
+        await gate;
+    }
+    async performStop(sessionId, promptRequestId, promptAdmitted, releaseGate) {
+        const deadline = Date.now() + STOP_BUDGET_MS;
+        try {
+            if (promptRequestId) {
+                const itemId = await this.findPendingPromptWithin(sessionId, promptRequestId, promptAdmitted, deadline);
+                if (itemId && (await this.removePendingPrompt(sessionId, itemId, deadline))) {
+                    releaseGate();
+                    this.inflight?.clear(sessionId, promptRequestId);
+                    getLogger().info(`[dsh] stop withdrew queued prompt session=${sessionId}`);
+                    return { status: 'withdrawn', sessionId };
+                }
+            }
+            // Nothing (or nothing claimable) in the inbox: the turn/compact is live.
+            if (!(await this.cancelWithRetry(sessionId, deadline))) {
+                releaseGate();
+                getLogger().warn(`[dsh] stop unconfirmed session=${sessionId}: cancel not accepted`);
+                return { status: 'unconfirmed', sessionId, detail: 'session/cancel was not accepted' };
+            }
+            const state = await this.waitForClosed(sessionId, deadline);
+            if (state === 'closed') {
+                releaseGate();
+                if (promptRequestId)
+                    this.inflight?.clear(sessionId, promptRequestId);
+                getLogger().info(`[dsh] cancelled session ${sessionId}`);
+                return { status: 'cancelled', sessionId };
+            }
+            if (state === 'unknown') {
+                releaseGate();
+                return { status: 'unconfirmed', sessionId, detail: 'turn state unavailable after cancel' };
+            }
+            // The host still reports an open turn (slow unwind or lost cancel): one
+            // more attempt, then report honestly instead of pretending it stopped.
+            // Keep the gate closed through the retry: it is session-scoped, so the
+            // successor must not submit its prompt until this attempt has landed.
+            await this.cancelWithRetry(sessionId, deadline);
+            const retryState = await this.waitForClosed(sessionId, deadline);
+            releaseGate();
+            if (retryState === 'closed') {
+                if (promptRequestId)
+                    this.inflight?.clear(sessionId, promptRequestId);
+                return { status: 'cancelled', sessionId };
+            }
+            getLogger().warn(`[dsh] stop unconfirmed session=${sessionId}: turn still open`);
+            return { status: 'unconfirmed', sessionId, detail: 'turn still open after cancel' };
+        }
+        catch (err) {
+            releaseGate();
+            getLogger().warn(`[dsh] stop failed session=${sessionId}: ${err.message}`);
+            return { status: 'unconfirmed', sessionId, detail: err.message };
+        }
+    }
+    /**
+     * Locate this run's unclaimed prompt.
+     *
+     * An already-admitted prompt is visible immediately. A request still in
+     * flight can be admitted after stop aborted it, so poll the inbox briefly —
+     * that is the only client-side protection against a late orphan turn.
+     */
+    async findPendingPromptWithin(sessionId, requestId, admitted, deadline) {
+        const attempts = admitted ? 1 : STOP_ADMIT_ATTEMPTS;
+        for (let attempt = 0; attempt < attempts; attempt++) {
+            if (attempt > 0 && !(await this.sleepWithin(deadline, STOP_ADMIT_DELAY_MS)))
+                return undefined;
+            try {
+                const itemId = await this.client.findPendingPrompt(sessionId, requestId, {
+                    timeoutMs: this.stopProbeTimeout(deadline),
+                });
+                if (itemId)
+                    return itemId;
+                if (admitted)
+                    return undefined;
+            }
+            catch (err) {
+                getLogger().warn(`[dsh] stop inbox probe failed session=${sessionId}: ${err.message}`);
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    async removePendingPrompt(sessionId, itemId, deadline) {
+        try {
+            return await this.client.removeQueuedPrompt(sessionId, itemId, {
+                timeoutMs: this.stopProbeTimeout(deadline),
+            });
+        }
+        catch (err) {
+            getLogger().warn(`[dsh] stop withdraw failed session=${sessionId}: ${err.message}`);
+            return false;
+        }
+    }
+    /** One cancel attempt, then one retry (the request is idempotent when idle). */
+    async cancelWithRetry(sessionId, deadline) {
+        if (await this.cancelOnce(sessionId, deadline))
+            return true;
+        if (!(await this.sleepWithin(deadline, 150)))
+            return false;
+        return this.cancelOnce(sessionId, deadline);
+    }
+    async cancelOnce(sessionId, deadline) {
+        const timeoutMs = Math.max(1, Math.min(CANCEL_TIMEOUT_MS, deadline - Date.now()));
+        try {
+            await this.client.unary('session/cancel', { sessionId }, { timeoutMs });
+            return true;
+        }
+        catch (err) {
+            getLogger().warn(`[dsh] session/cancel failed for ${sessionId}: ${err.message}`);
+            return false;
+        }
+    }
+    /** Poll the host until the session reports idle, or the budget runs out. */
+    async waitForClosed(sessionId, deadline) {
+        let state = 'unknown';
+        for (let attempt = 0; attempt < STOP_VERIFY_ATTEMPTS; attempt++) {
+            if (attempt > 0 && !(await this.sleepWithin(deadline, STOP_VERIFY_DELAY_MS)))
+                break;
+            state = await this.client.openTurnState(sessionId, {
+                timeoutMs: this.stopProbeTimeout(deadline),
+            });
+            if (state === 'closed')
+                return 'closed';
+        }
+        return state;
+    }
+    /** Sleep, but never past the stop deadline. Returns false when out of budget. */
+    async sleepWithin(deadline, ms) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            return false;
+        await delay(Math.min(ms, remaining));
+        return Date.now() < deadline;
+    }
+    stopProbeTimeout(deadline) {
+        return Math.max(1, Math.min(STOP_PROBE_TIMEOUT_MS, deadline - Date.now()));
     }
     killOrphan() {
         // No local subprocess for DSH — nothing to reap.
     }
+    /**
+     * 退出前取消在途 turn。
+     *
+     * turn 跑在常驻共享的 `dsh web` host 里，不在本进程的子进程树上；所以
+     * "杀自己的子进程"这套退出清理对它无效，桥接一退出，turn 继续无人接收地跑
+     * （2026-10-19 实测：一个孤儿 turn 在桥接死后又跑了 2h21m / 345 个 step）。
+     * 这里复用进程级退出分发器，用同步 curl 发一次 `session/cancel`。
+     */
     registerExitHandlers() {
-        // No local subprocess for DSH — nothing to register.
+        registerExitCleanup(this);
     }
     unregisterExitHandlers() {
-        // No-op (see registerExitHandlers).
+        unregisterExitCleanup(this);
+    }
+    /** Exit dispatcher hook: cancel the in-flight turn, bounded and never throwing. */
+    cleanupOnExit() {
+        if (!this.running || !this.activeSessionId)
+            return;
+        const sessionId = this.activeSessionId;
+        try {
+            this.cancelOnExit({ baseUrl: this.client.baseUrl, sessionId });
+            getLogger().info(`[dsh] exit-cancel sent session=${sessionId}`);
+        }
+        catch (err) {
+            getLogger().warn(`[dsh] exit-cancel failed session=${sessionId}: ${err.message}`);
+        }
     }
 }
 //# sourceMappingURL=runner.js.map

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

@@ -12,7 +12,7 @@
  *       completed → success; aborted/interrupted → interrupted;
  *       blocked/error/max-tokens → error (errorMessage carries the reason)
  *
- * Token accounting (ccusage 口径, AGENTS.md §9.21): DSH emits ONE usage per model
+ * Token accounting (ccusage 口径): DSH emits ONE usage per model
  * call (per step) — a tool-looping turn has several `assistant/message` events.
  * The result event therefore carries **the sum of the turn's samplings**, not the
  * last one (codex `token_count` has the same shape). `lastUsage` is kept only as