lark-remote 0.5.9 → 0.5.10

package/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.10] - 2026-10-24
+
+### 修复
+
+- **点「立即执行」后，run 卡片不再抢在最终 toast 前面**：立即执行的 run 起始会等当前排队卡完成交接再建卡。否则 toast 会成为点击后最后一条新消息，聊天列表预览停在 toast 文案上，而 run 卡片后续的「思考中 / 工具 / 完成」变化不点进会话就看不到
+- **长时间运行不再被过期的空闲定时器误杀**：工作区连接自行退出（如 codex app-server 偶发 exit 0）后，挂在旧连接上的空闲回收定时器此前不会被取消，约 30 分钟后会按工作目录回收后来接替的新连接，正在跑的回合被杀、卡片误报「连接已关闭」。现在定时器只回收自己武装时那个连接，进程自退时同时撤掉定时器，继任连接自己的空闲回收仍然照常生效
+
+### 变更
+
+- **英文架构文档补齐排队卡叙述**：立即执行时的 run 起始闸门与 toast 排序，中英两侧一致
+
 ## [0.5.9] - 2026-10-22
 
 ### 新增

package/dist/bridge/index.d.ts

@@ -270,6 +270,15 @@ export declare class Bridge {
      * user edits a queued message (see router handleQueueImmediate).
      */
     setTaskReplacement(cwd: string, messageId: string, task: () => Promise<void>): void;
+    /**
+     * One-shot: hold the target's run-card start until the returned release is
+     * called. queue.immediate uses it so its final toast is sent before the run
+     * card — the toast would otherwise be the newest message and the chat list
+     * would stop previewing the run card's title changes. The queue slot itself
+     * still begins normally; only run-card creation waits (see
+     * QueueManager.holdTaskRunStart).
+     */
+    holdQueueTaskRun(cwd: string, messageId: string): () => void;
     /** Update queue card to "cancelled" status when user clicks 撤销. */
     updateQueueCardToCancelled(cwd: string, messageId: string): Promise<void>;
     /** Mark a queued task's card as executing immediately (grey out buttons).

package/dist/bridge/index.js

@@ -488,6 +488,17 @@ export class Bridge {
     setTaskReplacement(cwd, messageId, task) {
         this.queueManager.setTaskReplacement(cwd, messageId, task);
     }
+    /**
+     * One-shot: hold the target's run-card start until the returned release is
+     * called. queue.immediate uses it so its final toast is sent before the run
+     * card — the toast would otherwise be the newest message and the chat list
+     * would stop previewing the run card's title changes. The queue slot itself
+     * still begins normally; only run-card creation waits (see
+     * QueueManager.holdTaskRunStart).
+     */
+    holdQueueTaskRun(cwd, messageId) {
+        return this.queueManager.holdTaskRunStart(cwd, messageId);
+    }
     /** Update queue card to "cancelled" status when user clicks 撤销. */
     async updateQueueCardToCancelled(cwd, messageId) {
         await this.queueManager.updateQueueCardToCancelled(cwd, messageId);
@@ -1209,6 +1220,11 @@ export class Bridge {
         });
         try {
             try {
+                // queue.immediate 的 run-start hold：目标槽位可能在 handler 发最终
+                // toast 之前就 begin（interrupt/PATCH 的 await 窗口）。activeRun 已
+                // 登记（队列语义照旧），只把建卡这一步挡到 toast 之后——run 卡片才是
+                // 点击后最后一条新消息，聊天列表预览跟随它的标题变化。
+                await this.queueManager.awaitTaskRunStart(cwd);
                 getLogger().debug(`[lark-remote] cardSession.start() begin runId=${runId}`);
                 await cardSession.start();
                 getLogger().info(`[lark-remote] cardSession.start() ok runId=${runId}`);

package/dist/bridge/queue-manager.d.ts

@@ -69,6 +69,11 @@ export interface ExecutingInfo {
      * settle 清掉后继任务的占用者（身份不用外部 id，同 §9.24 口径）。
      */
     slotId: number;
+    /**
+     * 本次执行条目自己的队列 key（排队卡身份，见 §9.24）。run 起始闸门按它
+     * 找到「当前 lane 占用者」持有的 hold；无 taskMeta 的任务为 undefined。
+     */
+    messageId?: string;
     kind: LaneTaskKind;
     /** 展示标签，例如 '💬 消息' / '🗜 Compact' / '📋 config.save'。 */
     label: string;
@@ -172,6 +177,17 @@ export declare class QueueManager {
     private interruptedSlots;
     /** Per-workspace messageId → replacement closure, set by queue.edit + immediate. */
     private taskReplacements;
+    /**
+     * Per-workspace messageId → run 起始 hold，单次消费。
+     *
+     * queue.immediate 在入口注册、finally 释放；目标任务的 begin 路径照常推进
+     * （槽位移除、排队卡翻执行态），但 `forwardToClaude` 在建 run 卡片前会等
+     * 当前 lane 占用者的 hold。这样「先 toast、后 run 卡片」与队列链推进速度
+     * 无关：run 卡片是点击后最后一条新消息，聊天列表预览才会跟随它的标题变化。
+     * hold 按队列 key 存（order.exec 的内部 key 也能命中），通过 executingInfo
+     * 找到当前占用者，不需要把队列 key 穿过 router/forwardToClaude 的参数。
+     */
+    private taskRunHolds;
     /**
      * MessageIds of tasks that have actually begun executing (cancellation check
      * passed, task removed from the queue). Entries are sticky: they remain
@@ -212,6 +228,21 @@ export declare class QueueManager {
      * Used for / commands that should respond immediately.
      */
     enqueueImmediate(cwd: string, task: () => Promise<void>): void;
+    /**
+     * 单次：hold 住某个排队任务的 run 起始，直到返回的 release 被调用。
+     *
+     * 与「hold 任务闭包」不同，这里只挡 `forwardToClaude` 建 run 卡片之前的
+     * 那一步：队列槽位照常 begin（排队卡翻执行态、began 记账都发生），所以
+     * queue.immediate 的成员资格判断不受影响，只是目标 run 卡片会等 toast。
+     * release 幂等；若任务在 begin 前被撤销，release 会清掉未消费的 hold。
+     */
+    holdTaskRunStart(cwd: string, messageId: string): () => void;
+    /**
+     * 等待当前 lane 占用者的 run 起始 hold。由 `forwardToClaude` 在建 run 卡片
+     * 前调用；hold 在当前调用里同步摘除，之后才注册的 hold 不会延长本次 run
+     * （release 仍会 settle 已捕获的 promise）。
+     */
+    awaitTaskRunStart(cwd: string): Promise<void>;
     /**
      * One-shot: replace the execution closure of an existing queued task in
      * place, preserving its queue position (tasks queued behind it still run

package/dist/bridge/queue-manager.js

@@ -87,6 +87,17 @@ export class QueueManager {
     interruptedSlots = new Map();
     /** Per-workspace messageId → replacement closure, set by queue.edit + immediate. */
     taskReplacements = new Map();
+    /**
+     * Per-workspace messageId → run 起始 hold，单次消费。
+     *
+     * queue.immediate 在入口注册、finally 释放；目标任务的 begin 路径照常推进
+     * （槽位移除、排队卡翻执行态），但 `forwardToClaude` 在建 run 卡片前会等
+     * 当前 lane 占用者的 hold。这样「先 toast、后 run 卡片」与队列链推进速度
+     * 无关：run 卡片是点击后最后一条新消息，聊天列表预览才会跟随它的标题变化。
+     * hold 按队列 key 存（order.exec 的内部 key 也能命中），通过 executingInfo
+     * 找到当前占用者，不需要把队列 key 穿过 router/forwardToClaude 的参数。
+     */
+    taskRunHolds = new Map();
     /**
      * MessageIds of tasks that have actually begun executing (cancellation check
      * passed, task removed from the queue). Entries are sticky: they remain
@@ -308,6 +319,7 @@ export class QueueManager {
             // is waiting for instead of reporting "前面还有 0 条".
             this.executingInfo.set(cwd, {
                 slotId,
+                messageId,
                 kind: taskMeta?.kind ?? 'message',
                 label: laneOccupantLabel(taskMeta?.kind ?? 'message', livePreview),
                 preview: livePreview,
@@ -339,6 +351,72 @@ export class QueueManager {
         getLogger().debug(`[queue-manager] enqueueImmediate cwd=${cwd}`);
         void task().catch((err) => getLogger().error('[queue-manager] immediate task error:', err));
     }
+    /**
+     * 单次：hold 住某个排队任务的 run 起始，直到返回的 release 被调用。
+     *
+     * 与「hold 任务闭包」不同，这里只挡 `forwardToClaude` 建 run 卡片之前的
+     * 那一步：队列槽位照常 begin（排队卡翻执行态、began 记账都发生），所以
+     * queue.immediate 的成员资格判断不受影响，只是目标 run 卡片会等 toast。
+     * release 幂等；若任务在 begin 前被撤销，release 会清掉未消费的 hold。
+     */
+    holdTaskRunStart(cwd, messageId) {
+        let resolve;
+        const hold = {
+            promise: new Promise((r) => {
+                resolve = r;
+            }),
+            release: () => resolve(),
+        };
+        let workspaceHolds = this.taskRunHolds.get(cwd);
+        if (!workspaceHolds) {
+            workspaceHolds = new Map();
+            this.taskRunHolds.set(cwd, workspaceHolds);
+        }
+        const holds = workspaceHolds.get(messageId);
+        if (holds) {
+            holds.push(hold);
+        }
+        else {
+            workspaceHolds.set(messageId, [hold]);
+        }
+        getLogger().debug(`[queue-manager] hold task run start cwd=${cwd} messageId=${messageId}`);
+        return () => {
+            // Resolve before mutating the map: `awaitTaskRunStart` may already have
+            // captured (and deleted) this entry, and the captured promise still needs
+            // to settle.
+            hold.release();
+            const current = this.taskRunHolds.get(cwd)?.get(messageId);
+            if (!current)
+                return;
+            const idx = current.indexOf(hold);
+            if (idx >= 0)
+                current.splice(idx, 1);
+            if (current.length > 0)
+                return;
+            this.taskRunHolds.get(cwd)?.delete(messageId);
+            if (this.taskRunHolds.get(cwd)?.size === 0)
+                this.taskRunHolds.delete(cwd);
+        };
+    }
+    /**
+     * 等待当前 lane 占用者的 run 起始 hold。由 `forwardToClaude` 在建 run 卡片
+     * 前调用；hold 在当前调用里同步摘除，之后才注册的 hold 不会延长本次 run
+     * （release 仍会 settle 已捕获的 promise）。
+     */
+    async awaitTaskRunStart(cwd) {
+        const messageId = this.executingInfo.get(cwd)?.messageId;
+        if (!messageId)
+            return;
+        const workspaceHolds = this.taskRunHolds.get(cwd);
+        const holds = workspaceHolds?.get(messageId);
+        if (!holds || holds.length === 0)
+            return;
+        workspaceHolds?.delete(messageId);
+        if (workspaceHolds?.size === 0)
+            this.taskRunHolds.delete(cwd);
+        getLogger().debug(`[queue-manager] awaiting task run start cwd=${cwd} messageId=${messageId} holds=${holds.length}`);
+        await Promise.all(holds.map((h) => h.promise));
+    }
     /**
      * One-shot: replace the execution closure of an existing queued task in
      * place, preserving its queue position (tasks queued behind it still run

package/dist/router/index.js

@@ -822,128 +822,143 @@ export class CommandRouter {
             await this.bridge.sendResult({ text: '⚠️ 正在压缩会话，消息将在压缩完成后按顺序执行。' }, ctx);
             return;
         }
-        // 1.5. If the user edited the message, the original closure (captured at
-        // enqueue time with stale content) must NOT run. Register a one-shot
-        // replacement closure on the task's EXISTING queue slot BEFORE any await:
-        // interruptCurrentRun / markQueueCardExecuting can let the chain advance to
-        // this task's begin, and begin consumes the replacement at that point — a
-        // registration after those awaits would arrive too late (the stale closure
-        // runs and the replacement leaks as a permanent dead closure). Registering
-        // on the existing slot (instead of removeFromQueue + re-enqueue) preserves
-        // the queue position: enqueue can only append to the promise chain tail,
-        // which would put the edited task behind tasks queued after it.
-        if (targetTask.editedMessage) {
-            const editedContent = targetTask.editedMessage;
-            ///Step3: 替换闭包复用原任务的 binding（不重新快照）+ 恢复丢失的
-            // cwdOverride（lane cwd 同源）。否则编辑后重新执行的 run 会丢 cwd 与绑定。
-            this.bridge.setTaskReplacement(cwd, messageId, async () => {
-                await this.handle(editedContent, ctx, {
-                    cwdOverride: cwd,
-                    binding: targetTask.binding,
+        // 1.4. Hold the target's run-card start until this handler has sent its
+        // final feedback. The queue chain can advance during the awaits below
+        // (interruptCurrentRun / the queue-card PATCH): the target may begin and
+        // call forwardToClaude before the toast is sent. Without this hold the
+        // run card would land first, leaving the toast as the newest message —
+        // the chat list then previews the toast instead of the run card's title
+        // (which is how the user follows a run without opening the conversation).
+        // Registered before any await, released in finally on every exit path;
+        // forwardToClaude waits for it before creating the run card.
+        const releaseRunStart = this.bridge.holdQueueTaskRun(cwd, messageId);
+        try {
+            // 1.5. If the user edited the message, the original closure (captured at
+            // enqueue time with stale content) must NOT run. Register a one-shot
+            // replacement closure on the task's EXISTING queue slot BEFORE any await:
+            // interruptCurrentRun / markQueueCardExecuting can let the chain advance to
+            // this task's begin, and begin consumes the replacement at that point — a
+            // registration after those awaits would arrive too late (the stale closure
+            // runs and the replacement leaks as a permanent dead closure). Registering
+            // on the existing slot (instead of removeFromQueue + re-enqueue) preserves
+            // the queue position: enqueue can only append to the promise chain tail,
+            // which would put the edited task behind tasks queued after it.
+            if (targetTask.editedMessage) {
+                const editedContent = targetTask.editedMessage;
+                ///Step3: 替换闭包复用原任务的 binding（不重新快照）+ 恢复丢失的
+                // cwdOverride（lane cwd 同源）。否则编辑后重新执行的 run 会丢 cwd 与绑定。
+                this.bridge.setTaskReplacement(cwd, messageId, async () => {
+                    await this.handle(editedContent, ctx, {
+                        cwdOverride: cwd,
+                        binding: targetTask.binding,
+                    });
                 });
+            }
+            // 2. Stop current running process
+            // (Note: queue executing count is reset inside Bridge.interruptCurrentRun
+            //  so all stop paths — /stop, /t, card stop, queue.immediate — are covered.)
+            const interrupt = await this.bridge.interruptCurrentRunDetailed({
+                userId: ctx.userId,
+                chatId: ctx.chatId,
+                cwd,
             });
-        }
-        // 2. Stop current running process
-        // (Note: queue executing count is reset inside Bridge.interruptCurrentRun
-        //  so all stop paths — /stop, /t, card stop, queue.immediate — are covered.)
-        const interrupt = await this.bridge.interruptCurrentRunDetailed({
-            userId: ctx.userId,
-            chatId: ctx.chatId,
-            cwd,
-        });
-        const stopped = interrupt.stopped;
-        // A remote (DSH) stop is only a request; when it cannot be confirmed the
-        // target must not be promised "immediate" execution — its prompt would sit
-        // behind the still-running turn with no visible progress.
-        const stopUnconfirmed = interrupt.stop?.status === 'unconfirmed';
-        getLogger().info(`[router] queue.immediate: stopped=${stopped} unconfirmed=${stopUnconfirmed}`);
-        // 3. Remove all tasks BEFORE this one (by position in the current queue).
-        // The target may have begun while interruptCurrentRun was awaiting (the chain
-        // advances concurrently): then it is already out of the snapshot and every
-        // remaining queued task is BEHIND it — clearing must stop, not run off the
-        // end and delete tasks queued after the target.
-        const tasks = this.bridge.getQueuedTasks(cwd);
-        const targetIdx = tasks.findIndex((t) => t.messageId === messageId);
-        let removedCount = 0;
-        // Phase 1: remove synchronously. The queue chain advances on any await
-        // (card PATCH round trips included), so every task before the target must
-        // be removed before yielding to the event loop — otherwise a task the user
-        // asked to clear can begin executing while its cancellation card is still
-        // in flight.
-        for (let i = 0; i < targetIdx; i++) {
-            const task = tasks[i];
-            // 撤销卡片由 removeFromQueue 统一触发（fire-and-forget），保持本循环
-            // 同步推进的既有不变式。
-            if (this.bridge.removeFromQueue(cwd, task.messageId)) {
-                removedCount++;
+            const stopped = interrupt.stopped;
+            // A remote (DSH) stop is only a request; when it cannot be confirmed the
+            // target must not be promised "immediate" execution — its prompt would sit
+            // behind the still-running turn with no visible progress.
+            const stopUnconfirmed = interrupt.stop?.status === 'unconfirmed';
+            getLogger().info(`[router] queue.immediate: stopped=${stopped} unconfirmed=${stopUnconfirmed}`);
+            // 3. Remove all tasks BEFORE this one (by position in the current queue).
+            // The target may have begun while interruptCurrentRun was awaiting (the chain
+            // advances concurrently): then it is already out of the snapshot and every
+            // remaining queued task is BEHIND it — clearing must stop, not run off the
+            // end and delete tasks queued after the target.
+            const tasks = this.bridge.getQueuedTasks(cwd);
+            const targetIdx = tasks.findIndex((t) => t.messageId === messageId);
+            let removedCount = 0;
+            // Phase 1: remove synchronously. The queue chain advances on any await
+            // (card PATCH round trips included), so every task before the target must
+            // be removed before yielding to the event loop — otherwise a task the user
+            // asked to clear can begin executing while its cancellation card is still
+            // in flight.
+            for (let i = 0; i < targetIdx; i++) {
+                const task = tasks[i];
+                // 撤销卡片由 removeFromQueue 统一触发（fire-and-forget），保持本循环
+                // 同步推进的既有不变式。
+                if (this.bridge.removeFromQueue(cwd, task.messageId)) {
+                    removedCount++;
+                }
             }
-        }
-        if (targetIdx < 0) {
-            getLogger().debug(`[router] queue.immediate: target no longer queued (began/cancelled), not clearing tasks behind it`);
-        }
-        // 4. DO NOT remove the target task - keep it in queue to execute immediately
-        // The queue will naturally execute it after the current task (which we just stopped)
-        // 4.4. Refresh the replacement with the latest edited content (idempotent:
-        // re-registering over the same slot). Covers the user editing the message
-        // again while interruptCurrentRun was awaiting; skipped automatically once
-        // the task has begun, because getQueuedTask then returns undefined.
-        const latestTask = this.bridge.getQueuedTask(cwd, messageId);
-        if (latestTask?.editedMessage) {
-            const editedContent = latestTask.editedMessage;
-            ///Step3: 复用原任务 binding + 恢复 cwdOverride（同上）。
-            this.bridge.setTaskReplacement(cwd, messageId, async () => {
-                await this.handle(editedContent, ctx, {
-                    cwdOverride: cwd,
-                    binding: latestTask.binding,
+            if (targetIdx < 0) {
+                getLogger().debug(`[router] queue.immediate: target no longer queued (began/cancelled), not clearing tasks behind it`);
+            }
+            // 4. DO NOT remove the target task - keep it in queue to execute immediately
+            // The queue will naturally execute it after the current task (which we just stopped)
+            // 4.4. Refresh the replacement with the latest edited content (idempotent:
+            // re-registering over the same slot). Covers the user editing the message
+            // again while interruptCurrentRun was awaiting; skipped automatically once
+            // the task has begun, because getQueuedTask then returns undefined.
+            const latestTask = this.bridge.getQueuedTask(cwd, messageId);
+            if (latestTask?.editedMessage) {
+                const editedContent = latestTask.editedMessage;
+                ///Step3: 复用原任务 binding + 恢复 cwdOverride（同上）。
+                this.bridge.setTaskReplacement(cwd, messageId, async () => {
+                    await this.handle(editedContent, ctx, {
+                        cwdOverride: cwd,
+                        binding: latestTask.binding,
+                    });
                 });
-            });
-        }
-        // 4.5/6. The target must only be marked executing (and the toast may only
-        // promise immediate execution) when it is really the next task after the
-        // stop. While interruptCurrentRun was awaiting, a task ahead of the target
-        // may have begun and now occupy the cwd — the target is still queued
-        // but is NOT next, so its card must stay queued and the toast must say so.
-        const targetStillQueued = this.bridge.getQueuedTask(cwd, messageId) !== undefined;
-        if (!targetStillQueued) {
-            // The target began or was cancelled while earlier awaits were in flight —
-            // a success toast must never promise execution of a task that will not
-            // run. The two missing-reason states get distinct feedback: a target
-            // that began while the interrupt was in flight is already executing, so
-            // the toast must acknowledge that instead of telling the user nothing
-            // was scheduled; only a target that was actually cancelled (never began)
-            // gets the "未安排执行" wording.
-            if (this.bridge.hasTaskBegan(messageId)) {
-                await this.bridge.sendResult({ text: `ℹ️ 目标消息已开始执行，无需重复操作。已清除 ${removedCount} 条排队消息。` }, ctx);
+            }
+            // 4.5/6. The target must only be marked executing (and the toast may only
+            // promise immediate execution) when it is really the next task after the
+            // stop. While interruptCurrentRun was awaiting, a task ahead of the target
+            // may have begun and now occupy the cwd — the target is still queued
+            // but is NOT next, so its card must stay queued and the toast must say so.
+            const targetStillQueued = this.bridge.getQueuedTask(cwd, messageId) !== undefined;
+            if (!targetStillQueued) {
+                // The target began or was cancelled while earlier awaits were in flight —
+                // a success toast must never promise execution of a task that will not
+                // run. The two missing-reason states get distinct feedback: a target
+                // that began while the interrupt was in flight is already executing, so
+                // the toast must acknowledge that instead of telling the user nothing
+                // was scheduled; only a target that was actually cancelled (never began)
+                // gets the "未安排执行" wording.
+                if (this.bridge.hasTaskBegan(messageId)) {
+                    await this.bridge.sendResult({ text: `ℹ️ 目标消息已开始执行，无需重复操作。已清除 ${removedCount} 条排队消息。` }, ctx);
+                }
+                else {
+                    await this.bridge.sendResult({
+                        text: `⚠️ 目标消息已不在队列中（可能已被撤销），未安排执行。已清除 ${removedCount} 条排队消息。`,
+                    }, ctx);
+                }
+                return;
+            }
+            const workspaceBusy = this.bridge.isBusyFor(cwd);
+            if (stopUnconfirmed) {
+                const name = interrupt.agentKind ? agentDisplayName(interrupt.agentKind) : 'agent';
+                await this.bridge.sendResult({
+                    text: `⚠️ 未能确认 ${name} 的 turn 已停止，它可能仍在后台运行。\n` +
+                        `已清除 ${removedCount} 条排队消息；您的消息已提交，但可能要等该 turn 结束后才开始。`,
+                }, ctx);
+            }
+            else if (!workspaceBusy) {
+                // Normal path: nothing new began during the stop, the target is next.
+                // Mark its own card as executing now so buttons grey out immediately.
+                // Done BEFORE any removal so getQueuedTask still returns the task with
+                // its (possibly edited) messagePreview for the card. The queue callback's
+                // later updateQueueCardToExecuting call becomes a no-op (idempotent).
+                await this.bridge.markQueueCardExecuting(cwd, messageId);
+                const stopPrefix = stopped ? '⚡ 已停止当前任务，' : '';
+                await this.bridge.sendResult({ text: `${stopPrefix}清除了 ${removedCount} 条排队消息。您的消息将立即执行。` }, ctx);
             }
             else {
                 await this.bridge.sendResult({
-                    text: `⚠️ 目标消息已不在队列中（可能已被撤销），未安排执行。已清除 ${removedCount} 条排队消息。`,
+                    text: `⚠️ 排在目标之前的任务已开始执行，目标消息保持排队。已清除 ${removedCount} 条排队消息。`,
                 }, ctx);
             }
-            return;
         }
-        const workspaceBusy = this.bridge.isBusyFor(cwd);
-        if (stopUnconfirmed) {
-            const name = interrupt.agentKind ? agentDisplayName(interrupt.agentKind) : 'agent';
-            await this.bridge.sendResult({
-                text: `⚠️ 未能确认 ${name} 的 turn 已停止，它可能仍在后台运行。\n` +
-                    `已清除 ${removedCount} 条排队消息；您的消息已提交，但可能要等该 turn 结束后才开始。`,
-            }, ctx);
-        }
-        else if (!workspaceBusy) {
-            // Normal path: nothing new began during the stop, the target is next.
-            // Mark its own card as executing now so buttons grey out immediately.
-            // Done BEFORE any removal so getQueuedTask still returns the task with
-            // its (possibly edited) messagePreview for the card. The queue callback's
-            // later updateQueueCardToExecuting call becomes a no-op (idempotent).
-            await this.bridge.markQueueCardExecuting(cwd, messageId);
-            const stopPrefix = stopped ? '⚡ 已停止当前任务，' : '';
-            await this.bridge.sendResult({ text: `${stopPrefix}清除了 ${removedCount} 条排队消息。您的消息将立即执行。` }, ctx);
-        }
-        else {
-            await this.bridge.sendResult({
-                text: `⚠️ 排在目标之前的任务已开始执行，目标消息保持排队。已清除 ${removedCount} 条排队消息。`,
-            }, ctx);
+        finally {
+            releaseRunStart();
         }
     }
     /**

package/dist/runner/common/jsonrpc/connection-manager.d.ts

@@ -147,6 +147,12 @@ export declare class ConnectionManager<TClient extends ConnectionClient = JsonRp
      *
      * `idleTtlMs: 0` = 不回收（与 claude 会话层的 `armIdleTimer` 同口径；按 0
      * setTimeout 会秒删刚建好的连接，等于每条消息重起一次进程）。
+     *
+     * 定时器回调带 **slot 身份校验**：武装之后 slot 可能已被替换——进程自退走
+     * baseOnClose（删 slot 但不经过 disposeSlot）、或同 cwd 已 acquire 了新连接。
+     * 这两种情况下本定时器都已过期，不得回收「当时恰好挂在该 cwd 上」的连接：
+     * 2026-10-24 线上事故即一条泄漏的过期 TTL 杀掉继任连接的在途 turn，卡片
+     * 误报 "Codex app-server connection closed"。
      */
     notifyIdle(cwd: string): void;
     private createClient;

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

@@ -183,18 +183,27 @@ export class ConnectionManager {
      *
      * `idleTtlMs: 0` = 不回收（与 claude 会话层的 `armIdleTimer` 同口径；按 0
      * setTimeout 会秒删刚建好的连接，等于每条消息重起一次进程）。
+     *
+     * 定时器回调带 **slot 身份校验**：武装之后 slot 可能已被替换——进程自退走
+     * baseOnClose（删 slot 但不经过 disposeSlot）、或同 cwd 已 acquire 了新连接。
+     * 这两种情况下本定时器都已过期，不得回收「当时恰好挂在该 cwd 上」的连接：
+     * 2026-10-24 线上事故即一条泄漏的过期 TTL 杀掉继任连接的在途 turn，卡片
+     * 误报 "Codex app-server connection closed"。
      */
     notifyIdle(cwd) {
         if (this.idleTtlMs <= 0)
             return;
         const slot = this.slots.get(cwd);
-        if (slot) {
-            this.clearIdleTimer(slot);
-            slot.idleTimer = setTimeout(() => {
-                getLogger().info(`[${this.logTag}] idle timeout for cwd=${cwd}, releasing connection`);
-                this.disposeSlot(cwd);
-            }, this.idleTtlMs);
-        }
+        if (!slot)
+            return;
+        this.clearIdleTimer(slot);
+        slot.idleTimer = setTimeout(() => {
+            slot.idleTimer = null;
+            if (this.slots.get(cwd) !== slot)
+                return;
+            getLogger().info(`[${this.logTag}] idle timeout for cwd=${cwd}, releasing connection`);
+            this.disposeSlot(cwd);
+        }, this.idleTtlMs);
     }
     // =========================================================================
     // Internal
@@ -222,7 +231,13 @@ export class ConnectionManager {
                 getLogger().info(`[${this.logTag}] connection closed cwd=${cwd}`);
                 // 只清理自己创建的 slot：并发 release + 重新 acquire 后 slot 可能已被
                 // 新连接占据，误删会破坏新连接。
-                if (this.slots.get(cwd)?.client === client) {
+                const current = this.slots.get(cwd);
+                if (current?.client === client) {
+                    // 进程自退（codex app-server 偶发 exit 0，非本程序发起，不经
+                    // disposeSlot）也要撤掉挂在旧 slot 上的 idle TTL：定时器不随 slot
+                    // 删除而取消，到期时会按 cwd 误杀继任连接的在途 turn（2026-10-24
+                    // 线上事故，见 notifyIdle 的身份校验与对应回归测试）。
+                    this.clearIdleTimer(current);
                     this.slots.delete(cwd);
                     this.onConnectionLost?.(cwd);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.5.9",
+  "version": "0.5.10",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",