lark-remote 0.4.5 → 0.5.1

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';
@@ -18,13 +19,13 @@ import { InboundMediaHandler } from './inbound-media.js';
  * Max events to read for the completion notification card (mirror router's
  * AUTO_RESUME_MAX_EVENTS = 5). Without a cap, readSessionContent returns every
  * event after the last user message and the card blows past Feishu's 28KB
- * budget (review §P1-21).
+ * budget.
  */
 const COMPLETION_NOTIFICATION_MAX_EVENTS = 5;
 /** Approval request timeout (ms) — pending approval expires after this. */
 const APPROVAL_TIMEOUT_MS = 5 * 60 * 1000;
 /**
- * runner 缓存的工作区数量上限（review P3-3）：超过后创建新工作区槽位时
+ * runner 缓存的工作区数量上限：超过后创建新工作区槽位时
  * 顺带回收「非 active 且进程已停」的死缓存，防止随访问过的工作区数量
  * 无界增长。活进程/在途 run 一律保留（workspace-lifetime 长驻连接不能误杀）。
  */
@@ -50,12 +51,18 @@ function terminalReactionEmoji(terminal) {
     return TERMINAL_REACTION_EMOJI[terminal] ?? 'Done';
 }
 /**
- * W2.4 单点化：`'runCompact' in runner` 鸭子探测（compact 按钮门控，
- * design doc §6.2-2）。codex app-server + kimi/opencode ACP runner 满足。
+ * 单点化：`'runCompact' in runner` 鸭子探测
+ * codex app-server + kimi/opencode ACP runner 满足。
  */
 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).
