lark-remote 0.5.0 → 0.5.2

package/dist/bridge/queue-manager.js

@@ -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.
@@ -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.
      */
     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
@@ -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
@@ -281,10 +306,18 @@ 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(() => {
@@ -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,48 @@ 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}\`\n**位置:** 第 ${actualPosition} 位\n**前面还有:** ${tasksAhead} 条消息在排队`,
-                },
+                text: { tag: 'lark_md', content: `**当前 Workspace:** \`${workspaceName}\`` },
             },
-            { tag: 'hr' },
-            {
+        ];
+        // 「队列位置 / 前面还有」只在前面确实还有等待中的消息时渲染。前面为空时
+        // 这两个数是「第 1 位 / 0 条」，与「排队中」字面矛盾；此时挡住用户的只有
+        // 正在执行的任务，由下一段的占用者说明（若占用者是普通消息则不额外渲染）。
+        if (tasksAhead > 0) {
+            elements.push({
                 tag: 'div',
                 text: {
                     tag: 'lark_md',
-                    content: `💡 消息将按顺序执行…当前正在处理: ${isRunning ? '有任务运行中' : '空闲'}`,
+                    content: `**队列位置:** 第 ${actualPosition} 位\n**前面还有:** ${tasksAhead} 条消息`,
                 },
-            },
-            { tag: 'hr' },
-        ];
+            });
+        }
+        if (occupant) {
+            // 只有可能挡住队列、需要用户归因的占用者才自报身份。「正在执行: 💬 消息」
+            // 对普通消息占用者没有信息量——用户刚发的就是消息，「💡 消息将按顺序执行…」
+            // 也只是复述排队本身，一并省去（2026-10-11）。压缩额外说明何时轮到用户。
+            if (occupant.kind !== 'message') {
+                elements.push({
+                    tag: 'div',
+                    text: { tag: 'lark_md', content: `**正在执行:** ${occupant.label}` },
+                });
+            }
+            if (occupant.kind === 'compact') {
+                elements.push({
+                    tag: 'div',
+                    text: { tag: 'lark_md', content: '💡 压缩结束后将按顺序执行你的消息' },
+                });
+            }
+        }
+        else {
+            // 防御分支：开卡判据是 lane 非空，所以「有排队卡但没有占用者」说明计数
+            // 与占用者记录漂移了。不改行为，只留证据（与 duplicate queue key 同口径）。
+            getLogger().warn(`[queue-manager] queue card without lane occupant cwd=${cwd} tasksAhead=${tasksAhead}`);
+        }
+        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 +490,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;
     }
     /**
@@ -436,8 +505,12 @@ export class QueueManager {
      * both. Centralizing the pair here eliminates the 3-way duplication
      * between `buildQueueStatusCardElements`, `updateQueueCardToExecuting`,
      * and `updateQueueCardToCancelled` (Clean Code).
+     *
+     * `opts.immediateLabel`（仅 pending 卡用）在 lane 被 Compact 占用时替换
+     * 「⚡ 立即执行」并强制置灰：点击它会中断正在跑的压缩。「❌ 撤销」不参与，
+     * 它只移除等待中的消息，不触碰 Compact。
      */
-    buildQueueActionButtons(cwd, messageId, disabled) {
+    buildQueueActionButtons(cwd, messageId, disabled, opts) {
         return [
             {
                 tag: 'button',
@@ -448,9 +521,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 } }],
             },
         ];
@@ -633,10 +706,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 +720,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 +728,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,14 +763,14 @@ 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.
      */
     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;
@@ -733,7 +803,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/cli.js

