lark-remote 0.5.6 → 0.5.7

package/dist/runner/dsh/client.js

@@ -52,6 +52,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;
+/**
+ * 只在 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;
+}
 /** Default unary timeout: long prompts are unbounded on the server side. */
 const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
 /** Extract the `token` query parameter from a pasted `dsh web` URL. */
@@ -85,6 +138,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 +420,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 +432,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 +835,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 +883,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 +898,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 +908,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 +937,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;

package/dist/runner/dsh/exit-cancel.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Synchronous `session/cancel` for the process-exit path.
+ *
+ * A DSH turn does not live in a local child process: it runs inside the shared
+ * `dsh web` host (`DshDaemon`). So the usual "kill my spawned child" exit
+ * cleanup does nothing for it, and a bridge that exits mid-turn leaves the
+ * turn running with no subscriber — an orphan turn that keeps consuming tokens
+ * and mutating the workspace invisibly (2026-10-19: one ran 2h21m / 345 steps
+ * after its bridge died).
+ *
+ * `process.on('exit')` cannot await, so this path uses the same synchronous
+ * curl transport the session reader already uses: bounded by `timeoutMs` and
+ * never throws.
+ */
+/** Upper bound on the exit-path cancel:退出不能被一个卡住的 host 拖住。 */
+export declare const EXIT_CANCEL_TIMEOUT_MS = 2000;
+export interface SyncCancelOptions {
+    baseUrl: string;
+    sessionId: string;
+    /** Configured `agents.dsh.dshHome` (selects `.credentials.yaml`). */
+    dshHome?: string;
+    /** Explicit credentials file; wins over `dshHome`/`$DSH_HOME`. */
+    credentialsFile?: string;
+    timeoutMs?: number;
+}
+/**
+ * Fire one `session/cancel` synchronously. Never throws: a failed cancel must
+ * not block the exit path or mask the real exit reason.
+ *
+ * @returns true when the host accepted the request.
+ */
+export declare function cancelSessionSync(opts: SyncCancelOptions): boolean;

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

