lark-remote 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -5,6 +5,22 @@ 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.1] - 2026-10-09
+
+### 修复
+
+- **旧卡片上的 Compact 按钮点下去不再报「该任务已结束或不属于当前会话」**：Compact 按钮只带本轮 run 的标识，此前按「每个工作目录最新一条 run」反查会话，而 compact 动作走串行队列——排队期间后续 run 收尾会覆盖那一个槽位，旧卡片于是必然失效。现在每条 run 收尾时按自己的标识记下会话与 agent，按钮自证身份，排队多久都不失效；Compact 也改为按该 run 自己的目录反查，中途切过目录不会压错会话
+- **同一会话的多条排队卡片不再互相顶掉**：队列条目此前复用飞书卡片的消息 id 当身份，同一会话里多条卡片撞同一个 key，先入队的那条被后面的覆盖、状态更新串到别的卡片上。改为每次入队铸造独立身份
+- **排队卡片会说清「在等谁」**：Compact 与普通消息共用同一条串行队列，Compact 占着执行位时新消息卡片仍写「位置: 第 1 位 / 前面还有: 0 条」，看着像马上就能轮到自己。现在没有等待中的消息时头部改为「等待当前任务结束」、正文写明正在执行的是 Compact 并收起位置行；占用者是 Compact 时「⚡ 立即执行」在渲染层置灰、执行层再加一道守卫，「❌ 撤销」保持可用
+- **codex 多 agent 会话不再把会话指针写坏**：codex app-server 会把子 agent 的开轮通知一起推过来，此前不判断归属，子线程的事件覆盖了本轮的线程标识，顶层会话指针被写成子线程标识——该值在会话索引里不是键，之后恢复会话报 `cannot resume an unloaded multi-agent v2 sub-agent`，`/restart` 也救不回来。现在通知按线程归属过滤；审批结算仍按请求标识走，子 agent 的审批照常可以回答
+- **带 `dsh` 的卡片不再静默退回默认 agent**：agent 名单此前被手抄成多份并发生漂移，收敛为单一来源、校验由该名单派生，消除「用错 reader → 未找到 session」的静默降级
+
+### 变更
+
+- **消除两处宿主环境相关的测试假红**：宿主带上本机没有的 locale（macOS 常见的 `LC_ALL=C.UTF-8`）时，bash 每次启动都往 stderr 打 setlocale 警告，让输出断言随机变红，测试 setup 阶段现在剔掉该变量（保留 UTF-8 解析所需项）；JSON-RPC 退出计时用例的计时起点从进程启动改到收到 `initialize` 应答，慢速 Windows runner 上不再因启动耗时超过阈值而误红
+- **英文架构文档补齐**：`docs/en/architecture/design.md` 增补与中文侧对应的五个章节，英中两侧不再不对称
+- **注释与用例名清理**：延续上一版的清理，去掉剩余指向未发布文档的引用与评审编号，并修正清理过程中留下的残句。无行为变化
+
 ## [0.5.0] - 2026-10-07
 
 ### 新增

package/dist/bridge/index.d.ts

@@ -4,8 +4,8 @@ import type { SessionReaderRegistry, SessionStore } from '../session/index.js';
 import type { AppConfig } from '../config/index.js';
 import { type RunCardChannel } from '../card/run-card-session.js';
 import type { RunTerminal } from '../card/run-state.js';
