lark-remote 0.5.5 → 0.5.7

package/dist/runner/dsh/runner.js

@@ -6,17 +6,25 @@
  * 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.
- * If `$events` is unavailable, the runner falls back to the Web UI prompt.
+ * `ask_user_question` prompts arrive only as a `user-questions/request`
+ * waterfall (no durable event); they are rendered as a `kind:'question'`
+ * approval on the same card. If `$events` is unavailable, the runner falls
+ * back to the Web UI prompt.
  */
 import { DshClient, DshError, newPromptRequestId } from './client.js';
 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.
@@ -24,8 +32,132 @@ import { getLogger } from '../../logger/index.js';
 const DSH_MODEL_PROVIDER = 'deepseek-official';
 /** DSH 内建手动压缩命令（dsh-command-compact，无参数、仅空闲可执行）。 */
 const DSH_COMPACT_COMMAND = '/compact';
-/** Budget for the fire-and-forget session/cancel on stop (never block /stop). */
+/**
+ * 飞书提问卡的有效窗口。
+ *
+ * DSH 的 legacy `ask_user_question` 会无限等待（`timed:false`），Web UI 那侧
+ * 也一直在等。飞书卡超时后只把这一路的应答权交回（outcome `next`），不取消
+ * turn，所以窗口比审批默认的 5 分钟给得宽：用户通常要先读完上一条长回答。
+ * 超时后问题仍可在 DSH Web UI 回答；之后由 idle 看门狗兜底（默认 15 分钟
+ * 静默，见 `config.idle.watchdogMinutes`，等待提问期间暂停计时）。
+ */
+const DSH_QUESTION_TIMEOUT_MS = 30 * 60 * 1000;
+/**
+ * 卡片上实际生效的多选语义：无选项的 multiSelect 没有可勾内容，共享渲染层把它
+ * 当自由文本题，coordinator 的 answerCustom 又拒绝 multiSelect——所以按单选处理，
+ * 视图与答案编码必须用同一个判定，否则会编码出错答案。
+ */
+function isCardMultiSelect(question) {
+    return question.multiSelect === true && (question.options?.length ?? 0) > 0;
+}
+/**
+ * 把 coordinator 回传的「问题文本 → 答案」映射成 DSH 的 `{id, selected,
+ * custom}` 批次。
+ *
+ * 契约见 `UserQuestion`：答案按问题文本回传；本函数按 id 回编。单选且文本
+ * 不等于任何选项 label 时，按 DSH Web UI 的语义记为自由答案（`selected: []`
+ * + `custom`）。
+ */
+function buildQuestionAnswers(questions, response) {
+    const answers = response
+        ?.answers;
+    if (!answers)
+        throw new Error('DSH 提问回答缺少 answers 载荷');
+    return questions.map((question) => {
+        const value = answers[question.question];
+        if (value === undefined)
+            throw new Error(`DSH 提问缺少答案: ${question.question}`);
+        const values = (Array.isArray(value) ? value : [value]).filter((item) => typeof item === 'string' && item.length > 0);
+        if (values.length === 0)
+            throw new Error(`DSH 提问答案为空: ${question.question}`);
+        if (isCardMultiSelect(question))
+            return { id: question.id, selected: values };
+        const selected = values[0];
+        const isOption = (question.options ?? []).some((option) => option.label === selected);
+        return isOption
+            ? { id: question.id, selected: [selected] }
+            : { id: question.id, selected: [], custom: selected };
+    });
+}
+/** 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)
@@ -62,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
@@ -74,10 +219,19 @@ export class DshRunner {
     permissionAlignedSessions = new Set();
     /** `$events` approval waterfall state for the current run. */
     approvalTracker = new DshApprovalTracker();
+    /**
+     * eventId → 待回答的 DSH `ask_user_question` waterfall。
+     *
+     * 提问没有 durable 审计事件，eventId 本身就是卡片 requestId；这里保存应答
+     * 所需的 clientId 与题面（DSH 回编按题目 id）。每轮 run 清空。
+     */
+    pendingQuestions = new Map();
     /** callId → tool call, used to render the command in the approval card. */
     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;
