lark-remote 0.4.5 → 0.5.1

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

@@ -1,8 +1,8 @@
 import type { AgentKind } from '../runner/types.js';
 /**
  * 入队时刻快照：当前 defaultAgent + 该 agent 的 sessionId（无 session 则 undefined）。
- * 唯一捕获点：排队消息在 T0 把 agent+session 钉进 AgentBinding，随任务闭包带到 T1
- * 执行时刻，避免 /new、/config 在排队期间改写 live 状态导致语义漂移（方案 D4）。
+ * 唯一捕获点：排队消息在入队时刻把 agent+session 钉进 AgentBinding，随任务闭包带到执行时刻
+ * 执行时刻，避免 /new、/config 在排队期间改写 live 状态导致语义漂移。
  */
 export interface AgentBinding {
     agent: AgentKind;
@@ -51,9 +51,32 @@ export interface QueuedTask {
      * `handleQueueImmediate`).
      */
     editedMessage?: string;
-    /** 入队时刻捕获的 agent+session 绑定（方案 D4），随任务闭包带到执行时刻。 */
+    /** 入队时刻捕获的 agent+session 绑定，随任务闭包带到执行时刻。 */
     binding?: AgentBinding;
 }
+/**
+ * lane 条目的展示类型。只影响排队卡如何描述「正在执行的是什么」：
+ * `message` 普通消息（缺省）、`compact` 压缩会话、`command` 其他卡片动作。
+ */
+export type LaneTaskKind = 'message' | 'compact' | 'command';
+/**
+ * lane 当前占用者的展示信息。由 begin 路径登记、settle 路径清除，与执行
+ * 槽位同寿命；排队卡靠它回答「我在等谁」。
+ */
+export interface ExecutingInfo {
+    /**
+     * 归属标记：与执行槽位共用同一个 slot id。清除时校验它，防止一条迟到的
+     * settle 清掉后继任务的占用者（身份不用外部 id，同 §9.24 口径）。
+     */
+    slotId: number;
+    kind: LaneTaskKind;
+    /** 展示标签，例如 '💬 消息' / '🗜 Compact' / '📋 config.save'。 */
+    label: string;
+    /** 该条目自己的排队预览（可选）。 */
+    preview?: string;
+    /** 登记时刻（epoch ms）。当前只供诊断，卡片不渲染实时时长。 */
+    startedAt: number;
+}
 /** Options for enqueue operation */
 export interface EnqueueOptions {
     taskMeta?: {
@@ -70,8 +93,14 @@ export interface EnqueueOptions {
         feishuReplyTo?: string;
         /** Whether the queued task is editable (queue card ✏️ 编辑 button). Defaults to true. */
         editable?: boolean;
-        /** 入队时刻捕获的 agent+session 绑定（方案 D4）。 */
+        /** 入队时刻捕获的 agent+session 绑定。 */
         binding?: AgentBinding;
+        /**
+         * lane 占用者的展示类型，缺省 'message'。
+         * 'compact' 时排队卡写明「正在执行: 🗜 Compact」，并把「立即执行」置灰
+         * ——该按钮会中断压缩（见 buildQueueActionButtons）。
+         */
+        kind?: LaneTaskKind;
     };
 }
 /** Queue info for a cwd */
@@ -90,7 +119,7 @@ export declare class QueueManager {
     /** Per-workspace queued tasks for queue display cards. Key = cwd, value = task list. */
     private queuedTasks;
     /**
-     * P3-5: per-workspace `messageId → QueuedTask` index mirroring `queuedTasks`.
+     * per-workspace `messageId → QueuedTask` index mirroring `queuedTasks`.
      * O(1) lookup for the task-start removal path (replacing the old double
      * `find`+`findIndex` O(N) scan) and for `getQueuedTask`/`removeFromQueue`/
      * `updateQueuedTaskMessage`. The ordered array remains the source of truth
@@ -115,18 +144,23 @@ export declare class QueueManager {
     /**
      * Monotonic counter minting a unique slot id per enqueued task. A slot
      * identifies one task's execution period for the interrupt bookkeeping in
-     * `executingSlot`/`interruptedSlots` — replacing the unowned skip-credit
+     * `executingInfo`/`interruptedSlots` — replacing the unowned skip-credit
      * counter, which any settle could consume and which therefore leaked a
-     * re-armed count after repeated resets (see A4 anchor).
+     * re-armed count after repeated resets.
      */
     private slotCounter;
     /**
-     * Per-workspace slot id of the task currently executing. Set in the begin
-     * path right before the task runs; deleted when that task's settle fires.
-     * `resetExecutingCount` reads it to bind the interrupt credit to exactly
-     * the interrupted task's slot.
+     * Per-workspace record of the task currently executing — the lane occupant.
+     * Set in the begin path right before the task runs; deleted by that task's
+     * settle. Carries both the slot id (`resetExecutingCount` binds the
+     * interrupt credit to exactly the interrupted task's slot) and the display
+     * info the queue card needs to name what a waiting message waits for.
+     *
+     * 2026-10-09 线上：一次 Compact 占着 lane，新消息的排队卡却写「位置: 第 1
+     * 位 / 前面还有: 0 条消息」——开卡判据看 lane（含正在执行者），位置文案只看
+     * 等待队列，两个口径的差集正是这条记录。
      */
-    private executingSlot;
+    private executingInfo;
     /**
      * Per-workspace set of slot ids whose task was interrupted by
      * `resetExecutingCount`. When such a slot settles, its decrement is skipped
@@ -141,7 +175,7 @@ export declare class QueueManager {
     /**
      * MessageIds of tasks that have actually begun executing (cancellation check
      * passed, task removed from the queue). Entries are sticky: they remain
-     * after the task settles (A21). `handleQueueImmediate` step 6 uses this to
+     * after the task settles. `handleQueueImmediate` step 6 uses this to
      * distinguish "target was cancelled (never began)" from "target began while
      * the interrupt was in flight" so the final feedback can report the true
      * state instead of telling a running task's user that nothing was
@@ -162,11 +196,11 @@ export declare class QueueManager {
     constructor(isWorkspaceRunning: (cwd: string) => boolean, sendCard: (chatId: string, card: object, opts?: {
         replyTo?: string;
     }) => Promise<string>, updateCard: (messageId: string, card: object) => Promise<void>);
-    /** P3-5: register a queued task in the per-workspace `messageId → task` index. */
+    /** register a queued task in the per-workspace `messageId → task` index. */
     private indexAdd;
-    /** P3-5: drop a task from the per-workspace index by messageId. */
+    /** drop a task from the per-workspace index by messageId. */
     private indexRemove;
-    /** P3-5: O(1) lookup of a queued task by messageId via the index. */
+    /** O(1) lookup of a queued task by messageId via the index. */
     private indexGet;
     /**
      * Enqueue a task into the workspace-level serial queue.
@@ -184,6 +218,12 @@ export declare class QueueManager {
      * after it). Consumed when the task's slot begins; removed if cancelled.
      */
     setTaskReplacement(cwd: string, messageId: string, task: () => Promise<void>): void;
+    /**
+     * 排队卡头部。只有前面确实还有等待中的消息时才说「排队」；前面为空时
+     * 用户等的是当前正在执行的任务（例如 Compact），用「等待当前任务结束」
+     * 表达才不会与「前面还有 0 条」自相矛盾（2026-10-09 线上实例）。
+     */
+    private queueCardHeader;
     /** Send a queue status card showing current queue position and actions. */
     private sendQueueStatusCard;
     /** Get queue info for a cwd. */
@@ -198,7 +238,11 @@ export declare class QueueManager {
      * state — pending cards enable both, executing/cancelled cards disable
      * both. Centralizing the pair here eliminates the 3-way duplication
      * between `buildQueueStatusCardElements`, `updateQueueCardToExecuting`,
-     * and `updateQueueCardToCancelled` (Clean Code P2-1).
+     * and `updateQueueCardToCancelled` (Clean Code).
+     *
+     * `opts.immediateLabel`（仅 pending 卡用）在 lane 被 Compact 占用时替换
+     * 「⚡ 立即执行」并强制置灰：点击它会中断正在跑的压缩。「❌ 撤销」不参与，
+     * 它只移除等待中的消息，不触碰 Compact。
      */
     private buildQueueActionButtons;
     /**
@@ -251,7 +295,7 @@ export declare class QueueManager {
      * id minted at enqueue time. Three cases:
      *
      * 1. The slot is the workspace's current executing slot → its execution
-     *    period ends (`executingSlot` marker removed).
+     *    period ends (`executingInfo` record removed).
      * 2. The slot is in `interruptedSlots` (its task was interrupted by
      *    `resetExecutingCount`) → skip the decrement: the reset already zeroed
      *    the count, so a stale decrement could wrongly zero it again while a
@@ -279,16 +323,23 @@ export declare class QueueManager {
      * `expectedSlot` binds the reset to the task that was actually interrupted:
      * the caller captures the executing slot BEFORE stopping the runner, and
      * the stop window may outlive the interrupted task's settle (the chain can
-     * advance to a NEW task, which then owns `executingSlot`). When the current
+     * advance to a NEW task, which then owns `executingInfo`). When the current
      * slot no longer matches the interrupted task's slot, the interrupted task
      * already decremented normally — resetting now would zero the count of the
      * running successor and mark ITS slot interrupted, hiding it from the
-     * queue card (A22).
+     * queue card.
      */
     resetExecutingCount(cwd: string, expectedSlot: number): void;
     /**
      * The slot id of the task currently executing in this cwd (if any).
      */
     getExecutingSlot(cwd: string): number | undefined;
+    /**
+     * The lane occupant's display info for this cwd (if any). Queue cards read
+     * it to name what a waiting message is waiting for; `handleQueueImmediate`
+     * reads it to refuse interrupting a running Compact. Returns a copy so
+     * callers cannot mutate the live record.
+     */
+    getExecutingInfo(cwd: string): ExecutingInfo | undefined;
 }
 export {};

package/dist/bridge/queue-manager.js

@@ -1,7 +1,7 @@
 import { getLogger } from '../logger/index.js';
 import { displayName } from '../platform/path.js';
 /**
- * Per-workspace cap on the number of tasks WAITING to execute (review P2-5).
+ * Per-workspace cap on the number of tasks WAITING to execute.
  * Without a bound, a message flood grows `queuedTasks` / the promise chain /
  * each task's captured `msg.content` closure without limit, and every enqueued
  * task fires a queue card (amplifying outbound API calls). When the waiting
@@ -11,6 +11,18 @@ import { displayName } from '../platform/path.js';
  * backlog, not throughput. Owner is a single user, so 50 is ample headroom.
  */
 const MAX_WAITING_QUEUE = 50;
+/** 排队卡「正在执行」一行用的展示标签。 */
+function laneOccupantLabel(kind, preview) {
+    switch (kind) {
+        case 'compact':
+            return '🗜 Compact';
+        case 'command':
+            // 卡片动作的预览形如 'card action: config.save'，标签里去掉前缀更短。
+            return `📋 ${preview.replace(/^card action:\s*/, '')}`;
+        default:
+            return '💬 消息';
+    }
+}
 /**
  * QueueManager handles the per-workspace serial processing queue.
  * Manages task queuing, cancellation, and queue status card rendering.
@@ -21,7 +33,7 @@ export class QueueManager {
     /** Per-workspace queued tasks for queue display cards. Key = cwd, value = task list. */
     queuedTasks = new Map();
     /**
-     * P3-5: per-workspace `messageId → QueuedTask` index mirroring `queuedTasks`.
+     * per-workspace `messageId → QueuedTask` index mirroring `queuedTasks`.
      * O(1) lookup for the task-start removal path (replacing the old double
      * `find`+`findIndex` O(N) scan) and for `getQueuedTask`/`removeFromQueue`/
      * `updateQueuedTaskMessage`. The ordered array remains the source of truth
@@ -46,18 +58,23 @@ export class QueueManager {
     /**
      * Monotonic counter minting a unique slot id per enqueued task. A slot
      * identifies one task's execution period for the interrupt bookkeeping in
-     * `executingSlot`/`interruptedSlots` — replacing the unowned skip-credit
+     * `executingInfo`/`interruptedSlots` — replacing the unowned skip-credit
      * counter, which any settle could consume and which therefore leaked a
-     * re-armed count after repeated resets (see A4 anchor).
+     * re-armed count after repeated resets.
      */
     slotCounter = 0;
     /**
-     * Per-workspace slot id of the task currently executing. Set in the begin
-     * path right before the task runs; deleted when that task's settle fires.
-     * `resetExecutingCount` reads it to bind the interrupt credit to exactly
-     * the interrupted task's slot.
+     * Per-workspace record of the task currently executing — the lane occupant.
+     * Set in the begin path right before the task runs; deleted by that task's
+     * settle. Carries both the slot id (`resetExecutingCount` binds the
+     * interrupt credit to exactly the interrupted task's slot) and the display
+     * info the queue card needs to name what a waiting message waits for.
+     *
+     * 2026-10-09 线上：一次 Compact 占着 lane，新消息的排队卡却写「位置: 第 1
+     * 位 / 前面还有: 0 条消息」——开卡判据看 lane（含正在执行者），位置文案只看
+     * 等待队列，两个口径的差集正是这条记录。
      */
-    executingSlot = new Map();
+    executingInfo = new Map();
     /**
      * Per-workspace set of slot ids whose task was interrupted by
      * `resetExecutingCount`. When such a slot settles, its decrement is skipped
@@ -72,7 +89,7 @@ export class QueueManager {
     /**
      * MessageIds of tasks that have actually begun executing (cancellation check
      * passed, task removed from the queue). Entries are sticky: they remain
-     * after the task settles (A21). `handleQueueImmediate` step 6 uses this to
+     * after the task settles. `handleQueueImmediate` step 6 uses this to
      * distinguish "target was cancelled (never began)" from "target began while
      * the interrupt was in flight" so the final feedback can report the true
      * state instead of telling a running task's user that nothing was
@@ -95,7 +112,7 @@ export class QueueManager {
         this.sendCard = sendCard;
         this.updateCard = updateCard;
     }
-    /** P3-5: register a queued task in the per-workspace `messageId → task` index. */
+    /** register a queued task in the per-workspace `messageId → task` index. */
     indexAdd(cwd, task) {
         let idx = this.taskIndex.get(cwd);
         if (!idx) {
@@ -104,11 +121,11 @@ export class QueueManager {
         }
         idx.set(task.messageId, task);
     }
-    /** P3-5: drop a task from the per-workspace index by messageId. */
+    /** drop a task from the per-workspace index by messageId. */
     indexRemove(cwd, messageId) {
         this.taskIndex.get(cwd)?.delete(messageId);
     }
-    /** P3-5: O(1) lookup of a queued task by messageId via the index. */
+    /** O(1) lookup of a queued task by messageId via the index. */
     indexGet(cwd, messageId) {
         return this.taskIndex.get(cwd)?.get(messageId);
     }
@@ -147,7 +164,7 @@ export class QueueManager {
             const currentExecutingCount = this.pendingOrExecutingCount.get(cwd) ?? 0;
             const currentQueueLength = this.queuedTasks.get(cwd)?.length ?? 0;
             const hasWaitingTasks = currentExecutingCount > 0 || currentQueueLength > 0;
-            // P2-5: bound the waiting backlog. When the queue is full, reject the
+            // bound the waiting backlog. When the queue is full, reject the
             // task with a visible card instead of appending it (which would grow
             // the promise chain + closures unboundedly under a message flood and
             // fire another queue card). Do NOT increment pendingOrExecutingCount —
@@ -183,6 +200,14 @@ export class QueueManager {
                 taskList = [];
                 this.queuedTasks.set(cwd, taskList);
             }
+            // 身份不变量 tripwire：同一 cwd 内 queue key 必须唯一（一次入队动作一个
+            // key，铸造点 router.mintQueueTaskKey）。撞 key 时数组（追加）与 taskIndex
+            // （覆盖）必然漂移，位置显示/撤销/立即执行/卡片更新会串到别的条目上——
+            // 2026-10-08 线上缺陷就是这么长出来的。这里不改行为，只留证据。
+            if (this.indexGet(cwd, queuedTask.messageId)) {
+                getLogger().warn(`[queue-manager] duplicate queue key cwd=${cwd} messageId=${queuedTask.messageId} — ` +
+                    'queue identity must be minted per enqueue action (see router.mintQueueTaskKey)');
+            }
             taskList.push(queuedTask);
             this.indexAdd(cwd, queuedTask);
             // Increment executing count SYNCHRONOUSLY so subsequent enqueues see it
@@ -217,7 +242,7 @@ export class QueueManager {
             let livePreview = taskMeta?.messagePreview ?? '';
             // Check if this task was cancelled before executing
             if (messageId) {
-                // P3-5: O(1) index lookup replaces the old `find` + `findIndex`
+                // O(1) index lookup replaces the old `find` + `findIndex`
                 // double O(N) scan. The ordered array still drives removal (splice
                 // preserves queue order for position display); the index stays in
                 // sync via indexRemove.
@@ -281,16 +306,24 @@ export class QueueManager {
                 this.pendingOrExecutingCount.set(cwd, 1);
                 getLogger().debug(`[queue-manager] re-armed pendingOrExecutingCount cwd=${cwd} (interrupt resume)`);
             }
-            // Mark this task's slot as the current execution period before running
-            // it. `resetExecutingCount` reads this marker to grant the interrupt
-            // credit to exactly this task; the settle removes the marker.
-            this.executingSlot.set(cwd, slotId);
+            // Mark this task as the lane occupant for its whole execution period
+            // before running it. `resetExecutingCount` reads the slot id to grant
+            // the interrupt credit to exactly this task; the settle removes the
+            // record. `kind`/`label` let a later message's queue card name what it
+            // is waiting for instead of reporting "前面还有 0 条".
+            this.executingInfo.set(cwd, {
+                slotId,
+                kind: taskMeta?.kind ?? 'message',
+                label: laneOccupantLabel(taskMeta?.kind ?? 'message', livePreview),
+                preview: livePreview,
+                startedAt: Date.now(),
+            });
             return replacement ? replacement() : task();
         })
             .then(() => {
             getLogger().debug(`[queue-manager] task end cwd=${cwd}`);
             // beganMessageIds entry intentionally retained: sticky by design
-            // (A21) — the marker records "has ever begun", not "is currently
+            // the marker records "has ever begun", not "is currently
             // running", so a task that began and settled quickly still reports
             // "已开始执行" to queue.immediate.
             this.decrementExecutingCount(cwd, slotId);
@@ -298,7 +331,7 @@ export class QueueManager {
             .catch((err) => {
             getLogger().error('[queue-manager] queue task error:', err);
             // Same sticky rationale as the success settle: the marker survives
-            // even when the task errors after beginning (A21).
+            // even when the task errors after beginning.
             this.decrementExecutingCount(cwd, slotId);
         });
         this.queues.set(cwd, newQueue);
@@ -325,6 +358,20 @@ export class QueueManager {
         workspaceReplacements.set(messageId, task);
         getLogger().debug(`[queue-manager] set task replacement cwd=${cwd} messageId=${messageId}`);
     }
+    /**
+     * 排队卡头部。只有前面确实还有等待中的消息时才说「排队」；前面为空时
+     * 用户等的是当前正在执行的任务（例如 Compact），用「等待当前任务结束」
+     * 表达才不会与「前面还有 0 条」自相矛盾（2026-10-09 线上实例）。
+     */
+    queueCardHeader(tasksAhead) {
+        return {
+            template: 'orange',
+            title: {
+                tag: 'plain_text',
+                content: tasksAhead > 0 ? '⏳ 消息排队中' : '⏳ 等待当前任务结束',
+            },
+        };
+    }
     /** Send a queue status card showing current queue position and actions. */
     async sendQueueStatusCard(cwd, chatId, replyToMessageId, messagePreview, 
     /** Feishu reply target when `replyToMessageId` (the queue key) is an
@@ -338,10 +385,7 @@ export class QueueManager {
         const card = {
             schema: '2.0',
             config: { wide_screen_mode: true },
-            header: {
-                template: 'orange',
-                title: { tag: 'plain_text', content: '⏳ 消息排队中' },
-            },
+            header: this.queueCardHeader(tasksAhead),
             body: {
                 elements: this.buildQueueStatusCardElements(cwd, actualPosition, tasksAhead, replyToMessageId, messagePreview),
             },
@@ -379,25 +423,50 @@ export class QueueManager {
     /** Build queue status card elements. */
     buildQueueStatusCardElements(cwd, actualPosition, tasksAhead, messageId, messagePreview) {
         const workspaceName = displayName(cwd);
-        const isRunning = this.isWorkspaceRunning(cwd);
+        const occupant = this.executingInfo.get(cwd);
         const elements = [
             {
+                tag: 'div',
+                text: { tag: 'lark_md', content: `**当前 Workspace:** \`${workspaceName}\`` },
+            },
+        ];
+        // 「队列位置 / 前面还有」只在前面确实还有等待中的消息时渲染。前面为空时
+        // 这两个数是「第 1 位 / 0 条」，与「排队中」字面矛盾；此时挡住用户的只有
+        // 正在执行的任务，交给下一段如实说明。
+        if (tasksAhead > 0) {
+            elements.push({
                 tag: 'div',
                 text: {
                     tag: 'lark_md',
-                    content: `**当前 Workspace:** \`${workspaceName}\`\n**位置:** 第 ${actualPosition} 位\n**前面还有:** ${tasksAhead} 条消息在排队`,
+                    content: `**队列位置:** 第 ${actualPosition} 位\n**前面还有:** ${tasksAhead} 条消息`,
                 },
-            },
-            { tag: 'hr' },
-            {
+            });
+        }
+        if (occupant) {
+            elements.push({
+                tag: 'div',
+                text: { tag: 'lark_md', content: `**正在执行:** ${occupant.label}` },
+            });
+            elements.push({
                 tag: 'div',
                 text: {
                     tag: 'lark_md',
-                    content: `💡 消息将按顺序执行…当前正在处理: ${isRunning ? '有任务运行中' : '空闲'}`,
+                    content: occupant.kind === 'compact'
+                        ? '💡 压缩结束后将按顺序执行你的消息'
+                        : '💡 消息将按顺序执行…',
                 },
-            },
-            { tag: 'hr' },
-        ];
+            });
+        }
+        else {
+            // 防御分支：开卡判据是 lane 非空，所以「有排队卡但没有占用者」说明计数
+            // 与占用者记录漂移了。不改行为，只留证据（与 duplicate queue key 同口径）。
+            getLogger().warn(`[queue-manager] queue card without lane occupant cwd=${cwd} tasksAhead=${tasksAhead}`);
+            elements.push({
+                tag: 'div',
+                text: { tag: 'lark_md', content: '💡 消息将按顺序执行…' },
+            });
+        }
+        elements.push({ tag: 'hr' });
         // Show message preview with edit button (only if not executing AND the
         // task is editable). One-shot card actions like Compact enqueue with
         // editable=false: their preview is not user-editable text, so the ✏️ 编辑
@@ -423,8 +492,10 @@ export class QueueManager {
             }
             elements.push({ tag: 'hr' });
         }
-        // Action buttons
-        elements.push(...this.buildQueueActionButtons(cwd, messageId, false));
+        // Action buttons. Compact 占着 lane 时「⚡ 立即执行」会中断压缩
+        // （interruptCurrentRun 遍历 activeRuns，压缩也注册在里面），按钮置灰并
+        // 换文案说明；执行层 handleQueueImmediate 再做一次同样的守卫兜住旧卡片。
+        elements.push(...this.buildQueueActionButtons(cwd, messageId, false, occupant?.kind === 'compact' ? { immediateLabel: '压缩完成后按顺序执行' } : undefined));
         return elements;
     }
     /**
@@ -435,9 +506,13 @@ export class QueueManager {
      * state — pending cards enable both, executing/cancelled cards disable
      * both. Centralizing the pair here eliminates the 3-way duplication
      * between `buildQueueStatusCardElements`, `updateQueueCardToExecuting`,
-     * and `updateQueueCardToCancelled` (Clean Code P2-1).
+     * and `updateQueueCardToCancelled` (Clean Code).
+     *
+     * `opts.immediateLabel`（仅 pending 卡用）在 lane 被 Compact 占用时替换
+     * 「⚡ 立即执行」并强制置灰：点击它会中断正在跑的压缩。「❌ 撤销」不参与，
+     * 它只移除等待中的消息，不触碰 Compact。
      */
-    buildQueueActionButtons(cwd, messageId, disabled) {
+    buildQueueActionButtons(cwd, messageId, disabled, opts) {
         return [
             {
                 tag: 'button',
@@ -448,9 +523,9 @@ export class QueueManager {
             },
             {
                 tag: 'button',
-                text: { tag: 'plain_text', content: '⚡ 立即执行' },
+                text: { tag: 'plain_text', content: opts?.immediateLabel ?? '⚡ 立即执行' },
                 type: 'primary',
-                disabled,
+                disabled: disabled || opts?.immediateLabel !== undefined,
                 behaviors: [{ type: 'callback', value: { cmd: 'queue.immediate', cwd, messageId } }],
             },
         ];
@@ -476,8 +551,8 @@ export class QueueManager {
         try {
             // Prefer the live preview: an edited task's messagePreview is updated in
             // place, and the passed-in snapshot may be stale if the card send was in
-            // flight while the user edited (A19). The begin path (started=true) already
-            // passes the live preview captured at begin (A12), so the fallback is only
+            // flight while the user edited. The begin path (started=true) already
+            // passes the live preview captured at begin, so the fallback is only
             // exercised when the task is no longer queued.
             const liveTask = this.indexGet(cwd, messageId);
             const stillQueued = liveTask !== undefined;
@@ -527,7 +602,7 @@ export class QueueManager {
         const taskList = this.queuedTasks.get(cwd);
         if (!taskList)
             return false;
-        // P3-5: index is the O(1) presence check; array splice keeps order.
+        // index is the O(1) presence check; array splice keeps order.
         if (!this.indexGet(cwd, messageId))
             return false;
         const index = taskList.findIndex((t) => t.messageId === messageId);
@@ -582,7 +657,7 @@ export class QueueManager {
     }
     /** Get task metadata from queue. */
     getQueuedTask(cwd, messageId) {
-        // P3-5: O(1) index lookup instead of array `find`.
+        // O(1) index lookup instead of array `find`.
         return this.indexGet(cwd, messageId);
     }
     /**
@@ -600,7 +675,7 @@ export class QueueManager {
     }
     /** Update the messagePreview for a queued task. Returns true if found and updated. */
     updateQueuedTaskMessage(cwd, messageId, newMessage) {
-        // P3-5: O(1) index lookup instead of array `find`.
+        // O(1) index lookup instead of array `find`.
         const task = this.indexGet(cwd, messageId);
         if (!task)
             return false;
@@ -633,10 +708,7 @@ export class QueueManager {
         return {
             schema: '2.0',
             config: { wide_screen_mode: true },
-            header: {
-                template: 'orange',
-                title: { tag: 'plain_text', content: '⏳ 消息排队中' },
-            },
+            header: this.queueCardHeader(tasksAhead),
             body: {
                 elements: this.buildQueueStatusCardElements(cwd, actualPosition, tasksAhead, messageId, newMessagePreview),
             },
@@ -650,7 +722,7 @@ export class QueueManager {
      * id minted at enqueue time. Three cases:
      *
      * 1. The slot is the workspace's current executing slot → its execution
-     *    period ends (`executingSlot` marker removed).
+     *    period ends (`executingInfo` record removed).
      * 2. The slot is in `interruptedSlots` (its task was interrupted by
      *    `resetExecutingCount`) → skip the decrement: the reset already zeroed
      *    the count, so a stale decrement could wrongly zero it again while a
@@ -658,8 +730,8 @@ export class QueueManager {
      * 3. Otherwise → normal decrement.
      */
     decrementExecutingCount(cwd, slotId) {
-        if (this.executingSlot.get(cwd) === slotId) {
-            this.executingSlot.delete(cwd);
+        if (this.executingInfo.get(cwd)?.slotId === slotId) {
+            this.executingInfo.delete(cwd);
         }
         const interrupted = this.interruptedSlots.get(cwd);
         if (interrupted?.has(slotId)) {
@@ -693,19 +765,19 @@ export class QueueManager {
      * `expectedSlot` binds the reset to the task that was actually interrupted:
      * the caller captures the executing slot BEFORE stopping the runner, and
      * the stop window may outlive the interrupted task's settle (the chain can
-     * advance to a NEW task, which then owns `executingSlot`). When the current
+     * advance to a NEW task, which then owns `executingInfo`). When the current
      * slot no longer matches the interrupted task's slot, the interrupted task
      * already decremented normally — resetting now would zero the count of the
      * running successor and mark ITS slot interrupted, hiding it from the
-     * queue card (A22).
+     * queue card.
      */
     resetExecutingCount(cwd, expectedSlot) {
-        const currentSlot = this.executingSlot.get(cwd);
+        const currentSlot = this.executingInfo.get(cwd)?.slotId;
         if (currentSlot !== expectedSlot) {
             getLogger().debug(`[queue-manager] resetExecutingCount skip (stopped task settled, slot advanced) cwd=${cwd} expectedSlot=${expectedSlot} currentSlot=${currentSlot ?? 'none'}`);
             return;
         }
-        // P3#9: only reset and grant an interrupt slot when there is actually a
+        // only reset and grant an interrupt slot when there is actually a
         // pending/executing task.
         const currentCount = this.pendingOrExecutingCount.get(cwd) ?? 0;
         if (currentCount === 0) {
@@ -733,7 +805,17 @@ export class QueueManager {
      * The slot id of the task currently executing in this cwd (if any).
      */
     getExecutingSlot(cwd) {
-        return this.executingSlot.get(cwd);
+        return this.executingInfo.get(cwd)?.slotId;
+    }
+    /**
+     * The lane occupant's display info for this cwd (if any). Queue cards read
+     * it to name what a waiting message is waiting for; `handleQueueImmediate`
+     * reads it to refuse interrupting a running Compact. Returns a copy so
+     * callers cannot mutate the live record.
+     */
+    getExecutingInfo(cwd) {
+        const info = this.executingInfo.get(cwd);
+        return info ? { ...info } : undefined;
     }
 }
 //# sourceMappingURL=queue-manager.js.map

package/dist/card/approval-render.d.ts

@@ -1,7 +1,7 @@
 /**
  * renderApprovalArea: renders the approval request area in a run card.
  *
- * Renders command/file/permissions approval areas with button mappings per §8.3.
+ * Renders command/file/permissions approval areas with button mappings.
  * Uses CardKit 2.0 (no tag:"action" container — 200861 rule).
  */
 import type { ApprovalView } from '../runner/types.js';

package/dist/card/approval-render.js

@@ -1,7 +1,7 @@
 /**
  * renderApprovalArea: renders the approval request area in a run card.
  *
- * Renders command/file/permissions approval areas with button mappings per §8.3.
+ * Renders command/file/permissions approval areas with button mappings.
  * Uses CardKit 2.0 (no tag:"action" container — 200861 rule).
  */
 import { collapsibleMarkdownPanel } from './collapsible.js';
@@ -13,7 +13,7 @@ function mkNonce() {
 }
 /** 计划面板正文字节预算（折叠展示 + 截断保护 28KB 卡片预算）。 */
 const PLAN_PANEL_BYTES = 6000;
-/** reason div（3 处共用）；反引号中和防 lark_md 解析错误（review P2-2）。 */
+/** reason div（3 处共用）；反引号中和防 lark_md 解析错误。 */
 function reasonDiv(approval) {
     if (!approval.reason)
         return null;
@@ -39,7 +39,7 @@ export function renderApprovalArea(approval, opts) {
     if (!approval)
         return [];
     // 终态（done/error/interrupted/idle_timeout）下 run 已结束：coordinator 已
-    // 释放，按钮点击无处响应，隐藏整个审批区避免"点了没反应"（P2-7）。
+    // 释放，按钮点击无处响应，隐藏整个审批区避免"点了没反应"。
     if (opts?.terminal && opts.terminal !== 'running' && opts.terminal !== 'finalizing') {
         return [];
     }
@@ -238,7 +238,7 @@ function renderPlanFeedbackInput(requestId, runId) {
 function renderCommandApproval(approval, expired, runId) {
     const elements = [];
     // Command display
-    // review P2-2：命令里的反引号会提前终止 lark_md 行内代码 span，奇数次
+    // 命令里的反引号会提前终止 lark_md 行内代码 span，奇数次
     // 反引号极易触发 11311 解析错误导致整卡失败（同 renderFileDiff 的中和策略）。
     const neutralizedCommand = (approval.command ?? '').replace(/`/g, '·');
     const cmdContent = neutralizedCommand
@@ -422,7 +422,7 @@ function renderQuestionApproval(approval, expired, runId) {
             elements.push(renderOptionRow(approval.requestId, i, option, isSelected, icon, runId));
         }
         // 自定义答案（Other）的选中态展示：选项按钮无法表示自由文本，单独显示
-        // 已选文本，避免「点了没反应」的困惑（review P3）。
+        // 已选文本，避免「点了没反应」的困惑。
         const customSelected = q.selected?.find((s) => !q.options.some((o) => o.label === s));
         if (customSelected) {
             elements.push({
@@ -430,7 +430,7 @@ function renderQuestionApproval(approval, expired, runId) {
                 text: { tag: 'lark_md', content: `✍️ 自定义答案：${customSelected}` },
             });
         }
-        // review P3-4：单选问题提供自定义答案（Other）输入——输入文本后提交
+        // 单选问题提供自定义答案（Other）输入——输入文本后提交
         // （移动端键盘回车/完成键，桌面端输入框右侧提交图标），input_value 经
         // connector raw 事件回传。
         // 显隐按 isOther !== false：Kimi form 会丢弃非声明选项值，翻译时置