@@ -0,0 +1,72 @@
+/**
+ * Synchronous `session/cancel` for the process-exit path.
+ *
+ * A DSH turn does not live in a local child process: it runs inside the shared
+ * `dsh web` host (`DshDaemon`). So the usual "kill my spawned child" exit
+ * cleanup does nothing for it, and a bridge that exits mid-turn leaves the
+ * turn running with no subscriber — an orphan turn that keeps consuming tokens
+ * and mutating the workspace invisibly (2026-10-19: one ran 2h21m / 345 steps
+ * after its bridge died).
+ *
+ * `process.on('exit')` cannot await, so this path uses the same synchronous
+ * curl transport the session reader already uses: bounded by `timeoutMs` and
+ * never throws.
+ */
+import { getLogger } from '../../logger/index.js';
+import { isWin32 } from '../../platform/select.js';
+import { spawnProcessSync } from '../../platform/spawn.js';
+import { DSH_COOKIE_LIFETIME_MS, mintDshBrowserCookie, readDshBrowserSecretSync, resolveDshCredentialsFile, } from './auth.js';
+/** Upper bound on the exit-path cancel:退出不能被一个卡住的 host 拖住。 */
+export const EXIT_CANCEL_TIMEOUT_MS = 2_000;
+/**
+ * Fire one `session/cancel` synchronously. Never throws: a failed cancel must
+ * not block the exit path or mask the real exit reason.
+ *
+ * @returns true when the host accepted the request.
+ */
+export function cancelSessionSync(opts) {
+    const logger = getLogger();
+    const timeoutMs = opts.timeoutMs ?? EXIT_CANCEL_TIMEOUT_MS;
+    let cookie;
+    try {
+        const file = opts.credentialsFile?.trim() || resolveDshCredentialsFile(process.env, opts.dshHome);
+        cookie = mintDshBrowserCookie(opts.baseUrl, readDshBrowserSecretSync(file), Date.now(), DSH_COOKIE_LIFETIME_MS);
+    }
+    catch (err) {
+        // 没有持久密钥就签不出 cookie；此时只能记一笔，放弃取消（启动 token 的
+        // /connect 换 cookie 是异步的，退出路径上等不起）。
+        logger.warn(`[dsh] exit-cancel skipped: cannot mint cookie (${err.message})`);
+        return false;
+    }
+    const body = JSON.stringify({
+        type: 'client-request',
+        rpcId: `rpc-exit-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        method: 'session/cancel',
+        payload: { args: { request: { sessionId: opts.sessionId } } },
+    });
+    const res = spawnProcessSync('curl', [
+        '-s',
+        '-o',
+        isWin32() ? 'NUL' : '/dev/null',
+        '-w',
+        '%{http_code}',
+        '-X',
+        'POST',
+        `${opts.baseUrl.replace(/\/$/, '')}/api/session/cancel`,
+        '-H',
+        'content-type: application/json',
+        '-H',
+        `Cookie: ${cookie}`,
+        '--max-time',
+        String(Math.max(1, Math.ceil(timeoutMs / 1000))),
+        '--data',
+        body,
+    ], { encoding: 'utf-8', timeout: timeoutMs, maxBuffer: 1024 * 1024 });
+    const status = String(res.stdout ?? '').trim();
+    const ok = status === '200';
+    if (!ok) {
+        logger.warn(`[dsh] exit-cancel failed for ${opts.sessionId}: ${res.error?.message ?? `http ${status || 'n/a'}`}`);
+    }
+    return ok;
+}
+//# sourceMappingURL=exit-cancel.js.map

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

@@ -0,0 +1,62 @@
+/**
+ * Durable record of DSH prompts that may outlive the bridge process.
+ *
+ * A DSH turn runs inside the shared `dsh web` host, not in a child process. If
+ * the bridge dies (SIGKILL, crash) the turn keeps running with no subscriber —
+ * the 2026-10-19 incident ran 2h21m / 345 steps after its bridge exited. The
+ * runner writes one entry when it submits a prompt and removes it once the run
+ * (or a verified stop) accounts for that prompt; the next startup reconciles
+ * anything left behind:
+ *
+ *  1. a still-pending prompt (identified by `source.rpcId`) is removed from the
+ *     host inbox, so it can never start a turn nobody is watching;
+ *  2. a session that still reports an open turn is reported to the owner once —
+ *     we deliberately do not cancel it, because the open turn may belong to the
+ *     DSH Web UI rather than to the dead bridge.
+ *
+ * This is a best-effort safety net, never a correctness dependency: every
+ * method swallows storage errors so a broken state file cannot block a run.
+ */
+import type { DshClient } from './client.js';
+/** Single source for the marker file shared by the runner and startup reconcile. */
+export declare function dshInflightPath(configDir: string): string;
+export interface DshInflightEntry {
+    sessionId: string;
+    promptRequestId: string;
+    baseUrl: string;
+    cwd?: string;
+    updatedAt: number;
+}
+export declare class DshInflightStore {
+    private readonly filePath;
+    constructor(filePath: string);
+    list(): DshInflightEntry[];
+    record(entry: Omit<DshInflightEntry, 'updatedAt'>): void;
+    clear(sessionId: string, promptRequestId: string): void;
+    private write;
+}
+export interface DshInflightReconcileOptions {
+    store: DshInflightStore;
+    client: Pick<DshClient, 'baseUrl' | 'findPendingPrompt' | 'removeQueuedPrompt' | 'openTurnState'>;
+    /** Owner notification; omitted when no p2p recipient is known yet. */
+    notify?: (text: string) => Promise<void>;
+    timeoutMs?: number;
+}
+export interface DshInflightReconcileResult {
+    /** Pending prompts removed from the host inbox. */
+    removed: number;
+    /** Sessions that still reported an open turn (or an unreadable state). */
+    open: number;
+    /** True when the host was unreachable; entries are kept for the next start. */
+    skipped: boolean;
+}
+/**
+ * Reconcile entries left by a previous process.
+ *
+ * Only entries for the currently configured host are considered; entries for
+ * another host are kept untouched. On a transport failure the remaining
+ * entries are left in the file so a later startup can retry.
+ */
+export declare function reconcileInflightDshRuns(opts: DshInflightReconcileOptions): Promise<DshInflightReconcileResult>;
+/** One short owner-facing notice; session ids are truncated, not paths. */
+export declare function formatInflightWarning(entries: DshInflightEntry[]): string;

package/dist/runner/dsh/inflight.js

@@ -0,0 +1,140 @@
+/**
+ * Durable record of DSH prompts that may outlive the bridge process.
+ *
+ * A DSH turn runs inside the shared `dsh web` host, not in a child process. If
+ * the bridge dies (SIGKILL, crash) the turn keeps running with no subscriber —
+ * the 2026-10-19 incident ran 2h21m / 345 steps after its bridge exited. The
+ * runner writes one entry when it submits a prompt and removes it once the run
+ * (or a verified stop) accounts for that prompt; the next startup reconciles
+ * anything left behind:
+ *
+ *  1. a still-pending prompt (identified by `source.rpcId`) is removed from the
+ *     host inbox, so it can never start a turn nobody is watching;
+ *  2. a session that still reports an open turn is reported to the owner once —
+ *     we deliberately do not cancel it, because the open turn may belong to the
+ *     DSH Web UI rather than to the dead bridge.
+ *
+ * This is a best-effort safety net, never a correctness dependency: every
+ * method swallows storage errors so a broken state file cannot block a run.
+ */
+import path from 'node:path';
+import { getLogger } from '../../logger/index.js';
+import { atomicWriteJson } from '../../persistence/atomic-write.js';
+import { loadJsonFile } from '../../persistence/load-json-file.js';
+/** Single source for the marker file shared by the runner and startup reconcile. */
+export function dshInflightPath(configDir) {
+    return path.join(configDir, 'dsh-inflight.json');
+}
+/** Keep the file bounded; stale entries are pruned by age and count. */
+const MAX_ENTRIES = 50;
+/** A turn cannot plausibly live this long; drop the record instead of nagging. */
+const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+function isEntry(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const entry = value;
+    return (typeof entry.sessionId === 'string' &&
+        entry.sessionId.length > 0 &&
+        typeof entry.promptRequestId === 'string' &&
+        entry.promptRequestId.length > 0 &&
+        typeof entry.baseUrl === 'string' &&
+        entry.baseUrl.length > 0 &&
+        typeof entry.updatedAt === 'number');
+}
+function sameEntry(left, right) {
+    return left.sessionId === right.sessionId && left.promptRequestId === right.promptRequestId;
+}
+export class DshInflightStore {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    list() {
+        const parsed = loadJsonFile(this.filePath, undefined);
+        const raw = Array.isArray(parsed?.entries) ? parsed.entries : [];
+        const now = Date.now();
+        return raw
+            .filter(isEntry)
+            .filter((entry) => now - entry.updatedAt <= MAX_AGE_MS)
+            .slice(-MAX_ENTRIES);
+    }
+    record(entry) {
+        const next = this.list().filter((existing) => !sameEntry(existing, entry));
+        next.push({ ...entry, updatedAt: Date.now() });
+        this.write(next);
+    }
+    clear(sessionId, promptRequestId) {
+        const next = this.list().filter((entry) => !sameEntry(entry, { sessionId, promptRequestId }));
+        this.write(next);
+    }
+    write(entries) {
+        try {
+            atomicWriteJson(this.filePath, { entries: entries.slice(-MAX_ENTRIES) });
+        }
+        catch (err) {
+            // The marker is a safety net; losing it must never fail the run.
+            getLogger().warn(`[dsh] inflight marker write failed: ${err.message}`);
+        }
+    }
+}
+/**
+ * Reconcile entries left by a previous process.
+ *
+ * Only entries for the currently configured host are considered; entries for
+ * another host are kept untouched. On a transport failure the remaining
+ * entries are left in the file so a later startup can retry.
+ */
+export async function reconcileInflightDshRuns(opts) {
+    const timeoutMs = opts.timeoutMs ?? 3_000;
+    const entries = opts.store.list().filter((entry) => entry.baseUrl === opts.client.baseUrl);
+    if (entries.length === 0)
+        return { removed: 0, open: 0, skipped: false };
+    let removed = 0;
+    const open = [];
+    for (const entry of entries.slice(0, 10)) {
+        try {
+            const itemId = await opts.client.findPendingPrompt(entry.sessionId, entry.promptRequestId, {
+                timeoutMs,
+            });
+            if (itemId) {
+                const ok = await opts.client.removeQueuedPrompt(entry.sessionId, itemId, { timeoutMs });
+                if (ok)
+                    removed++;
+            }
+            const state = await opts.client.openTurnState(entry.sessionId, { timeoutMs });
+            if (state !== 'closed')
+                open.push(entry);
+            // Handled once: do not nag on every later startup.
+            opts.store.clear(entry.sessionId, entry.promptRequestId);
+        }
+        catch (err) {
+            getLogger().warn(`[dsh] inflight reconcile skipped (host unreachable?): ${err.message}`);
+            return { removed, open: open.length, skipped: true };
+        }
+    }
+    if (open.length > 0) {
+        getLogger().warn(`[dsh] inflight reconcile: ${open.length} session(s) may still have an open turn`);
+        if (opts.notify) {
+            try {
+                await opts.notify(formatInflightWarning(open));
+            }
+            catch (err) {
+                getLogger().warn(`[dsh] inflight notice failed: ${err.message}`);
+            }
+        }
+    }
+    return { removed, open: open.length, skipped: false };
+}
+/** One short owner-facing notice; session ids are truncated, not paths. */
+export function formatInflightWarning(entries) {
+    const lines = entries.slice(0, 3).map((entry) => {
+        const id = entry.sessionId.length > 8 ? entry.sessionId.slice(0, 8) : entry.sessionId;
+        return `- session ${id}（${entry.cwd ?? '未知目录'}）`;
+    });
+    if (entries.length > 3)
+        lines.push(`- …另有 ${entries.length - 3} 个`);
+    return (`⚠️ 上次退出时可能留下了未结束的 DSH turn（${entries.length} 个）：\n` +
+        `${lines.join('\n')}\n` +
+        '请到 DSH Web UI 检查并终止；本机的 /stop 只能停止当前由 lark-remote 发起的 run。');
+}
+//# sourceMappingURL=inflight.js.map