@@ -86,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,
@@ -94,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;
@@ -159,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
@@ -212,7 +382,7 @@ export class DshRunner {
                 };
                 return;
             }
-            // provider/模型/推理强度对齐（§4.3）：会话首次 run 时 selectModel 一次
+            // provider/模型/推理强度对齐：会话首次 run 时 selectModel 一次
             // （该调用同时写服务端全局默认，故不重复写）；同一 session 后续 run
             // 跳过。显式配置 provider 时失败必须 fail closed：静默回退到其他
             // provider 会让用户以为切换成功，实际模型与账单都错。
@@ -271,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 事件）。
@@ -290,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;
@@ -341,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 {
@@ -356,22 +550,41 @@ 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();
         const emittedApprovals = new Set();
         this.approvalTracker.clear();
+        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;
@@ -391,7 +604,25 @@ export class DshRunner {
                     });
                     continue;
                 }
+                if (item.kind === 'question') {
+                    // 同一 waterfall 在重连后会带新的 clientId 重投：覆盖写回，卡片的
+                    // requestId（eventId）不变，coordinator 按重投语义刷新视图。
+                    this.pendingQuestions.set(item.eventId, {
+                        clientId: item.clientId,
+                        questions: item.questions,
+                    });
+                    getLogger().info(`[dsh] user question surfaced eventId=${item.eventId} questions=${item.questions.length}`);
+                    yield this.buildQuestionRequested(sessionId, item.eventId, item.questions);
+                    continue;
+                }
                 if (item.kind === 'cancelled') {
+                    // 提问与审批共用 cancel 帧：提问在别处（DSH Web UI）被回答或超时后
+                    // 也要清掉飞书卡片，否则上面还留着可点但已无 responder 的问题区。
+                    if (this.pendingQuestions.delete(item.eventId)) {
+                        getLogger().info(`[dsh] user question resolved elsewhere eventId=${item.eventId}`);
+                        yield this.approvalResolved(item.eventId);
+                        continue;
+                    }
                     const binding = this.approvalTracker.onCancelled(item.eventId);
                     if (binding)
                         yield this.approvalResolved(binding.audit.approvalId);
@@ -437,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;
@@ -448,18 +681,57 @@ 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;
                 }
             }
         }
         finally {
             streamAbort.abort();
             this.approvalTracker.clear();
+            this.pendingQuestions.clear();
             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;
@@ -482,11 +754,22 @@ export class DshRunner {
         getLogger().info(`[dsh] permission preset updated to ${settings.permissionPreset ?? '(follow default)'}; applies to the next run`);
     }
     /**
-     * Answer one DSH approval. `accept` / `decline` are the only user decisions
-     * exposed by the DSH Web UI; `cancel` stops the turn through session/cancel.
+     * Answer one DSH approval or `ask_user_question` prompt.
+     *
+     * Approvals: `accept` / `decline` are the only user decisions exposed by the
+     * DSH Web UI; `cancel` stops the turn through session/cancel.
+     *
+     * Questions: `answer` / `decline`（跳过回答）resolve the `user-questions/request`
+     * waterfall with an answer batch; `cancel`（飞书卡超时）只把这一路交回
+     * `next`，让 DSH Web UI 仍可回答，不取消 turn。
      */
     async respondApproval(requestId, response) {
         const approvalId = String(requestId);
+        const question = this.pendingQuestions.get(approvalId);
+        if (question) {
+            await this.respondQuestion(approvalId, question, response);
+            return;
+        }
         const binding = this.approvalTracker.getBinding(approvalId) ??
             (await this.approvalTracker.waitForBinding(approvalId, 2_000, this.activeAbort?.signal));
         if (!binding) {
@@ -508,6 +791,41 @@ export class DshRunner {
         this.approvalTracker.onDecided(approvalId);
         getLogger().info(`[dsh] approval responded approvalId=${approvalId} action=${String(action)} eventId=${binding.waterfall.eventId}`);
     }
+    /** Resolve one pending `ask_user_question` waterfall from a card action. */
+    async respondQuestion(eventId, pending, response) {
+        const action = response?.action;
+        let outcome;
+        if (action === 'answer') {
+            outcome = {
+                kind: 'result',
+                value: { answers: buildQuestionAnswers(pending.questions, response) },
+            };
+        }
+        else if (action === 'decline') {
+            // 「跳过回答」：与 DSH Web UI 的 skip 同语义，逐题回空 selected，
+            // 工具把这次提问当作已跳过，agent 拿到结果后继续。
+            outcome = {
+                kind: 'result',
+                value: {
+                    answers: pending.questions.map((question) => ({ id: question.id, selected: [] })),
+                },
+            };
+        }
+        else if (action === 'cancel') {
+            // 飞书卡超时/放弃：只交回这一路的应答权（outcome next）。DSH Web UI
+            // 仍是 owner Client 且持有该 waterfall，可以继续回答；没有其他 Client
+            // 时才 settle 为 next（工具报 no user-questions answerer）。
+            outcome = { kind: 'next' };
+        }
+        else {
+            throw new Error(`DSH 提问不支持审批决策: ${String(action)}`);
+        }
+        await this.client.answerRemoteEvent(pending.clientId, eventId, outcome, {
+            signal: this.activeAbort?.signal,
+        });
+        this.pendingQuestions.delete(eventId);
+        getLogger().info(`[dsh] user question responded eventId=${eventId} action=${String(action)}`);
+    }
     buildApprovalRequested(sessionId, audit, binding, cwd) {
         const call = audit.callId ? this.toolCalls.get(audit.callId) : undefined;
         const args = parseToolArguments(call?.arguments);
@@ -538,6 +856,51 @@ export class DshRunner {
             timestamp: new Date().toISOString(),
         };
     }
+    /**
+     * Render one `user-questions/request` waterfall as a `kind:'question'`
+     * approval area. The card renderer is agent-agnostic: it draws options,
+     * the Other input, multi-select submit and skip from this view alone.
+     */
+    buildQuestionRequested(sessionId, eventId, questions) {
+        const view = {
+            requestId: eventId,
+            kind: 'question',
+            note: '仅影响本次回答；若飞书提交失败，请到 DSH Web UI 处理。',
+            // 提问不是审批：超时只是把这一路交回 Web UI，卡上要如实说清还能去哪答。
+            expiredHint: '仍可在 DSH Web UI 继续回答；本卡不再接收回答。',
+            questions: questions.map((question) => {
+                const options = (question.options ?? []).map((option) => ({
+                    label: option.label,
+                    ...(option.description ? { description: option.description } : {}),
+                }));
+                return {
+                    id: question.id,
+                    question: question.question,
+                    // plan-review 提问把计划全文放在 detail；丢了就成了「看不见计划就批准」。
+                    ...(question.detail ? { detail: question.detail } : {}),
+                    ...(question.header ? { header: question.header } : {}),
+                    // 共享渲染层把「无选项」当自由文本题，而 coordinator 的 answerCustom
+                    // 拒绝 multiSelect——无选项的多选在卡片上等于无解，按单选渲染。
+                    ...(isCardMultiSelect(question) ? { multiSelect: true } : {}),
+                    options,
+                };
+            }),
+            availableDecisions: [],
+        };
+        return {
+            type: 'approval_requested',
+            requestId: eventId,
+            kind: 'question',
+            threadId: sessionId,
+            turnId: '',
+            itemId: eventId,
+            view,
+            // legacy ask_user_question 没有服务端期限；给飞书卡一个宽窗口，
+            // 超时只交回应答权、不取消 turn（见 respondQuestion）。
+            timeoutMs: DSH_QUESTION_TIMEOUT_MS,
+            timestamp: new Date().toISOString(),
+        };
+    }
     approvalResolved(requestId) {
         return {
             type: 'approval_resolved',
@@ -583,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();
@@ -593,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 默认预算会误杀；
@@ -703,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