-import type { AgentKind } from '../runner/types.js';
-import { QueueManager, type QueuedTask, type EnqueueOptions, type AgentBinding } from './queue-manager.js';
+import { type AgentKind } from '../runner/types.js';
+import { QueueManager, type QueuedTask, type EnqueueOptions, type AgentBinding, type ExecutingInfo } from './queue-manager.js';
 import type { InboundMediaPayload } from '../connector/index.js';
 import type { MediaOutcome } from '../inbound/turn.js';
 /**
@@ -141,10 +141,16 @@ export declare class Bridge {
     /** Approval coordinators keyed by runId. */
     private approvalCoordinators;
     /**
-     * 最近一次已完成的、runner 有 runCompact 的 run（按 cwd）。run 结束后
-     * activeRuns 已清空，Compact 需要它来校验 runId 并提供 sessionId。
+     * 最近若干次已完成的、runner 有 runCompact 的 run（cwd → runId → 记录）。
+     * run 结束后 activeRuns 已清空，而终态卡上的 Compact 按钮只带 runId，
+     * 需要它反查 sessionId + agentKind。
+     *
+     * 为什么按 runId 存而不是「每 cwd 只留最新一条」：compact 卡片动作走串行
+     * 队列（会被正在跑的 run 挡住），点击到执行之间可能夹着别的 run 收尾。
+     * 单槽会被覆盖 —— 旧卡片的压缩必然报「该任务已结束或不属于当前会话」，
+     * 与 session 是否还在、能否压缩无关（2026-10-08 线上缺陷）。
      */
-    private lastCompactableRun;
+    private compactableRuns;
     /**
      * Active `!` bash runs, keyed by runId (NOT cwd). Bash runs bypass the serial
      * queue and may run in parallel with claude runs / other bash runs in the same
@@ -233,6 +239,11 @@ export declare class Bridge {
         tasksAhead: number;
         isRunning: boolean;
     };
+    /**
+     * lane 当前占用者的展示信息（排队卡与「立即执行」守卫共用）。
+     * 典型用途：占用者是 Compact 时拒绝 queue.immediate，避免中断压缩。
+     */
+    getQueueExecutingInfo(cwd: string): ExecutingInfo | undefined;
     /** Remove a task from the queue by messageId. Returns true if found and removed. */
     removeFromQueue(cwd: string, messageId: string): boolean;
     /**
@@ -323,6 +334,17 @@ export declare class Bridge {
      * Returns true if the in-place update succeeded, false if it fell back.
      */
     updateCardInPlace(card: object, ctx: CommandContext): Promise<boolean>;
