lark-remote 0.5.6 → 0.5.8

package/dist/router/order-exec-dispatch.js

@@ -1,3 +1,4 @@
+import { ORDER_NOT_FOUND_TEXT } from '../order/index.js';
 /**
  * Dispatch an `order.exec` card action as an equivalent queued user message
  * (Plan A): resolve the order text at the enqueue boundary, then enqueue it
@@ -20,7 +21,7 @@ export async function dispatchOrderExecForQueue(args) {
     }
     const resolved = router.resolveOrderExecForQueue(orderId);
     if (!resolved) {
-        await bridge.sendResult({ text: '指令不存在或已被删除' }, ctx);
+        await bridge.sendResult({ text: ORDER_NOT_FOUND_TEXT }, ctx);
         return 'not-found';
     }
     // Step4/入队时刻快照 agent+session，随任务闭包带到执行时刻，

package/dist/runner/claude/session.d.ts

@@ -147,7 +147,7 @@ export declare class ClaudeSession extends SpawningRunner {
     private consumeTurn;
     /**
      * 构造进程退出且无终态 result 时的统一错误结果（对齐原 SpawningRunner
-     * buildResultEvent 语义，含 §4.4 win32 command-not-found 双条件定性）。
+     * buildResultEvent 语义，含 win32 command-not-found 的双条件定性）。
      */
     private buildStreamEndedError;
     private wakeWaiters;

package/dist/runner/claude/session.js