@@ -2,7 +2,8 @@
 /**
  * CLI 引导层（bootstrap）：在 import 应用模块图之前决定运行时（bun/node）并拉起它。
  *
- *XX * 缺一不可：
+ * **这是全仓唯一被认可的 spawn 收口例外**（即 AGENTS.md「子进程 spawn 只走
+ * platform/spawn.ts」红线的显式豁免）。三个理由缺一不可：
  *   1. 时序：preflight（Node 版本守卫、-v/-h/--advanced-help）必须在 import 应用
  *      模块图之前跑完——dist/cli.js 刻意不使用 ES2020+ 语法以便在 node 12 上仍
  *      可被解析，而 dist/index.js 是 ES2022；先 import platform/spawn 就等于先把

package/dist/index.js

@@ -9,7 +9,7 @@ import { probeAllAgents } from './runner/probe.js';
 import { warmCodexCatalogCache } from './config/codex-config.js';
 import { SessionReaderRegistry, SessionStore } from './session/index.js';
 import { ClaudeSessionReader, CodexSessionReader, OpencodeSessionReader, PiSessionReader, KimiSessionReader, DshSessionReader, } from './session/index.js';
-import { CommandRouter, isImmediateAction, DIRECT_RETURN_CMDS, SESSION_MUTATING_ACTION_CMDS, } from './router/index.js';
+import { CommandRouter, isImmediateAction, DIRECT_RETURN_CMDS, SESSION_MUTATING_ACTION_CMDS, COMPACT_ACTION_CMDS, } from './router/index.js';
 import { dispatchOrderExecForQueue } from './router/order-exec-dispatch.js';
 import { buildCardActionFullValue } from './router/card-action-payload.js';
 import { actionFeedbackText } from './router/card-action-feedback.js';
@@ -629,10 +629,21 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
                 taskMeta: {
                     userId,
                     chatId,
-                    messageId,
+                    // 队列身份 key 必须与「这一次点击」1:1：同一张卡片可点 N 次
+                    // （Compact 尤其明显），复用卡片 messageId 会让同 key 的多条排队
+                    // 任务在 queuedTasks/taskIndex/queueCardMessages 三处 lookup 里互相
+                    // 顶替（2026-10-08 线上：连点 Compact 三次 → 三张卡都显示「第 1 位」、
+                    // 两张永久停在「等待中」，只压缩一次）。
+                    messageId: router.mintQueueTaskKey('card', actionValue.cmd),
+                    // 卡片 messageId 仍然要留着当回复目标：排队卡要回复到被点击的卡片，
+                    // 内部 key 不是合法飞书 id（replyTo 用它会 400）。
+                    feishuReplyTo: messageId,
                     messagePreview: `card action: ${actionValue.cmd}`,
+                    // lane 占用者的展示类型：压缩类动作在排队卡上自报身份
+                    // （「正在执行: 🗜 Compact」），并据此禁用「立即执行」。
+                    kind: COMPACT_ACTION_CMDS.has(actionValue.cmd) ? 'compact' : 'command',
                     // Compact 是单向操作，排队卡不允许编辑（编辑预览无意义）。
-                    editable: actionValue.cmd !== 'compact' && actionValue.cmd !== 'resume.compact',
+                    editable: !COMPACT_ACTION_CMDS.has(actionValue.cmd),
                 },
             });
         }

package/dist/router/index.d.ts

@@ -114,8 +114,20 @@ export declare const DIRECT_RETURN_CMDS: ReadonlySet<string>;
  * 不在此列——只有卡片动作绕过了该分支。
  */
 export declare const SESSION_MUTATING_ACTION_CMDS: ReadonlySet<string>;