+    /**
+     * Best-effort in-place refresh of a KNOWN card (no fallback send).
+     *
+     * `updateCardInPlace` falls back to sending a new card when the PATCH fails,
+     * which is right for the card the user just clicked (a silent failure would
+     * leave the click with no feedback) but wrong when refreshing *sibling*
+     * cards: an expired/withdrawn card would spawn a duplicate card on every
+     * edit. Callers that fan out to several cards use this instead and drop the
+     * card id from their set on `false`.
+     */
+    patchCard(messageId: string, card: object): Promise<boolean>;
     /** Send a file to the user via Feishu. */
     sendFile(filePath: string, ctx: CommandContext): Promise<void>;
     /**
@@ -465,11 +487,27 @@ export declare class Bridge {
         text: string;
         nonce: string;
     }): Promise<void>;
+    /**
+     * 记下一次「可压缩 run」：终态卡上的 Compact 按钮点击时据此反查
+     * sessionId + agentKind。runId 是按钮自带的唯一键，同 cwd 内唯一。
+     * 超出上限按插入序淘汰最旧的一条（Map 保持插入序；重复写同一 runId
+     * 先 delete 再 set 以刷新位置）。
+     */
+    private recordCompactableRun;
+    /**
+     * 按 runId 反查可压缩 run 记录（跨 cwd 扫描）。
+     *
+     * 为什么不带 cwd 过滤：按钮属于「那一次 run」，与用户此刻在哪个工作目录、
+     * 排队期间有没有 /cd 无关。`/stop` 的 interruptCurrentRun 同样是全局按 runId
+     * 找（从不查当前 cwd），compact 与它保持一致。用当前 cwd 收窄会让「切了工作区
+     * 再点旧卡片」和「排队期间 /cd」两种情况误报「该任务已结束或不属于当前会话」。
+     */
+    private findCompactableRun;
     /**
      * Handle compact card action — trigger a compaction request for any
-     * runCompact-capable runner（codex/kimi/opencode/pi/claude，按
-     * lastCompactableRun 记录的 agentKind 路由）。Validates the run exists
-     * and is in a terminal state, then calls the runner's runCompact().
+     * runCompact-capable runner（codex/kimi/opencode/pi/claude）。按钮带的是
+     * 那次 run 的 runId，据此反查该 run 实际使用的 sessionId + agentKind
+     * + cwd（compactableRuns，按 runId 记录），再调 runner 的 runCompact()。
      */
     handleCompactAction(value: {
         runId?: string;

package/dist/bridge/index.js

@@ -11,6 +11,7 @@ import { agentDisplayName, resumeUseButton } from '../card/card-shared.js';
 import { enforceCardBudget } from '../card/card-budget.js';
 import { normalizeResultUsage } from '../runner/common/result-usage.js';
 import { BashProcessRunner } from '../runner/index.js';
+import { AGENT_KINDS } from '../runner/types.js';
 import { QueueManager, } from './queue-manager.js';
 import { ApprovalCoordinator, decisionToApprovalAction } from './approval-coordinator.js';
 import { InboundMediaHandler } from './inbound-media.js';
@@ -56,6 +57,12 @@ function terminalReactionEmoji(terminal) {
 function runnerHasRunCompact(runner) {
     return ('runCompact' in runner && typeof runner.runCompact === 'function');
 }
+/**
+ * 每个 cwd 保留的「可压缩 run」条数上限。Compact 按钮挂在终态 run 卡片上，
+ * 卡片会被后续消息不断顶上去；无上限会让长跑进程随 run 数无界增长，而用户
+ * 实际能点到的只有最近几张卡，20 条足以覆盖。
+ */
+const MAX_COMPACTABLE_RUNS_PER_CWD = 20;
 /**
  * Bridge owns the per-workspace serial processing queue (§9.6) and the
  * single-card streaming forwarding loop (§9.12 watchdog + session sync).
@@ -112,10 +119,16 @@ export class Bridge {
     /** Approval coordinators keyed by runId. */
     approvalCoordinators = new Map();
     /**
-     * 最近一次已完成的、runner 有 runCompact 的 run（按 cwd）。run 结束后
-     * activeRuns 已清空，Compact 需要它来校验 runId 并提供 sessionId。
+     * 最近若干次已完成的、runner 有 runCompact 的 run（cwd → runId → 记录）。
+     * run 结束后 activeRuns 已清空，而终态卡上的 Compact 按钮只带 runId，
+     * 需要它反查 sessionId + agentKind。
+     *
+     * 为什么按 runId 存而不是「每 cwd 只留最新一条」：compact 卡片动作走串行
+     * 队列（会被正在跑的 run 挡住），点击到执行之间可能夹着别的 run 收尾。
+     * 单槽会被覆盖 —— 旧卡片的压缩必然报「该任务已结束或不属于当前会话」，
+     * 与 session 是否还在、能否压缩无关（2026-10-08 线上缺陷）。
      */
-    lastCompactableRun = new Map();
+    compactableRuns = new Map();
     /**
      * Active `!` bash runs, keyed by runId (NOT cwd). Bash runs bypass the serial
      * queue and may run in parallel with claude runs / other bash runs in the same
@@ -383,6 +396,13 @@ export class Bridge {
     getQueueInfo(cwd) {
         return this.queueManager.getQueueInfo(cwd);
     }
+    /**
+     * lane 当前占用者的展示信息（排队卡与「立即执行」守卫共用）。
+     * 典型用途：占用者是 Compact 时拒绝 queue.immediate，避免中断压缩。
+     */
+    getQueueExecutingInfo(cwd) {
+        return this.queueManager.getExecutingInfo(cwd);
+    }
     /** Remove a task from the queue by messageId. Returns true if found and removed. */
     removeFromQueue(cwd, messageId) {
         return this.queueManager.removeFromQueue(cwd, messageId);
@@ -663,6 +683,26 @@ export class Bridge {
             return false;
         }
     }
+    /**
+     * Best-effort in-place refresh of a KNOWN card (no fallback send).
+     *
+     * `updateCardInPlace` falls back to sending a new card when the PATCH fails,
+     * which is right for the card the user just clicked (a silent failure would
+     * leave the click with no feedback) but wrong when refreshing *sibling*
+     * cards: an expired/withdrawn card would spawn a duplicate card on every
+     * edit. Callers that fan out to several cards use this instead and drop the
+     * card id from their set on `false`.
+     */
+    async patchCard(messageId, card) {
+        try {
+            await this.connector.updateCard(messageId, card);
+            return true;
+        }
+        catch (err) {
+            getLogger().debug(`[lark-remote] patchCard failed messageId=${messageId}: ${errorMessage(err)}`);
+            return false;
+        }
+    }
     /** Send a file to the user via Feishu. */
     async sendFile(filePath, ctx) {
         try {
@@ -1335,11 +1375,7 @@ export class Bridge {
                     const compactSessionId = cardSession.currentState.sessionId ??
                         this.sessionStore.getSessionId(ctx.userId, activeRun.agentKind);
                     if (compactSessionId) {
-                        this.lastCompactableRun.set(cwd, {
-                            runId: activeRun.runId,
-                            sessionId: compactSessionId,
-                            agentKind: activeRun.agentKind,
-                        });
+                        this.recordCompactableRun(cwd, activeRun.runId, compactSessionId, activeRun.agentKind);
                     }
                 }
                 getLogger().info(`[lark-remote] activeRuns.delete cwd=${cwd} runId=${runId}`);
@@ -1481,11 +1517,48 @@ export class Bridge {
         log.info(`[lark-remote] handleApprovalAnswerNote runId=${opts.runId.slice(0, 8)}... requestId=${opts.requestId} question=${opts.questionIndex}`);
         return this.withCoordinator(opts.runId, (coordinator) => coordinator.answerNote({ questionIndex: opts.questionIndex, text: opts.text }, { requestId: opts.requestId, nonce: opts.nonce }));
     }
+    /**
+     * 记下一次「可压缩 run」：终态卡上的 Compact 按钮点击时据此反查
+     * sessionId + agentKind。runId 是按钮自带的唯一键，同 cwd 内唯一。
+     * 超出上限按插入序淘汰最旧的一条（Map 保持插入序；重复写同一 runId
+     * 先 delete 再 set 以刷新位置）。
+     */
+    recordCompactableRun(cwd, runId, sessionId, agentKind) {
+        let byRunId = this.compactableRuns.get(cwd);
+        if (!byRunId) {
+            byRunId = new Map();
+            this.compactableRuns.set(cwd, byRunId);
+        }
+        byRunId.delete(runId);
+        byRunId.set(runId, { sessionId, agentKind, cwd });
+        while (byRunId.size > MAX_COMPACTABLE_RUNS_PER_CWD) {
+            const oldest = byRunId.keys().next().value;
+            if (oldest === undefined)
+                break;
+            byRunId.delete(oldest);
+        }
+    }
+    /**
+     * 按 runId 反查可压缩 run 记录（跨 cwd 扫描）。
+     *
+     * 为什么不带 cwd 过滤：按钮属于「那一次 run」，与用户此刻在哪个工作目录、
+     * 排队期间有没有 /cd 无关。`/stop` 的 interruptCurrentRun 同样是全局按 runId
+     * 找（从不查当前 cwd），compact 与它保持一致。用当前 cwd 收窄会让「切了工作区
+     * 再点旧卡片」和「排队期间 /cd」两种情况误报「该任务已结束或不属于当前会话」。
+     */
+    findCompactableRun(runId) {
+        for (const byRunId of this.compactableRuns.values()) {
+            const record = byRunId.get(runId);
+            if (record)
+                return record;
+        }
+        return undefined;
+    }
     /**
      * Handle compact card action — trigger a compaction request for any
-     * runCompact-capable runner（codex/kimi/opencode/pi/claude，按
-     * lastCompactableRun 记录的 agentKind 路由）。Validates the run exists
-     * and is in a terminal state, then calls the runner's runCompact().
+     * runCompact-capable runner（codex/kimi/opencode/pi/claude）。按钮带的是
+     * 那次 run 的 runId，据此反查该 run 实际使用的 sessionId + agentKind
+     * + cwd（compactableRuns，按 runId 记录），再调 runner 的 runCompact()。
      */
     async handleCompactAction(value, ctx) {
         const log = getLogger();
@@ -1495,36 +1568,32 @@ export class Bridge {
             await this.sendResult({ text: '⚠️ 无效的 Compact 请求，缺少 runId' }, ctx);
             return;
         }
-        const cwd = this.resolveCwd(ctx.userId);
-        if (!cwd) {
-            await this.sendResult({ text: '⚠️ 未设置工作目录' }, ctx);
-            return;
-        }
-        // 校验：run 结束后 activeRuns 已清空，用 lastCompactableRun 对照 runId。
-        const last = this.lastCompactableRun.get(cwd);
-        if (!last || last.runId !== runId) {
+        // 校验：run 结束后 activeRuns 已清空，只能靠按钮自带的 runId 反查记录。
+        // 按 runId 存（不按「最新的那一条」），点击到执行之间夹了新 run 收尾也不失效；
+        // 查找也不按「当前 cwd」收窄（见 findCompactableRun）。
+        const target = this.findCompactableRun(runId);
+        if (!target) {
             await this.sendResult({ text: '⚠️ 该任务已结束或不属于当前会话' }, ctx);
             return;
         }
-        if (!last.sessionId) {
-            await this.sendResult({ text: '⚠️ 未找到可压缩的会话' }, ctx);
-            return;
-        }
+        // 压缩必须用那次 run 自己的 cwd（session 文件 + runner 实例都按 cwd 解析）。
+        const cwd = target.cwd;
         // §5.3: kimi 压缩在途检测（wire 状态机）。第二次点击在本地毫秒级如实回答，
         // 不开卡、不发 session/prompt——否则 kimi 服务端拒绝并产生「秒回」假完成。
-        if (await this.rejectIfCompactionInFlight(last.sessionId, cwd, last.agentKind, ctx))
+        if (await this.rejectIfCompactionInFlight(target.sessionId, cwd, target.agentKind, ctx)) {
             return;
+        }
         // Check that the runner has runCompact method
-        const runner = this.getRunner(cwd, last.agentKind);
+        const runner = this.getRunner(cwd, target.agentKind);
         if (!runnerHasRunCompact(runner)) {
             await this.sendResult({ text: '⚠️ 当前运行模式不支持 Compact' }, ctx);
             return;
         }
         log.info(`[lark-remote] handleCompactAction executing runCompact for runId=${runId} cwd=${cwd}`);
         await this.streamCompact({
-            sessionId: last.sessionId,
+            sessionId: target.sessionId,
             cwd,
-            agentKind: last.agentKind,
+            agentKind: target.agentKind,
             runner,
             ctx,
         });
@@ -1731,9 +1800,10 @@ export class Bridge {
             return;
         }
         // Resolve agent kind the same way resume.use does: card value wins,
-        // otherwise fall back to defaultAgent.
-        const validAgents = ['claude', 'codex', 'opencode', 'pi', 'kimi'];
-        const agentKind = value.agent && validAgents.includes(value.agent)
+        // otherwise fall back to defaultAgent. 名单来自单源 AGENT_KINDS —— 手抄一份
+        // 必然再次漂移（这份曾经漏 dsh：带 dsh 的卡片会静默退回 defaultAgent，
+        // 用错 reader 报「未找到 session」）。
+        const agentKind = value.agent && AGENT_KINDS.includes(value.agent)
             ? value.agent
             : this.config.defaultAgent;
         // Session must exist in the current cwd (same rule as cmdResume /
@@ -1846,9 +1916,10 @@ export class Bridge {
             for await (const event of bashRunner.run(command, { cwd })) {
                 if (event.type === 'stdout') {
                     // 层④：bridge 本地 output 也必须 store-time 截断——仅 session state
-                    // 有界并不会让 `output +=` 自然有界（review 第④条表述不成立），!yes 洪峰
-                    // 下本地字符串仍全量驻留。capBashOutput 增量调用 O(CAP+chunk)，不会带回
-                    // O(n²) 截断成本（output 恒 ≤ CAP，拼接后 ≤ CAP+chunk 再 slice 尾部）。
+                    // 有界并不会让 `output +=` 自然有界（「store 有界则本地拼接自然有界」
+                    // 不成立），!yes 洪峰下本地字符串仍全量驻留。capBashOutput 增量调用
+                    // O(CAP+chunk)，不会带回 O(n²) 截断成本（output 恒 ≤ CAP，拼接后
+                    // ≤ CAP+chunk 再 slice 尾部）。
                     output = capBashOutput(output + event.content);
                     await cardSession.update({ output, stderr });
                 }

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

@@ -54,6 +54,29 @@ export interface QueuedTask {
     /** 入队时刻捕获的 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?: {
@@ -72,6 +95,12 @@ export interface EnqueueOptions {
         editable?: boolean;
         /** 入队时刻捕获的 agent+session 绑定。 */
         binding?: AgentBinding;
+        /**
+         * lane 占用者的展示类型，缺省 'message'。
+         * 'compact' 时排队卡写明「正在执行: 🗜 Compact」，并把「立即执行」置灰
+         * ——该按钮会中断压缩（见 buildQueueActionButtons）。
+         */
+        kind?: LaneTaskKind;
     };
 }
 /** Queue info for a cwd */
@@ -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.
      */
     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
@@ -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. */
@@ -199,6 +239,10 @@ export declare 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。
      */
     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,7 +323,7 @@ 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
@@ -290,5 +334,12 @@ export declare class QueueManager {
      * 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

@@ -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,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;
     }
     /**
@@ -436,8 +507,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 +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 } }],
             },
         ];
@@ -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,14 +765,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 +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/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}`);

package/dist/runner/codex/app-server/runner.d.ts

@@ -42,6 +42,8 @@ export declare class CodexAppServerRunner extends ConnectionBasedRunner<JsonRpcC
     private connectionManager;
     private currentTranslator;
     private activeThreadId;
+    /** 本轮已记录过日志的外来（子 agent）线程 id，避免逐条 delta 刷盘。 */
+    private foreignThreadIds;
     private model?;
     private modelProvider?;
     private reasoningEffort?;
@@ -91,7 +93,33 @@ export declare class CodexAppServerRunner extends ConnectionBasedRunner<JsonRpcC
      * thread/resume（按 sessionId 恢复既有线程）→ turn/start。
      */
     protected setupTurn(message: string, opts: SpawnOptions): Promise<void>;
+    /**
+     * Route one server notification into the current turn's translator.
+     *
+     * App-server 把已知线程的通知全部复用同一条 stdio 连接：agent 用
+     * multi-agent v2 派生子 agent 后，子线程的 `turn/started`、`item/*`、
+     * `turn/completed`、`thread/tokenUsage/updated` 会与本轮通知交错到达
+     * （2026-10-09 实测）。一个 turn 只属于一个线程，因此外来线程的通知一律
+     * 丢弃——否则子线程的 `turn/started` 会覆盖本轮 threadId，会话写回把子
+     * 线程 id 当成顶层会话指针存盘（冷连接 `thread/resume` 直接报
+     * "cannot resume an unloaded multi-agent v2 sub-agent"），且子线程的
+     * `turn/completed` 会提前结束本轮 run、token 用量也会串台。
+     */
     private handleNotification;
+    /**
+     * 线程归属闸门：通知是否属于本轮 turn 的线程。
+     *
+     * - 无 threadId 的通知（如部分 warning）没有线程维度可用，放行；
+     * - `serverRequest/resolved` 保持线程无关：审批按 requestId 关联（桥侧
+     *   ApprovalCoordinator 跟踪），子 agent 的审批同样必须能结算，否则卡片
+     *   上的审批条目会一直挂在 pending。
+     */
+    private belongsToActiveThread;
+    /**
+     * 每个被忽略的外来线程只记一条日志：这是会话指针被污染的入口，出问题时
+     * 必须能从日志直接看到「本轮忽略了哪些子线程」，同时避免逐条 delta 刷盘。
+     */
+    private noteForeignThread;
     private handleServerRequest;
     private buildGrantedPermissions;
     /** 拒绝权限审批：空 fileSystem + 关闭网络（真实 GrantedPermissionProfile）。 */

package/dist/runner/codex/app-server/runner.js

@@ -12,6 +12,7 @@
  */
 import { ConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { CodexAppServerTranslator } from './translator.js';
+import { NotificationMethod, } from './protocol-types.js';
 import { RpcErrorCode } from '../../common/acp/protocol-types.js';
 import { mapAnswersByIndex } from '../../question-common.js';
 import { getLogger } from '../../../logger/index.js';
@@ -102,6 +103,8 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
     connectionManager;
     currentTranslator = null;
     activeThreadId = null;
+    /** 本轮已记录过日志的外来（子 agent）线程 id，避免逐条 delta 刷盘。 */
+    foreignThreadIds = new Set();
     model;
     modelProvider;
     reasoningEffort;
@@ -171,6 +174,7 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
     clearTurnState() {
         this.currentTranslator = null;
         this.activeThreadId = null;
+        this.foreignThreadIds.clear();
     }
     async releaseConnection(cwd) {
         await this.connectionManager.release(cwd);
@@ -362,7 +366,8 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
             // 故 thread.id 可同时用作协议 threadId 与 store/session reader 的 session
             // 键（bridge 用 turn_started 通知的 threadId 写回，/resume、Compact 按此
             // 键定位 JSONL）。forked/subagent 线程二者会分叉（openai/codex#29327），
-            // 桥只把主线程作为顶层会话，不在此链路内。
+            // 桥只把主线程作为顶层会话——子线程的通知由 handleNotification 的线程
+            // 归属闸门挡掉，不会进来（见 belongsToActiveThread）。
             threadId = threadResult.thread.id;
         }
         this.activeThreadId = threadId;
@@ -372,10 +377,58 @@ export class CodexAppServerRunner extends ConnectionBasedRunner {
         const turnResult = await client.request('turn/start', turnParams);
         this.currentTurnId = turnResult.turn.id;
     }
+    /**
+     * Route one server notification into the current turn's translator.
+     *
+     * App-server 把已知线程的通知全部复用同一条 stdio 连接：agent 用
+     * multi-agent v2 派生子 agent 后，子线程的 `turn/started`、`item/*`、
+     * `turn/completed`、`thread/tokenUsage/updated` 会与本轮通知交错到达
+     * （2026-10-09 实测）。一个 turn 只属于一个线程，因此外来线程的通知一律
+     * 丢弃——否则子线程的 `turn/started` 会覆盖本轮 threadId，会话写回把子
+     * 线程 id 当成顶层会话指针存盘（冷连接 `thread/resume` 直接报
+     * "cannot resume an unloaded multi-agent v2 sub-agent"），且子线程的
+     * `turn/completed` 会提前结束本轮 run、token 用量也会串台。
+     */
     handleNotification(method, params) {
+        if (!this.belongsToActiveThread(method, params)) {
+            this.noteForeignThread(params);
+            return;
+        }
         const events = this.currentTranslator?.handleNotification(method, params) ?? [];
         this.pushEvents(events);
     }
+    /**
+     * 线程归属闸门：通知是否属于本轮 turn 的线程。
+     *
+     * - 无 threadId 的通知（如部分 warning）没有线程维度可用，放行；
+     * - `serverRequest/resolved` 保持线程无关：审批按 requestId 关联（桥侧
+     *   ApprovalCoordinator 跟踪），子 agent 的审批同样必须能结算，否则卡片
+     *   上的审批条目会一直挂在 pending。
+     */
+    belongsToActiveThread(method, params) {
+        const active = this.activeThreadId;
+        if (!active)
+            return true;
+        if (method === NotificationMethod.SERVER_REQUEST_RESOLVED)
+            return true;
+        const threadId = params?.threadId;
+        if (typeof threadId !== 'string' || threadId.length === 0)
+            return true;
+        return threadId === active;
+    }
+    /**
+     * 每个被忽略的外来线程只记一条日志：这是会话指针被污染的入口，出问题时
+     * 必须能从日志直接看到「本轮忽略了哪些子线程」，同时避免逐条 delta 刷盘。
+     */
+    noteForeignThread(params) {
+        const threadId = params?.threadId;
+        if (typeof threadId !== 'string' || threadId.length === 0)
+            return;
+        if (this.foreignThreadIds.has(threadId))
+            return;
+        this.foreignThreadIds.add(threadId);
+        getLogger().info(`[${this.logTag}] ignoring notifications from foreign thread threadId=${threadId} activeThreadId=${this.activeThreadId}`);
+    }
     handleServerRequest(id, method, params) {
         const events = this.currentTranslator?.handleServerRequest(id, method, params) ?? [];
         if (events.length === 0) {

package/dist/runner/types.d.ts

@@ -402,7 +402,16 @@ export interface Runner {
      */
     unregisterExitHandlers?(): void;
 }
-export type AgentKind = 'claude' | 'codex' | 'opencode' | 'pi' | 'kimi' | 'dsh';
+/**
+ * Agent 名单单源（运行时数组 + 类型同源，二者不可能漂移）。
+ *
+ * 历史上这份名单被手抄成多份（router 的 VALID_AGENTS、bridge 的 resume.compact
+ * 校验、各 agent 的 config builder…），漂移过：dsh 加入后 bridge 的
+ * resume.compact 仍只有 5 个，带 dsh 的 resume 卡片会静默退回 defaultAgent。
+ * 新增 agent 只改这里。
+ */
+export declare const AGENT_KINDS: readonly ["claude", "codex", "opencode", "pi", "kimi", "dsh"];
+export type AgentKind = (typeof AGENT_KINDS)[number];
 /** Unified session descriptor returned by every AgentSessionReader. */
 export interface AgentSession {
     sessionId: string;

package/dist/runner/types.js

@@ -4,5 +4,16 @@
  * 本文件包含所有 Agent 相关的类型定义，从 runner/index.ts 提取。
  * 所有下游模块应从本文件 import 类型，而非直接依赖实现。
  */
-export {};
+// =============================================================================
+// Multi-Agent Adapter Types
+// =============================================================================
+/**
+ * Agent 名单单源（运行时数组 + 类型同源，二者不可能漂移）。
+ *
+ * 历史上这份名单被手抄成多份（router 的 VALID_AGENTS、bridge 的 resume.compact
+ * 校验、各 agent 的 config builder…），漂移过：dsh 加入后 bridge 的
+ * resume.compact 仍只有 5 个，带 dsh 的 resume 卡片会静默退回 defaultAgent。
+ * 新增 agent 只改这里。
+ */
+export const AGENT_KINDS = ['claude', 'codex', 'opencode', 'pi', 'kimi', 'dsh'];
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "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",