@@ -306,7 +306,7 @@ export class ClaudeSession extends SpawningRunner {
         this.cwd = opts.cwd;
         this.autoApprove = false;
         this.pendingToolInputs.clear();
-        // §4.4 win32 嗅探嫌疑标记每次 spawn 重置（spawnChild 置位，收尾双条件消费）。
+        // win32 的 command-not-found 嫌疑标记每次 spawn 重置（spawnChild 置位，收尾双条件消费）。
         this.commandNotFoundSeen = false;
         // 每次 run 独立：上次 run 会话内跟踪到的计划文件不得泄漏到本次
         // （否则本次 ExitPlanMode 无 plan/planFilePath 时 resolvePlanContent
@@ -422,7 +422,7 @@ export class ClaudeSession extends SpawningRunner {
     }
     /**
      * 构造进程退出且无终态 result 时的统一错误结果（对齐原 SpawningRunner
-     * buildResultEvent 语义，含 §4.4 win32 command-not-found 双条件定性）。
+     * buildResultEvent 语义，含 win32 command-not-found 的双条件定性）。
      */
     async buildStreamEndedError() {
         // 进程已死但 proc 'close' 事件可能略晚于 stdout 关闭：等退出登记拿可靠
@@ -438,7 +438,7 @@ export class ClaudeSession extends SpawningRunner {
             errorMessage = `${this.binary} killed by signal ${exited.signal}${stderrTail ? `: ${stderrTail}` : ''}`;
         }
         else if (exited.code !== null && exited.code !== 0) {
-            // §4.4 双条件定性：本分支已保证「用户未停 + signal 为 null + 非零退出」，
+            // 双条件定性：本分支已保证「用户未停 + signal 为 null + 非零退出」，
             // 这里只补嗅探嫌疑标记这第二个条件。
             const commandNotFound = this.commandNotFoundSeen;
             if (commandNotFound) {

package/dist/runner/common/defaults.d.ts

@@ -0,0 +1,2 @@
+/** 默认单请求超时（JSON-RPC 与 DSH HTTP client 共用）。 */
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 60000;

package/dist/runner/common/defaults.js

@@ -0,0 +1,3 @@
+/** 默认单请求超时（JSON-RPC 与 DSH HTTP client 共用）。 */
+export const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+//# sourceMappingURL=defaults.js.map

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

@@ -17,8 +17,8 @@ import { JsonlRpcTransport } from './transport.js';
 import { JsonRpcClient } from './client.js';
 import { getLogger } from '../../../logger/index.js';
 import { agentStopperRegistry, } from '../../../platform/agent-stopper.js';
+import { DEFAULT_REQUEST_TIMEOUT_MS } from '../defaults.js';
 const DEFAULT_IDLE_TTL_MS = 30 * 60 * 1000; // 30 minutes
-const DEFAULT_REQUEST_TIMEOUT_MS = 60_000; // 60 seconds
 /** acquire() 的轮次上限：防止 slot 被持续释放时无限重建连接。 */
 const MAX_ACQUIRE_ATTEMPTS = 5;
 export class ConnectionManager {

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

@@ -30,7 +30,7 @@ export declare class JsonlRpcTransport {
     /** JSON lines buffered while stdin is under backpressure (bounded by callers). */
     private writeQueue;
     private flushing;
-    /** §4.4 win32 嗅探嫌疑标记（双条件定性见下方 onExit）。 */
+    /** win32 嗅探嫌疑标记（双条件定性见下方 onExit）。 */
     private commandNotFoundSeen;
     constructor(opts: {
         binary: string;

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

@@ -34,7 +34,7 @@ export class JsonlRpcTransport {
     /** JSON lines buffered while stdin is under backpressure (bounded by callers). */
     writeQueue = [];
     flushing = false;
-    /** §4.4 win32 嗅探嫌疑标记（双条件定性见下方 onExit）。 */
+    /** win32 嗅探嫌疑标记（双条件定性见下方 onExit）。 */
     commandNotFoundSeen = false;
     constructor(opts) {
         this.binary = opts.binary;
@@ -106,7 +106,7 @@ export class JsonlRpcTransport {
             const text = chunk.toString('utf-8');
             stderrBuf = (stderrBuf + text).slice(-MAX_STDERR_BYTES);
             getLogger().debug(`[jsonrpc-transport] stderr: ${text.trimEnd()}`);
-            // §4.4 win32 command-not-found 嗅探：命中只记嫌疑标记，不立即杀——
+            // win32 command-not-found 嗅探：命中只记嫌疑标记，不立即杀——
             // agent 正常输出可能引用该错误文本（调试 Windows 报错场景），见行即杀
             // 会误杀 run；定性由 onExit 的「标记 + 非零退出」双条件完成，真挂起由
             // 上层超时兜底
@@ -169,7 +169,7 @@ export class JsonlRpcTransport {
                     // ignore trailing incomplete line
                 }
             }
-            // §4.4 双条件定性：嫌疑标记 + 非零正常退出 → command-not-found。
+            // 双条件定性：嫌疑标记 + 非零正常退出 → command-not-found。
             // reason 仅供日志/诊断，消费方不解析该字符串（baseOnClose 无参）。
             let reason = signal ? `signal:${signal}` : `exit:${code}`;
             if (this.commandNotFoundSeen && signal === null && code !== null && code !== 0) {

package/dist/runner/common/spawning-runner.d.ts

@@ -84,7 +84,7 @@ export declare abstract class SpawningRunner {
      */
     protected stoppedByUser: boolean;
     /**
-     * §4.4 win32 command-not-found 嗅探嫌疑标记：stderr 命中特征行时置位，
+     * win32 command-not-found 嗅探嫌疑标记：stderr 命中特征行时置位，
      * 但**不**立即杀进程——agent 正常输出可能引用该错误文本（调试 Windows
      * 报错场景），见行即杀会误杀 run。定性走双条件：子类收尾时「标记在 +
      * 非零退出」才判 command-not-found；真挂起由既有 grace/超时兜底。

package/dist/runner/common/spawning-runner.js

@@ -127,7 +127,7 @@ export class SpawningRunner {
      */
     stoppedByUser = false;
     /**
-     * §4.4 win32 command-not-found 嗅探嫌疑标记：stderr 命中特征行时置位，
+     * win32 command-not-found 嗅探嫌疑标记：stderr 命中特征行时置位，
      * 但**不**立即杀进程——agent 正常输出可能引用该错误文本（调试 Windows
      * 报错场景），见行即杀会误杀 run。定性走双条件：子类收尾时「标记在 +
      * 非零退出」才判 command-not-found；真挂起由既有 grace/超时兜底。
@@ -253,7 +253,7 @@ export class SpawningRunner {
             const text = chunk.toString('utf-8').trim();
             if (text) {
                 this.spawnStderr = (this.spawnStderr + '\n' + text).trim().slice(-STDERR_TAIL_BYTES);
-                // §4.4 win32 command-not-found 嗅探：经 cmd 垫片启动失败不是 spawn 的
+                // win32 command-not-found 嗅探：经 cmd 垫片启动失败不是 spawn 的
                 // ENOENT，而是 stderr 的 "is not recognized..." 行。命中只记嫌疑标记
                 // （双条件之一），不立即杀——定性由子类收尾的「标记 + 非零退出」
                 // 双条件完成；子进程真挂起由既有 grace/超时看门狗兜底。

package/dist/runner/dsh/auth.js

@@ -13,6 +13,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import YAML from 'yaml';
+import { isWin32 } from '../../platform/select.js';
 /** Credential record that owns the browser-cookie signing secret. */
 export const DSH_BROWSER_CREDENTIAL_KEY = 'client-connection/browser-session';
 /** Short lifetime keeps every request safely inside DSH's configurable max age. */
@@ -40,7 +41,7 @@ function assertOwnerOnly(file, stats) {
         throw new Error(`DSH credentials file ${file} is not a regular file`);
     }
     // Windows has no POSIX mode bits; DSH itself skips the same check there.
-    if (process.platform === 'win32')
+    if (isWin32())
         return;
     if ((stats.mode & 0o077) !== 0) {
         throw new Error(`DSH credentials file ${file} is readable beyond its owner ` +

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

@@ -19,7 +19,7 @@
  * `sessionEvents()` adds per-session filtering, reconnect + follow-snapshot
  * replay, and seq-based dedup.
  */
-import type { DshApprovalStreamItem, DshCommandResult, DshModelCatalogValue, DshModelSelection, DshPermissionCatalogValue, DshPresetListValue, DshQuestion, DshRemoteEventOutcome, DshSessionPageValue, DshStreamItem, DshTokenUsage } from './types.js';
+import type { DshApprovalStreamItem, DshCommandResult, DshModelCatalogValue, DshModelSelection, DshOpenTurnState, DshPermissionCatalogValue, DshJobView, DshPresetListValue, DshProjectionItem, DshProjectionSnapshot, DshQuestion, DshRemoteEventOutcome, DshSessionPageValue, DshStreamItem, DshTokenUsage } from './types.js';
 interface WebSocketMessageEvent {
     data: unknown;
 }
@@ -182,6 +182,68 @@ export declare class DshClient {
         signal?: AbortSignal;
         timeoutMs?: number;
     }): Promise<DshSessionPageValue>;
+    /**
+     * Read the session's exact projection values.
+     *
+     * Returns `null` when the host has no projections for the session (e.g. it was
+     * deleted). A failed unary still throws — callers that only need a
+     * best-effort probe catch it themselves.
+     */
+    projectionSnapshot(sessionId: string, opts?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<DshProjectionSnapshot | null>;
+    /**
+     * Find this run's prompt if it is still sitting in the host's inbox.
+     *
+     * DSH 的 prompt 受理后先进入 inbox，被 turn 取走（claim）就不再出现；停止
+     * 时用它区分“还没开始 → 可以从队列里撤掉”和“已经在跑 → 只能 cancel”。
+     * `source.rpcId` 是 `session/prompt` 的 requestId，归属不会认错。
+     */
+    findPendingPrompt(sessionId: string, requestId: string, opts?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<string | undefined>;
+    /**
+     * Remove one not-yet-claimed inbox occurrence (`session/updateQueue`).
+     *
+     * @returns true when the host removed it; false when it was claimed between
+     *   the projection read and this call (`session/queue-item-not-found`).
+     */
+    removeQueuedPrompt(sessionId: string, itemId: string, opts?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<boolean>;
+    /**
+     * Whether the session still has a running turn.
+     *
+     * 主信号是 `session/list` 的 `running` 字段：服务端权威（会话列表页"运行中"
+     * 用的就是它），一次 unary，投票不受桥接进程内存影响。名单里没有该会话或
+     * 服务端不返回 `running` 时，回退到事件探测（{@link probeOpenTurnByEvents}），
+     * 两者都判不出来就返回 false（fail open，仍由 DSH 自己拒绝）。
+     */
+    hasOpenTurn(sessionId: string, opts?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<boolean>;
+    /**
+     * Tri-state version of {@link hasOpenTurn}.
+     *
+     * Stop verification must distinguish "the host says idle" from "the probe
+     * could not tell" — reporting `closed` on a failed probe would let a still
+     * running turn be reported as stopped. `unknown` is the honest answer there.
+     */
+    openTurnState(sessionId: string, opts?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<DshOpenTurnState>;
+    /**
+     * Fallback probe: the newest durable event's type tells whether a turn is open.
+     *
+     * 只在拿不到 `running` 时用。名单刻意保守——`job/*`（后台任务可在 turn 外
+     * 结算）、`user/message`、`turn/end` 都不算，判不出来就报告 `unknown`。
+     */
+    private probeOpenTurnByEvents;
     /**
      * One logical stream over `/api/remote.mux`. The WebSocket must carry the
      * same auth cookie as unary calls. Ends on the server's `end` frame, socket
@@ -203,9 +265,44 @@ export declare class DshClient {
      * Per-session subscription: yields session events, assistant stream chunks
      * and approval notices for `sessionId`, auto-reconnecting on stream
      * drop/error and replaying the follow snapshot (dedup by seq). Terminates on
-     * turn/end or `signal` abort.
+     * the run's own turn/end or `signal` abort.
+     *
+     * `promptRequestId` binds the stream to this run's prompt. `mode:'queue'`
+     * prompts are accepted while the agent is mid-turn and start a turn only
+     * later, so the first `turn/end` after `initialSeq` can belong to that OTHER
+     * turn. Everything recorded before the prompt's own durable `user/message`
+     * (whose source echoes the request id as `rpcId`) is foreign: dropping it
+     * keeps the card "running" until this run's turn actually finishes.
+     */
+    sessionEvents(sessionId: string, signal: AbortSignal, initialSeq?: number, promptRequestId?: string): AsyncGenerator<DshStreamItem>;
+    /**
+     * Host-wide live projection stream (`session/control`).
+     *
+     * 一份 baseline（当前所有活跃 session 的完整投影值）+ 之后每个投影的变化帧。
+     * 调用方按 sessionId 过滤：这是 DSH 上唯一"服务端变一次推一次"的通道，
+     * 不需要轮询 `session/projections`。
+     *
+     * 失败必须降级为"没有状态条"，不能影响 run：控制流是增强通道，断了运行
+     * 照常（异常在此吞掉并记日志，不向 merge 抛）。
+     */
+    controlFrames(signal: AbortSignal): AsyncGenerator<DshProjectionItem>;
+    /**
+     * One session's current background-job roster.
+     *
+     * `job/list` 是流（生命周期变化时推整份名单），但"此刻有哪些任务在跑"只需
+     * 要第一帧：文档明确首帧就是当前真相（whole-set replacement）。取到即断开，
+     * 不长期持有连接——任务列表只用于收尾时的一句话与停止按钮。
+     *
+     * 失败返回 undefined（与"没有任务"区分）：拿不到就别在卡片上写"0 个后台任务"。
      */
-    sessionEvents(sessionId: string, signal: AbortSignal, initialSeq?: number): AsyncGenerator<DshStreamItem>;
+    jobRows(sessionId: string, opts?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<DshJobView[] | undefined>;
+    /** Kill one background job on the user's behalf (`job/kill`). */
+    jobKill(sessionId: string, jobId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<boolean>;
     /** Extract TokenUsage from an assistant/message data payload (absent → undefined). */
     static usageOf(data: Record<string, unknown>): DshTokenUsage | undefined;
 }

package/dist/runner/dsh/client.js

@@ -23,6 +23,7 @@ import { randomUUID } from 'node:crypto';
 import WebSocket from 'ws';
 import { getLogger } from '../../logger/index.js';
 import { DSH_COOKIE_LIFETIME_MS, isDshCredentialsNotFound, mintDshBrowserCookie, readDshBrowserSecret, resolveDshCredentialsFile, } from './auth.js';
+import { DEFAULT_REQUEST_TIMEOUT_MS } from '../common/defaults.js';
 function defaultWebSocketFactory(url, options) {
     const socket = new WebSocket(url, {
         ...(options?.headers ? { headers: options.headers } : {}),
@@ -52,8 +53,59 @@ function isDshAuthError(error) {
 const RECONNECT_BACKOFF_MS = 200;
 /** Follow snapshot budget. `session/follow` also stays live after the snapshot. */
 const FOLLOW_MAX_MESSAGES = 200;
-/** Default unary timeout: long prompts are unbounded on the server side. */
-const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+/**
+ * 只在 turn 内部落盘的会话事件类型：看到它们说明 turn 还没结束。
+ * 名单刻意保守——`user/message`（压缩 checkpoint 会以 turn:null 落盘）、
+ * `job/*`（后台任务可在 turn 外结算）、`turn/end`、`command/*` 等都不算，
+ * 判不出来时宁可放行，让 DSH 自己拒绝。
+ */
+const IN_TURN_EVENT_TYPES = new Set([
+    'step/start',
+    'step/end',
+    'assistant/chunk',
+    'assistant/message',
+    'assistant/attempt',
+    'tool/call',
+    'tool/result',
+    'request/header',
+]);
+/**
+ * Parse the `inbox` projection into the pending items this repo consumes.
+ *
+ * The projection's items are wire data (typed `{}` by the server schema); keep
+ * this defensive: one malformed row must not hide the others.
+ */
+function inboxItemsOf(values) {
+    const inbox = values.inbox;
+    if (!inbox || typeof inbox !== 'object' || Array.isArray(inbox))
+        return [];
+    const out = [];
+    for (const target of ['next-turn', 'next-step']) {
+        const list = inbox[target];
+        if (!Array.isArray(list))
+            continue;
+        for (const raw of list) {
+            if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+                continue;
+            const item = raw;
+            if (typeof item.id !== 'string' || item.id.length === 0)
+                continue;
+            const source = item.source;
+            const parsedSource = source && typeof source === 'object' && !Array.isArray(source)
+                ? {
+                    ...(typeof source.kind === 'string'
+                        ? { kind: source.kind }
+                        : {}),
+                    ...(typeof source.rpcId === 'string'
+                        ? { rpcId: source.rpcId }
+                        : {}),
+                }
+                : undefined;
+            out.push({ id: item.id, ...(parsedSource ? { source: parsedSource } : {}) });
+        }
+    }
+    return out;
+}
 /** Extract the `token` query parameter from a pasted `dsh web` URL. */
 export function extractDshToken(raw) {
     const value = (raw ?? '').trim();
@@ -85,6 +137,9 @@ const DSH_ARGS_KEY = {
     'session/projections': 'request',
     'session/page': 'request',
     'session/follow': 'request',
+    'session/updateQueue': 'request',
+    'job/list': 'request',
+    'job/kill': 'request',
     'session/modelCatalog': null,
     'agentPresets/list': null,
     'permissionPresets/catalog': null,
@@ -364,7 +419,7 @@ export class DshClient {
      * `session/prompt` so a follow snapshot can skip already-completed turns.
      */
     async latestEventSeq(sessionId, opts) {
-        const value = (await this.unary('session/projections', { sessionId }, opts));
+        const value = await this.projectionSnapshot(sessionId, opts);
         return typeof value?.asOfSeq === 'number' ? value.asOfSeq : -1;
     }
     /** Read one cold history page. `throughSeq` normally comes from
@@ -376,6 +431,110 @@ export class DshClient {
             maxMessages,
         }, opts));
     }
+    /**
+     * Read the session's exact projection values.
+     *
+     * Returns `null` when the host has no projections for the session (e.g. it was
+     * deleted). A failed unary still throws — callers that only need a
+     * best-effort probe catch it themselves.
+     */
+    async projectionSnapshot(sessionId, opts) {
+        const value = (await this.unary('session/projections', { sessionId }, opts));
+        if (!value || typeof value !== 'object')
+            return null;
+        return {
+            ...(typeof value.asOfSeq === 'number' ? { asOfSeq: value.asOfSeq } : {}),
+            values: value.values && typeof value.values === 'object' && !Array.isArray(value.values)
+                ? value.values
+                : {},
+        };
+    }
+    /**
+     * Find this run's prompt if it is still sitting in the host's inbox.
+     *
+     * DSH 的 prompt 受理后先进入 inbox，被 turn 取走（claim）就不再出现；停止
+     * 时用它区分“还没开始 → 可以从队列里撤掉”和“已经在跑 → 只能 cancel”。
+     * `source.rpcId` 是 `session/prompt` 的 requestId，归属不会认错。
+     */
+    async findPendingPrompt(sessionId, requestId, opts) {
+        const snapshot = await this.projectionSnapshot(sessionId, opts);
+        if (!snapshot)
+            return undefined;
+        return inboxItemsOf(snapshot.values).find((item) => item.source?.kind === 'user' && item.source.rpcId === requestId)?.id;
+    }
+    /**
+     * Remove one not-yet-claimed inbox occurrence (`session/updateQueue`).
+     *
+     * @returns true when the host removed it; false when it was claimed between
+     *   the projection read and this call (`session/queue-item-not-found`).
+     */
+    async removeQueuedPrompt(sessionId, itemId, opts) {
+        try {
+            await this.unary('session/updateQueue', { sessionId, itemId, action: { kind: 'remove' } }, opts);
+            return true;
+        }
+        catch (err) {
+            if (err instanceof DshError && err.code === 'session/queue-item-not-found')
+                return false;
+            throw err;
+        }
+    }
+    /**
+     * Whether the session still has a running turn.
+     *
+     * 主信号是 `session/list` 的 `running` 字段：服务端权威（会话列表页"运行中"
+     * 用的就是它），一次 unary，投票不受桥接进程内存影响。名单里没有该会话或
+     * 服务端不返回 `running` 时，回退到事件探测（{@link probeOpenTurnByEvents}），
+     * 两者都判不出来就返回 false（fail open，仍由 DSH 自己拒绝）。
+     */
+    async hasOpenTurn(sessionId, opts) {
+        return (await this.openTurnState(sessionId, opts)) === 'open';
+    }
+    /**
+     * Tri-state version of {@link hasOpenTurn}.
+     *
+     * Stop verification must distinguish "the host says idle" from "the probe
+     * could not tell" — reporting `closed` on a failed probe would let a still
+     * running turn be reported as stopped. `unknown` is the honest answer there.
+     */
+    async openTurnState(sessionId, opts) {
+        try {
+            const list = (await this.unary('session/list', {}, opts));
+            const row = list?.items?.find((item) => String(item.sessionId) === sessionId);
+            if (row && typeof row.running === 'boolean')
+                return row.running ? 'open' : 'closed';
+        }
+        catch (err) {
+            getLogger().warn(`[dsh] open-turn probe: session/list failed for ${sessionId}: ${err.message}`);
+        }
+        return this.probeOpenTurnByEvents(sessionId, opts);
+    }
+    /**
+     * Fallback probe: the newest durable event's type tells whether a turn is open.
+     *
+     * 只在拿不到 `running` 时用。名单刻意保守——`job/*`（后台任务可在 turn 外
+     * 结算）、`user/message`、`turn/end` 都不算，判不出来就报告 `unknown`。
+     */
+    async probeOpenTurnByEvents(sessionId, opts) {
+        try {
+            // A missing projection snapshot is not "idle": the host simply cannot
+            // tell us. Only a known watermark with no events (or a closed tail) is
+            // evidence that no turn is open.
+            const snapshot = await this.projectionSnapshot(sessionId, opts);
+            if (!snapshot || typeof snapshot.asOfSeq !== 'number' || snapshot.asOfSeq < 0) {
+                return 'unknown';
+            }
+            const value = await this.page(sessionId, snapshot.asOfSeq, 1, opts);
+            const last = value.records.at(-1)?.event;
+            if (last === undefined)
+                return 'closed';
+            return last.type === 'turn/start' || IN_TURN_EVENT_TYPES.has(last.type) ? 'open' : 'closed';
+        }
+        catch (err) {
+            getLogger().warn(`[dsh] open-turn probe failed for session ${sessionId}: ${err.message}`);
+            return 'unknown';
+        }
+    }
     /**
      * One logical stream over `/api/remote.mux`. The WebSocket must carry the
      * same auth cookie as unary calls. Ends on the server's `end` frame, socket
@@ -675,10 +834,41 @@ export class DshClient {
      * Per-session subscription: yields session events, assistant stream chunks
      * and approval notices for `sessionId`, auto-reconnecting on stream
      * drop/error and replaying the follow snapshot (dedup by seq). Terminates on
-     * turn/end or `signal` abort.
+     * the run's own turn/end or `signal` abort.
+     *
+     * `promptRequestId` binds the stream to this run's prompt. `mode:'queue'`
+     * prompts are accepted while the agent is mid-turn and start a turn only
+     * later, so the first `turn/end` after `initialSeq` can belong to that OTHER
+     * turn. Everything recorded before the prompt's own durable `user/message`
+     * (whose source echoes the request id as `rpcId`) is foreign: dropping it
+     * keeps the card "running" until this run's turn actually finishes.
      */
-    async *sessionEvents(sessionId, signal, initialSeq = -1) {
-        const state = { lastSeq: initialSeq };
+    async *sessionEvents(sessionId, signal, initialSeq = -1, promptRequestId) {
+        const state = { lastSeq: initialSeq, owns: promptRequestId === undefined };
+        let foreignTailReported = false;
+        /** Mark this run as the owner once its own prompt message is recorded. */
+        const ownsEvent = (ev) => {
+            if (state.owns)
+                return true;
+            if (ev.type !== 'user/message')
+                return false;
+            const source = ev.data
+                ?.source;
+            if (source?.kind === 'user' && source.rpcId === promptRequestId) {
+                state.owns = true;
+                return true;
+            }
+            return false;
+        };
+        const admit = (ev) => {
+            if (ownsEvent(ev))
+                return true;
+            if (!foreignTailReported) {
+                foreignTailReported = true;
+                getLogger().info(`[dsh] prompt ${promptRequestId ?? '(none)'} is queued behind a running turn for session ${sessionId}; holding the card open until its own turn starts`);
+            }
+            return false;
+        };
         let authRefreshAttempted = false;
         while (!signal.aborted) {
             try {
@@ -692,6 +882,8 @@ export class DshClient {
                             if (!ev || ev.seq <= state.lastSeq)
                                 continue;
                             state.lastSeq = ev.seq;
+                            if (!admit(ev))
+                                continue;
                             const item = this.eventItem(sessionId, ev);
                             if (item)
                                 yield item;
@@ -705,6 +897,8 @@ export class DshClient {
                         if (ev.seq <= state.lastSeq)
                             continue;
                         state.lastSeq = ev.seq;
+                        if (!admit(ev))
+                            continue;
                         const item = this.eventItem(sessionId, ev);
                         if (item)
                             yield item;
@@ -713,6 +907,9 @@ export class DshClient {
                         continue;
                     }
                     if (frame.type === 'assistant-stream') {
+                        // Mid-turn deltas of the turn this prompt is queued behind.
+                        if (!state.owns)
+                            continue;
                         yield { kind: 'assistant-stream', sessionId, frame: frame.frame };
                     }
                 }
@@ -739,6 +936,93 @@ export class DshClient {
             await new Promise((resolve) => setTimeout(resolve, RECONNECT_BACKOFF_MS));
         }
     }
+    /**
+     * Host-wide live projection stream (`session/control`).
+     *
+     * 一份 baseline（当前所有活跃 session 的完整投影值）+ 之后每个投影的变化帧。
+     * 调用方按 sessionId 过滤：这是 DSH 上唯一"服务端变一次推一次"的通道，
+     * 不需要轮询 `session/projections`。
+     *
+     * 失败必须降级为"没有状态条"，不能影响 run：控制流是增强通道，断了运行
+     * 照常（异常在此吞掉并记日志，不向 merge 抛）。
+     */
+    async *controlFrames(signal) {
+        try {
+            // mux 的 payload 与 unary 同信封：`{args:{...}}`。control 无参数，故空 args；
+            // 少了这层包装网关直接拒绝（live 实测 0 帧，测试用假服务端不会发现）。
+            for await (const raw of this.muxStream('session/control', { args: {} }, signal)) {
+                const frame = raw;
+                if (!frame || typeof frame !== 'object')
+                    continue;
+                if (frame.type === 'baseline') {
+                    const projections = frame.value?.projections ??
+                        {};
+                    for (const [sessionId, snapshot] of Object.entries(projections)) {
+                        const values = snapshot?.values ?? {};
+                        for (const [key, value] of Object.entries(values)) {
+                            yield { kind: 'projection', sessionId, key, value };
+                        }
+                    }
+                    continue;
+                }
+                if (frame.type === 'projection' && frame.sessionId && frame.key) {
+                    yield {
+                        kind: 'projection',
+                        sessionId: frame.sessionId,
+                        key: frame.key,
+                        value: frame.value,
+                    };
+                }
+            }
+        }
+        catch (err) {
+            if (signal.aborted)
+                return;
+            getLogger().warn(`[dsh] session/control stream unavailable (${err.message}); run continues without live status`);
+        }
+    }
+    /**
+     * One session's current background-job roster.
+     *
+     * `job/list` 是流（生命周期变化时推整份名单），但"此刻有哪些任务在跑"只需
+     * 要第一帧：文档明确首帧就是当前真相（whole-set replacement）。取到即断开，
+     * 不长期持有连接——任务列表只用于收尾时的一句话与停止按钮。
+     *
+     * 失败返回 undefined（与"没有任务"区分）：拿不到就别在卡片上写"0 个后台任务"。
+     */
+    async jobRows(sessionId, opts = {}) {
+        const timer = new AbortController();
+        const timeout = setTimeout(() => timer.abort(), opts.timeoutMs ?? 2_000);
+        const signal = opts.signal ? AbortSignal.any([opts.signal, timer.signal]) : timer.signal;
+        try {
+            for await (const frame of this.muxStream('job/list', { args: dshArgs('job/list', { sessionId }) }, signal)) {
+                const rows = frame;
+                if (rows?.type === 'rows') {
+                    return Array.isArray(rows.jobs) ? rows.jobs : [];
+                }
+            }
+            return undefined;
+        }
+        catch (err) {
+            getLogger().debug(`[dsh] job/list unavailable: ${err.message}`);
+            return undefined;
+        }
+        finally {
+            clearTimeout(timeout);
+            timer.abort();
+        }
+    }
+    /** Kill one background job on the user's behalf (`job/kill`). */
+    async jobKill(sessionId, jobId, opts = {}) {
+        try {
+            await this.unary('job/kill', { sessionId, jobId }, opts);
+            return true;
+        }
+        catch (err) {
+            getLogger().warn(`[dsh] job/kill failed job=${jobId}: ${err.message}`);
+            return false;
+        }
+    }
     /** Extract TokenUsage from an assistant/message data payload (absent → undefined). */
     static usageOf(data) {
         return data.usage ?? undefined;