+/**
+ * 会产生压缩工作的卡片动作（单源）。这类条目占用 lane 时必须自报身份：
+ * 排队卡写明「正在执行: 🗜 Compact」而不是「前面还有 0 条」，并且期间禁用
+ * 「立即执行」——该按钮走 interruptCurrentRun，会连带中断正在跑的压缩
+ * （2026-10-09 线上：Compact 占 lane 期间新消息的排队卡自相矛盾，且按钮
+ * 一点就会杀掉压缩）。同时它们也不允许编辑（预览不是用户文本）。
+ */
+export declare const COMPACT_ACTION_CMDS: ReadonlySet<string>;
 export declare class CommandRouter {
-    /** Valid agent kinds — single source of truth for resume.use / resume.page / cmdResume. */
+    /**
+     * Valid agent kinds — single source of truth for resume.use / resume.page /
+     * cmdResume. 名单本体在 `runner/types.ts` 的 AGENT_KINDS（与 AgentKind 类型
+     * 同源），这里只做别名，避免人手抄第二份。
+     */
     static readonly VALID_AGENTS: readonly ["claude", "codex", "opencode", "pi", "kimi", "dsh"];
     private sessionStore;
     /** 飞书桥接实例（public：测试直接访问断言，替代 as unknown as）。 */
@@ -150,13 +162,28 @@ export declare class CommandRouter {
     /** /config 卡片编辑暂存区（public：测试直接读取断言，替代 as unknown as）。 */
     pendingConfig: AppConfig | null;
     /**
-     * Monotonic counter minting unique internal keys for order.exec enqueue
-     * actions. One order card can be clicked many times, so the Feishu card
-     * messageId is 1:N with enqueue actions and must not be reused as the queue
-     * dedup key. Date.now() alone is unsafe (two synchronous calls can share a
-     * millisecond); the counter guarantees uniqueness regardless of timing.
+     * 已见过的 /config 卡片 messageId（有界，最近的在最后）。
+     *
+     * 草稿（pendingConfig）是全局一份：/config 文本命令重开卡片时沿用同一份草稿
+     * （这是既有语义，不改）。但**视图**是每张卡一份 —— 只刷新被点击的那张，其余
+     * 卡片就停在旧视图上：用户在旧卡上看到的和点保存实际提交的是两套内容
+     * （2026-10-08 发现的缺陷）。这里记住所有交互过的 config 卡，任何一次编辑/保存
+     * 后把草稿刷到每张卡，保证「看到的就是会保存的」。
+     */
+    private configCardIds;
+    /**
+     * 排队条目身份 key 的唯一铸造计数器（order.exec 与卡片动作共用）。
+     *
+     * 一张飞书卡片可以被点击 N 次，卡片 messageId 与入队动作是 1:N；而排队
+     * 条目的身份必须与「一次入队动作」1:1（queuedTasks 的定位、queueCardMessages
+     * 的卡片更新、taskIndex 的取消判据全部按这个 key 做 lookup）。复用卡片 id
+     * 会让同 key 的多条任务互相顶替：位置显示命中最早那条兄弟、第一条开始时删掉
+     * 索引导致其余兄弟被判「已撤销」静默丢弃（2026-10-08 线上：连点 Compact
+     * 三次 → 三张排队卡都显示「第 1 位」、两张永久停在「等待中」，只压缩一次）。
+     *
+     * Date.now() 不够（两次同步调用可落在同一毫秒）；计数器与时间无关，恒唯一。
      */
-    private orderExecKeyCounter;
+    private queueTaskKeyCounter;
     /**
      * Per-user sort preference for /ws list (memory-only, not persisted).
      * Default 'recent' (most recently used first), can toggle to 'alpha'.
@@ -349,6 +376,15 @@ export declare class CommandRouter {
         orderText: string;
         internalKey: string;
     } | null;
+    /**
+     * 铸造一个排队条目身份 key（唯一铸造点）。
+     *
+     * 调用方：order.exec 文本钩子（resolveOrderExecForQueue）与入口层
+     * （index.ts）的非即时卡片动作入队。卡片 messageId 只能当「回复目标」
+     * （`taskMeta.feishuReplyTo`），不得当队列 key —— 理由见
+     * `queueTaskKeyCounter` 字段注释。
+     */
+    mintQueueTaskKey(kind: string, id?: string): string;
     /**
      * 单源：重建 order/ws 列表卡（不投递，card 进 callback 响应体用）。
      * `q` 只服务 ws 卡的关键词筛选；order 卡无此功能，不透传。
@@ -452,6 +488,19 @@ export declare class CommandRouter {
     private deliverFileToFeishu;
     /** 确保 pendingConfig 已初始化（从当前 config 克隆） */
     ensurePendingConfig(): void;
+    /**
+     * 记住一张 config 卡片 messageId（有界：超限丢最早的一张）。
+     * 无 messageId 的调用（测试/文本路径）不登记。
+     */
+    private rememberConfigCard;
+    /**
+     * 把当前草稿刷到所有已知 config 卡片上（含本次点击的那张）。
+     *
+     * 被点击的那张走 `updateCardInPlace`（失败 fallback 发新卡，保证点击必有
+     * 反馈）；其余兄弟卡走 `patchCard`（纯 best-effort，失败即从集合剔除，不再
+     * 重复打无效 PATCH，也不会因为卡片过期而反复补发新卡）。
+     */
+    private refreshConfigCards;
     /**
      * 串行化 config.* 卡片回调（2026-07-04 修复 toggle 卡死 bug）。
      *

package/dist/router/index.js

@@ -8,6 +8,7 @@ import { WorkspaceStore } from '../workspace/index.js';
 import { OrderStore } from '../order/index.js';
 import { resolveAlias } from '../order/alias-resolve.js';
 import { diffConfig, setNestedValue } from './config-diff.js';
+import { AGENT_KINDS } from '../runner/types.js';
 import { getLogger } from '../logger/index.js';
 import { stripPlaceholders } from '../inbound/placeholder.js';
 import { clampInt } from '../common/clamp.js';
@@ -339,6 +340,14 @@ export const SESSION_MUTATING_ACTION_CMDS = new Set([
     'ws.use',
     'config.save',
 ]);
+/**
+ * 会产生压缩工作的卡片动作（单源）。这类条目占用 lane 时必须自报身份：
+ * 排队卡写明「正在执行: 🗜 Compact」而不是「前面还有 0 条」，并且期间禁用
+ * 「立即执行」——该按钮走 interruptCurrentRun，会连带中断正在跑的压缩
+ * （2026-10-09 线上：Compact 占 lane 期间新消息的排队卡自相矛盾，且按钮
+ * 一点就会杀掉压缩）。同时它们也不允许编辑（预览不是用户文本）。
+ */
+export const COMPACT_ACTION_CMDS = new Set(['compact', 'resume.compact']);
 /** 单源：payload.offset → 钳位 offset（原先 9 处逐字副本）。 */
 function payloadOffset(value) {
     return Math.max(0, Math.trunc(Number(value.offset) || 0));
@@ -358,9 +367,18 @@ function searchQueryFrom(value) {
 }
 /** 卡片 cardAction payload 缺字段的统一报错文案（原先 12 处手写且已漂移出两种前缀）。 */
 const CARD_PAYLOAD_MISSING = '⚠️ 卡片 payload 缺少必要信息';
+/**
+ * 记住并同步刷新的 config 卡片数上限。一次 /config 会话里用户实际会交互的
+ * 卡片只有最近一两张，5 张足够覆盖；无上限会让长跑进程的 Set 随卡片数增长。
+ */
+const MAX_CONFIG_CARDS = 5;
 export class CommandRouter {
-    /** Valid agent kinds — single source of truth for resume.use / resume.page / cmdResume. */
-    static VALID_AGENTS = ['claude', 'codex', 'opencode', 'pi', 'kimi', 'dsh'];
+    /**
+     * Valid agent kinds — single source of truth for resume.use / resume.page /
+     * cmdResume. 名单本体在 `runner/types.ts` 的 AGENT_KINDS（与 AgentKind 类型
+     * 同源），这里只做别名，避免人手抄第二份。
+     */
+    static VALID_AGENTS = AGENT_KINDS;
     sessionStore;
     /** 飞书桥接实例（public：测试直接访问断言，替代 as unknown as）。 */
     bridge;
@@ -394,13 +412,28 @@ export class CommandRouter {
     /** /config 卡片编辑暂存区（public：测试直接读取断言，替代 as unknown as）。 */
     pendingConfig = null;
     /**
-     * Monotonic counter minting unique internal keys for order.exec enqueue
-     * actions. One order card can be clicked many times, so the Feishu card
-     * messageId is 1:N with enqueue actions and must not be reused as the queue
-     * dedup key. Date.now() alone is unsafe (two synchronous calls can share a
-     * millisecond); the counter guarantees uniqueness regardless of timing.
+     * 已见过的 /config 卡片 messageId（有界，最近的在最后）。
+     *
+     * 草稿（pendingConfig）是全局一份：/config 文本命令重开卡片时沿用同一份草稿
+     * （这是既有语义，不改）。但**视图**是每张卡一份 —— 只刷新被点击的那张，其余
+     * 卡片就停在旧视图上：用户在旧卡上看到的和点保存实际提交的是两套内容
+     * （2026-10-08 发现的缺陷）。这里记住所有交互过的 config 卡，任何一次编辑/保存
+     * 后把草稿刷到每张卡，保证「看到的就是会保存的」。
      */
-    orderExecKeyCounter = 0;
+    configCardIds = new Set();
+    /**
+     * 排队条目身份 key 的唯一铸造计数器（order.exec 与卡片动作共用）。
+     *
+     * 一张飞书卡片可以被点击 N 次，卡片 messageId 与入队动作是 1:N；而排队
+     * 条目的身份必须与「一次入队动作」1:1（queuedTasks 的定位、queueCardMessages
+     * 的卡片更新、taskIndex 的取消判据全部按这个 key 做 lookup）。复用卡片 id
+     * 会让同 key 的多条任务互相顶替：位置显示命中最早那条兄弟、第一条开始时删掉
+     * 索引导致其余兄弟被判「已撤销」静默丢弃（2026-10-08 线上：连点 Compact
+     * 三次 → 三张排队卡都显示「第 1 位」、两张永久停在「等待中」，只压缩一次）。
+     *
+     * Date.now() 不够（两次同步调用可落在同一毫秒）；计数器与时间无关，恒唯一。
+     */
+    queueTaskKeyCounter = 0;
     /**
      * Per-user sort preference for /ws list (memory-only, not persisted).
      * Default 'recent' (most recently used first), can toggle to 'alpha'.
@@ -765,6 +798,15 @@ export class CommandRouter {
             }, ctx);
             return;
         }
+        // Compact 占 lane 时拒绝「立即执行」。该动作会调 interruptCurrentRun，而它
+        // 遍历 activeRuns 时会一并中断正在跑的压缩（压缩也注册在 activeRuns 里）。
+        // 渲染层已把按钮置灰，这里是旧卡片的兜底：改动前渲染的卡仍带可点的按钮。
+        // 放在存在性检查之后：目标已失效时，上一条「不在队列中」的反馈更准确。
+        const laneOccupant = this.bridge.getQueueExecutingInfo(cwd);
+        if (laneOccupant?.kind === 'compact') {
+            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:
@@ -1348,9 +1390,23 @@ export class CommandRouter {
         this.orderStore.updateUsedAt(order.id);
         return {
             orderText: order.text,
-            internalKey: `order-${order.id}-${this.orderExecKeyCounter++}`,
+            internalKey: this.mintQueueTaskKey('order', order.id),
         };
     }
+    /**
+     * 铸造一个排队条目身份 key（唯一铸造点）。
+     *
+     * 调用方：order.exec 文本钩子（resolveOrderExecForQueue）与入口层
+     * （index.ts）的非即时卡片动作入队。卡片 messageId 只能当「回复目标」
+     * （`taskMeta.feishuReplyTo`），不得当队列 key —— 理由见
+     * `queueTaskKeyCounter` 字段注释。
+     */
+    mintQueueTaskKey(kind, id) {
+        this.queueTaskKeyCounter += 1;
+        return id === undefined
+            ? `queue-${kind}-${this.queueTaskKeyCounter}`
+            : `${kind}-${id}-${this.queueTaskKeyCounter}`;
+    }
     /**
      * 单源：重建 order/ws 列表卡（不投递，card 进 callback 响应体用）。
      * `q` 只服务 ws 卡的关键词筛选；order 卡无此功能，不透传。
@@ -1742,6 +1798,44 @@ export class CommandRouter {
             this.pendingConfig = structuredClone(this.config);
         }
     }
+    /**
+     * 记住一张 config 卡片 messageId（有界：超限丢最早的一张）。
+     * 无 messageId 的调用（测试/文本路径）不登记。
+     */
+    rememberConfigCard(messageId) {
+        if (!messageId)
+            return;
+        this.configCardIds.delete(messageId);
+        this.configCardIds.add(messageId);
+        while (this.configCardIds.size > MAX_CONFIG_CARDS) {
+            const oldest = this.configCardIds.values().next().value;
+            if (oldest === undefined)
+                break;
+            this.configCardIds.delete(oldest);
+        }
+    }
+    /**
+     * 把当前草稿刷到所有已知 config 卡片上（含本次点击的那张）。
+     *
+     * 被点击的那张走 `updateCardInPlace`（失败 fallback 发新卡，保证点击必有
+     * 反馈）；其余兄弟卡走 `patchCard`（纯 best-effort，失败即从集合剔除，不再
+     * 重复打无效 PATCH，也不会因为卡片过期而反复补发新卡）。
+     */
+    async refreshConfigCards(ctx) {
+        this.rememberConfigCard(ctx.messageId);
+        const card = this.buildConfigCard().card;
+        if (!card)
+            return;
+        for (const messageId of [...this.configCardIds]) {
+            if (messageId === ctx.messageId) {
+                await this.bridge.updateCardInPlace(card, ctx);
+                continue;
+            }
+            const ok = await this.bridge.patchCard(messageId, card);
+            if (!ok)
+                this.configCardIds.delete(messageId);
+        }
+    }
     /**
      * 串行化 config.* 卡片回调（2026-07-04 修复 toggle 卡死 bug）。
      *
@@ -1786,7 +1880,7 @@ export class CommandRouter {
                 try {
                     // 只改暂存区，不写盘；原地更新卡片而非发送新卡（2026-07-04）
                     this.setNestedValue(this.pendingConfig, key, !boolVal);
-                    await this.bridge.updateCardInPlace(this.buildConfigCard().card, ctx);
+                    await this.refreshConfigCards(ctx);
                 }
                 catch (err) {
                     await this.bridge.sendResult({ text: `设置失败: ${err.message}` }, ctx);
@@ -1810,7 +1904,7 @@ export class CommandRouter {
                     for (const patch of patches) {
                         this.setNestedValue(this.pendingConfig, patch.key, patch.value);
                     }
-                    await this.bridge.updateCardInPlace(this.buildConfigCard().card, ctx);
+                    await this.refreshConfigCards(ctx);
                 }
                 catch (err) {
                     await this.bridge.sendResult({ text: `设置失败: ${err.message}` }, ctx);
@@ -1841,7 +1935,7 @@ export class CommandRouter {
                     for (const patch of patches) {
                         this.setNestedValue(this.pendingConfig, patch.key, patch.value);
                     }
-                    await this.bridge.updateCardInPlace(this.buildConfigCard().card, ctx);
+                    await this.refreshConfigCards(ctx);
                 }
                 catch (err) {
                     await this.bridge.sendResult({ text: `设置失败: ${err.message}` }, ctx);
@@ -1873,7 +1967,7 @@ export class CommandRouter {
                     try {
                         // host 可能已变更 → 重新预取 DSH 目录（内部按 host 缓存，未变不重复拉）
                         await this.prefetchConfigCardCatalogs();
-                        await this.bridge.updateCardInPlace(this.buildConfigCard().card, ctx);
+                        await this.refreshConfigCards(ctx);
                     }
                     catch (refreshErr) {
                         getLogger().warn(`[router] config.save 卡片刷新失败（保存已成功）: ${refreshErr.message}`);