@@ -98,7 +105,7 @@ export class Bridge {
      */
     runners = new Map();
     /**
-     * Runner 槽位在「活跃运行期间配置变更」时被标 stale（CC-06/P1）：clearRunners() 对
+     * Runner 槽位在「活跃运行期间配置变更」时被标 stale：clearRunners() 对
      * 活跃 cwd 只标 stale、不立即 evict（避免误杀长驻连接），当前 run 结束后由
      * finalizeRun 安全 evict+dispose，下一轮 getRunner 创建新配置的 runner。
      * key 为 `${cwd}\u0000${agentKind}`。
@@ -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
@@ -150,7 +163,7 @@ export class Bridge {
         if (workspaceMap?.has(kind)) {
             return workspaceMap.get(kind);
         }
-        // review P3-3：缓存超过上限且是新工作区时才回收死槽位——刚创建未 run
+        // 缓存超过上限且是新工作区时才回收死槽位——刚创建未 run
         // 的 runner 同样是 isRunning=false，小缓存下立即回收会破坏「创建即注册」
         // 的既有语义（exit-dispatcher 计数回归）。
         if (this.runners.size >= MAX_CACHED_RUNNER_WORKSPACES && !this.runners.has(cwd)) {
@@ -241,13 +254,13 @@ export class Bridge {
                 return undefined;
         }
     }
-    /** Get the current runner for a cwd. Used by router for agent-specific commands (P3.2). */
+    /** Get the current runner for a cwd. Used by router for agent-specific commands (.2). */
     getCurrentRunner(cwd) {
         return this.getRunner(cwd);
     }
     /**
      * Whether the runner for the given agent kind has runCompact capability.
-     * Used by router for compact button gating (design doc §6.2-2: duck-typing
+     * Used by router for compact button gating (duck-typing
      * instead of hardcoding agentKind === 'codex').
      */
     hasRunCompact(cwd, kind = this.config.defaultAgent) {
@@ -255,8 +268,8 @@ export class Bridge {
         return runnerHasRunCompact(runner);
     }
     /** 入队时刻快照：当前 defaultAgent + 该 agent 的 sessionId（无 session 则 undefined）。
-     *  唯一捕获点：排队消息在 T0 把 agent+session 钉进 AgentBinding，随任务闭包带到 T1
-     *  执行时刻，避免 /new、/config 在排队期间改写 live 状态导致语义漂移（方案 D4）。 */
+     *  唯一捕获点：排队消息在入队时刻把 agent+session 钉进 AgentBinding，随任务闭包带到执行时刻
+     *  执行时刻，避免 /new、/config 在排队期间改写 live 状态导致语义漂移。 */
     currentBinding(userId) {
         const agent = this.config.defaultAgent;
         return {
@@ -278,7 +291,7 @@ export class Bridge {
         // ends, and the next run picks up the new config/agent via getRunner.
         for (const cwd of [...this.runners.keys()]) {
             if (this.activeRuns.has(cwd)) {
-                // CC-06/P1: 活跃 cwd 不能立即 evict（会误杀长驻连接），但必须标记 stale，
+                // 活跃 cwd 不能立即 evict（会误杀长驻连接），但必须标记 stale，
                 // 否则 finalizeRun 对 workspace-lifetime runner 也不 evict → 下一轮复用旧配置实例。
                 // 这里只标待淘汰，当前 run 结束后由 finalizeRun 安全 evict。
                 for (const kind of [...this.runners.get(cwd).keys()]) {
@@ -294,7 +307,7 @@ export class Bridge {
     }
     /**
      * Evict a (cwd, agentKind) runner cache slot. Unregisters the runner from the
-     * process-level exit dispatcher first (P1-1: without removal the singleton
+     * process-level exit dispatcher first (without removal the singleton
      * Set<Runner> retains every historical runner instance, so memory still grows
      * with run count), then deletes the slot. Every runner-discarding path
      * (clearRunners / finalizeRun / interruptCurrentRun) must go through this.
@@ -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);
@@ -535,7 +555,7 @@ export class Bridge {
                 // below may outlive the task's settle, letting the serial chain advance
                 // to a successor that begins executing before we resume. An
                 // unconditional reset would then zero the successor's count and mark
-                // its slot interrupted, hiding it from queue cards (A22).
+                // its slot interrupted, hiding it from queue cards.
                 const stoppedSlot = this.queueManager.getExecutingSlot(cwd);
                 await Promise.allSettled([
                     // 用户主动中断（/stop、stop 卡按钮、queue.immediate）显式打标
@@ -551,8 +571,8 @@ export class Bridge {
                     this.activeRuns.delete(cwd);
                 }
                 // Fix 4: Clean up this specific (cwd, agentKind) runner slot
-                // (P1-1: eviction must also unregister the runner from the exit dispatcher)
-                // P2-3: evict by the run's captured agentKind, not the live
+                // (eviction must also unregister the runner from the exit dispatcher)
+                // evict by the run's captured agentKind, not the live
                 // defaultAgent (may have changed mid-run via /config).
                 this.evictRunnerSlot(cwd, active.agentKind);
                 // Reset queue executing count: the task was interrupted externally, so
@@ -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 {
@@ -709,9 +749,9 @@ export class Bridge {
      * updates the same run card, and terminal events finalize that card.
      */
     async forwardToClaude(message, ctx, opts) {
-        // D5: agentKind 一律来自绑定。无 binding 时保持现状（live defaultAgent）。
+        // agentKind 一律来自绑定。无 binding 时保持现状（live defaultAgent）。
         const agentKind = opts?.binding?.agent ?? this.config.defaultAgent;
-        // P1-14: lane 与执行 cwd 同源。消息入队时（index.ts 闭包）捕获的 cwd
+        // lane 与执行 cwd 同源。消息入队时（index.ts 闭包）捕获的 cwd
         // 作为 cwdOverride 显式传入；执行时若 sessionStore cwd 已被 /cd 等命令改写，
         // 以 lane 为准 —— 否则旧 lane 的排队消息会被 busy-drop 静默丢失。空串视为
         // 未提供（与入队前无 cwd 的兜底语义一致）。
@@ -732,12 +772,12 @@ export class Bridge {
         }
         // Note: Multiple workspaces can have runs in parallel. If runner is busy,
         // runner.run() will throw and we'll catch it below.
-        // D2/D5: sessionId 钉死语义——binding 有 sessionId 时用它（入队时刻快照），
+        // sessionId 钉死语义——binding 有 sessionId 时用它（入队时刻快照），
         // 否则跟随 live store（无 binding 或入队时无 session 的正常路径）。
         const sessionId = opts?.binding?.sessionId ?? this.sessionStore.getSessionId(ctx.userId, agentKind);
         // 会话代际快照（2026-08-09，2026-10-07 前移）：/new、/cd、/resume 会 bump
         // epoch，该 run 后续 system.init 的 sessionId 写回即判 stale 跳过。
-        // 快照点优先取 binding.sessionEpoch（入队/commit 时刻 T0，与 sessionId 同刻）：
+        // 快照点优先取 binding.sessionEpoch（入队/commit 时刻，与 sessionId 同刻）：
         // 排队消息在「commit 后、开跑前」被 reset 时，执行起点捕获会漏判（epoch 已是
         // bump 后的值）→ 旧 sessionId 被写回复活 reset。无 binding 时回退执行起点捕获，
         // 保持非排队路径（如 /compact）的既有语义。
@@ -761,8 +801,8 @@ export class Bridge {
     createRunSession(ctx, cwd, runner, agentKind = this.config.defaultAgent) {
         const runId = randomUUID();
         getLogger().debug(`[lark-remote] creating runCard runId=${runId}`);
-        // D5: agentKind 来自入队绑定（forwardToClaude 解析），不再读 live config。
-        // 缓存键 (cwd, agentKind) 和 eviction 都用这个值（review P2-3）。
+        // agentKind 来自入队绑定（forwardToClaude 解析），不再读 live config。
+        // 缓存键 (cwd, agentKind) 和 eviction 都用这个值。
         const cardSession = new RunCardSession({
             connector: this.connector,
             chatId: ctx.chatId,
@@ -790,7 +830,7 @@ export class Bridge {
         return { runId, cardSession, activeRun };
     }
     /**
-     * §9.12 空闲看门狗：单 interval + 截止时间判定（P2-1），普通 run 与 compact
+     * §9.12 空闲看门狗：单 interval + 截止时间判定，普通 run 与 compact
      * 共用同一套兜底。事件到达只 `touch()` 刷新时间戳（无 timer 操作）；静默超过
      * `idleTimeoutMs` 才 finish('idle_timeout') + runner.stop()，让该工作区的串行
      * 队列继续推进（否则一个挂死的 run 永久堵住后续消息）。
@@ -839,7 +879,7 @@ export class Bridge {
      * Handles idle watchdog, event processing, session sync, and state transitions.
      */
     async runAgentStreamToEnd(runner, cardSession, sessionId, sessionEpochAtStart, ctx, cwd, runId, message, agentKind = this.config.defaultAgent) {
-        // Runner 声明的 usage 权威来源（review P3-7）：codex app-server = 'live'
+        // Runner 声明的 usage 权威来源：codex app-server = 'live'
         // （turn/started 的 tokenUsage.last 是本 turn 增量）。其余 runner 未声明。
         const usageAuthority = runner.getUsageAuthority?.();
         // §9.12 空闲看门狗：判定口径见 startIdleWatchdog；武装点在 cardSession.start() 之后。
@@ -914,7 +954,7 @@ export class Bridge {
                 // Card session did not enter running state - still try to send static fallback
                 getLogger().info(`[lark-remote] cardSession not running, using static fallback`);
             }
-            // P2-1: 单 interval 看门狗。事件到来时只刷新时间戳（无 timer 操作）；
+            // 单 interval 看门狗。事件到来时只刷新时间戳（无 timer 操作）；
             // interval 周期检查静默时长，超时才 finish('idle_timeout') + stop()。
             // 武装点在建卡之后，与原实现一致（宽限期不含 cardSession.start() 耗时）。
             watchdog = this.startIdleWatchdog({
@@ -955,8 +995,8 @@ export class Bridge {
                         getLogger().info(`[lark-remote] system.init write-back skipped: session pointer moved since run start runId=${runId} sessionId=${event.session_id}`);
                     }
                     else {
-                        // L5: Use session's real directory from event.cwd (not runner's cwd parameter)
-                        // L3: guard empty string too -- `??` only catches null/undefined, but a
+                        // Use session's real directory from event.cwd (not runner's cwd parameter)
+                        // guard empty string too -- `??` only catches null/undefined, but a
                         // translator (or older build) may emit cwd="", which must NOT overwrite
                         // the good runner cwd.
                         const hasCwd = !!this.sessionStore.getCwd(ctx.userId);
@@ -1028,7 +1068,7 @@ export class Bridge {
                         : `[lark-remote] result event received runId=${runId}`);
                     // app-server 模式 setup 失败路径（thread/start 成功后 turn/start 失败）
                     // 不会有 turn_started 事件，store 不会写回新线程 id；runner 已在 result
-                    // 里兜底上报（review P3-10）。此处仅当 runner 声明 live usage（app-server）
+                    // 里兜底上报。此处仅当 runner 声明 live usage（app-server）
                     // 且会话指针未动时写回，避免下条消息再开一个孤儿线程。其余 agent 不在
                     // 此列（它们各自有 system.init / turn_started 写回）。
                     if (usageAuthority === 'live' &&
@@ -1121,7 +1161,7 @@ export class Bridge {
                     const coordinator = this.approvalCoordinators.get(runId);
                     coordinator?.updateView(event.requestId, event.view);
                 }
-                // §9.12 红线（§P1-2 方案 A）：每个事件（含 result）无条件刷新
+                // §9.12 红线：每个事件（含 result）无条件刷新
                 // lastEventTs 重新武装看门狗。result 后 CLI 进程做 jsonl flush/清理（finalizing
                 // 过渡）期间，宽限期恢复为完整的 idleTimeoutMs，避免已产出结果的 turn 被误标
                 // idle_timeout。旧实现 `else { resetIdle(); }` 漏掉 result 分支。
@@ -1129,9 +1169,9 @@ export class Bridge {
                 await cardSession.push(event);
             }
             getLogger().info(`[lark-remote] runner stream end runId=${runId} sawResult=${sawResult}`);
-            // §9.12 红线（§P1-2 方案 A 第 2 点）：for-await 自然结束 = CLI 已退出，
+            // §9.12 红线：for-await 自然结束 = CLI 已退出，
             // 看门狗使命结束，立即摘除 interval（不再等 finally），堵掉「stream 已结束、
-            // 收尾处理跨过死线被误标 idle_timeout」的同源小窗口（P2-4 随本修复一并关闭）。
+            // 收尾处理跨过死线被误标 idle_timeout」的同源小窗口（随本修复一并关闭）。
             watchdog?.stop();
             // stream 结束 = CLI 退出 = jsonl 已落盘。读 jsonl 拿准确的 contextLength + compactCount：
             // live stream-json 不发 compact_boundary，live contextLength 会被 result 的 input+output 兜底失真。
@@ -1210,7 +1250,7 @@ export class Bridge {
         }
         catch (err) {
             getLogger().error(`[lark-remote] claude run error runId=${runId}:`, err);
-            // P1-11 双保险：run() 的 finally 已负责杀子进程，但 catch 路径再补一次
+            // 双保险：run() 的 finally 已负责杀子进程，但 catch 路径再补一次
             // runner.stop()（与 bash 路径对齐），覆盖任何 finally 之外的残留窗口。
             try {
                 await runner.stop();
@@ -1299,7 +1339,7 @@ export class Bridge {
             this.finishTurnReactions(ctx, terminalReactionEmoji(cardSession.currentState.terminal));
         }
         finally {
-            // P1-13: cleanup must survive mid-finalize errors. The only unguarded
+            // cleanup must survive mid-finalize errors. The only unguarded
             // expression in finalizeRun is the renderRunCard(...) argument evaluated
             // at the sendResult call site; if it throws, the run must still release
             // its activeRuns slot — otherwise the cwd is permanently busy
@@ -1312,7 +1352,7 @@ export class Bridge {
                 // evicted+disposed by clearRunners (/config) and interruptCurrentRun
                 // (/stop). Spawn-per-message runners are evicted as before to prevent
                 // stale process references accumulating.
-                // CC-06/P1: 配置变更期间（clearRunners 标了 stale）的 workspace-lifetime
+                // 配置变更期间（clearRunners 标了 stale）的 workspace-lifetime
                 // runner 也必须在 run 结束后 evict，否则下一轮复用旧配置实例。
                 const slotKey = `${cwd}\u0000${activeRun.agentKind}`;
                 if (activeRun.runner.lifetime !== 'workspace' || this.staleRunnerSlots.has(slotKey)) {
@@ -1322,7 +1362,7 @@ export class Bridge {
                 // Compact 卡片需要 runId + sessionId；record 供终态卡上的 Compact 按钮
                 // 校验与取参（activeRuns 已清空，无法再查到）。异常退出（error/
                 // interrupted/idle_timeout）同样记录——上下文往往更大，压缩后再续。
-                // §6.2-3：写入条件从「codex 终态」放宽为「runner 有 runCompact 的终态」
+                // 写入条件从「codex 终态」放宽为「runner 有 runCompact 的终态」
                 // （codex app-server + kimi acp 均满足）。
                 const runTerminal = cardSession.currentState.terminal;
                 const runnerHasCompact = runnerHasRunCompact(activeRun.runner);
@@ -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}`);
@@ -1354,7 +1390,7 @@ export class Bridge {
      */
     async sendCompletionNotificationCard(sessionId, cwd, ctx, agentKind = this.config.defaultAgent) {
         try {
-            // P1-21: cap the events read for the notification card — without
+            // cap the events read for the notification card — without
             // maxEvents claude returns every event after the last user message and
             // the card blows past Feishu's 28KB budget.
             const content = this.sessionReaderRegistry.get(agentKind).readSessionContent(sessionId, cwd, {
@@ -1374,7 +1410,7 @@ export class Bridge {
                 actions: [resumeUseButton(sessionId, agentKind)],
                 headerTemplate: 'green',
             });
-            // P1-21: send through sendResult so enforceCardBudget guards the card
+            // send through sendResult so enforceCardBudget guards the card
             // (previously sent via connector directly, bypassing the budget — long
             // sessions produced >28KB cards that Feishu silently rejected).
             const sent = await this.sendResult({ card }, ctx);
@@ -1399,7 +1435,7 @@ export class Bridge {
     withCoordinator(runId, fn) {
         const coordinator = this.approvalCoordinators.get(runId);
         if (!coordinator) {
-            // P2-7: run 已结束（coordinator 已释放）时点击审批按钮必须给用户明确反馈，
+            // run 已结束（coordinator 已释放）时点击审批按钮必须给用户明确反馈，
             // 不能静默。router 会把该异常转成 error toast。
             getLogger().warn(`[lark-remote] no approval coordinator for runId=${runId.slice(0, 8)}`);
             throw new Error('任务已结束，审批无法响应');
@@ -1463,7 +1499,7 @@ export class Bridge {
         return this.withCoordinator(opts.runId, (coordinator) => coordinator.submitAnswers({ questionIndex: opts.questionIndex }, { requestId: opts.requestId, nonce: opts.nonce }));
     }
     /**
-     * Claude AskUserQuestion 自定义答案（Other，review P3-4）：自由文本直接
+     * Claude AskUserQuestion 自定义答案（Other）：自由文本直接
      * 作为该单选问题的答案提交。路由到 ApprovalCoordinator.answerCustom。
      */
     async handleApprovalAnswerCustom(opts) {
@@ -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,
         });
@@ -1599,7 +1668,7 @@ export class Bridge {
                 agentKind,
             },
         });
-        // A6：压缩与普通 run 共用同一套生命周期——注册进 activeRuns（/stop 有对象可停、
+        // 压缩与普通 run 共用同一套生命周期——注册进 activeRuns（/stop 有对象可停、
         // /active 看得见）、挂 §9.12 空闲看门狗、终态后补 reaction。缺任何一环，卡住的
         // 压缩都只能等 runner 级超时，用户既停不掉也看不出它还在跑。
         const activeRun = {
@@ -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 /
@@ -1845,10 +1915,11 @@ export class Bridge {
             }
             for await (const event of bashRunner.run(command, { cwd })) {
                 if (event.type === 'stdout') {
-                    // P1-4 层④：bridge 本地 output 也必须 store-time 截断——仅 session state
-                    // 有界并不会让 `output +=` 自然有界（review 第④条表述不成立），!yes 洪峰
-                    // 下本地字符串仍全量驻留。capBashOutput 增量调用 O(CAP+chunk)，不会带回
-                    // O(n²) 截断成本（output 恒 ≤ CAP，拼接后 ≤ CAP+chunk 再 slice 尾部）。
+                    // 层④：bridge 本地 output 也必须 store-time 截断——仅 session state
+                    // 有界并不会让 `output +=` 自然有界（「store 有界则本地拼接自然有界」
+                    // 不成立），!yes 洪峰下本地字符串仍全量驻留。capBashOutput 增量调用
+                    // O(CAP+chunk)，不会带回 O(n²) 截断成本（output 恒 ≤ CAP，拼接后
+                    // ≤ CAP+chunk 再 slice 尾部）。
                     output = capBashOutput(output + event.content);
                     await cardSession.update({ output, stderr });
                 }
@@ -1884,7 +1955,7 @@ export class Bridge {
             const settleResult = await cardSession.settle();
             if (settleResult === 'unsent') {
                 // Stream never established a card — send a static terminal card as fallback.
-                // Use 2.0 schema to match the streaming card (M2: avoid 2.0→1.x downgrade).
+                // Use 2.0 schema to match the streaming card (avoid 2.0→1.x downgrade).
                 try {
                     await this.connector.sendWithRetry(ctx.chatId, { card: renderBashCard(cardSession.currentState, {}) }, { replyTo: ctx.messageId });
                 }