lark-remote 0.1.4 → 0.1.6

package/dist/router/index.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import YAML from 'yaml';
-import { getConfigDir, getConfigValue, setConfigValue, setConfigValues, mapAgentKey, assertSafeKeyPart, } from '../config/index.js';
+import { getConfigDir, getConfigValue, setConfigValue, setConfigValues, getAgentConfig, mapAgentKey, assertSafeKeyPart, } from '../config/index.js';
 import { syncAgentChoices } from '../runner/index.js';
 import { WorkspaceStore } from '../workspace/index.js';
 import { OrderStore } from '../order/index.js';
@@ -11,8 +11,9 @@ import { activeRunUsage, formatUsageStats } from './utils.js';
 import { markdownDiv, sessionEventPanel } from './card-helpers.js';
 import { MAX_FILE_UPLOAD_SIZE } from '../connector/file-limits.js';
 import { atomicWrite } from '../persistence/atomic-write.js';
+import { checkLatestVersion as defaultCheckLatestVersion, isNewer as defaultIsNewer, runInstallLatest as defaultRunInstallLatest, } from '../update/index.js';
 /** Config card builder - delegates to per-agent builders */
-import { getConfigBuilder, listRegisteredAgents, sortAgentsByAvailability, } from './config/index.js';
+import { getConfigBuilder, listRegisteredAgents } from './config/index.js';
 import { probeAllAgents, getCachedAvailability } from '../runner/probe.js';
 import { buildConfigCardFromTabs } from './config/common/render.js';
 /** Max events to read for auto-resume and /resume cards.
@@ -44,7 +45,7 @@ const RESUME_CONTENT_PREFETCH = 5;
  * `New Session`、空串），都不是真实输入，不得渲染成行标题。
  */
 const RESUME_SUMMARY_PLACEHOLDERS = new Set(['', '(no user message)', '(无摘要)', 'New Session']);
-import { newSessionButton, agentDisplayName } from '../card/card-shared.js';
+import { newSessionButton, resumeCompactButton, agentDisplayName } from '../card/card-shared.js';
 /**
  * Card-action commands that must run with enqueue({ immediate: true }).
  * These bypass the serial queue and execute immediately.
@@ -95,7 +96,12 @@ export function isImmediateAction(cmd) {
         cmd === 'config.toggle' ||
         cmd === 'config.set' ||
         cmd === 'config.input' ||
-        cmd === 'config.save');
+        cmd === 'config.save' ||
+        // 审批响应/权限切换必须即时触达在途 run（同 stop 类控制动作）。若走串行
+        // 队列会排在等待审批的 run 之后形成死锁：run 不结束审批不执行，run 结束
+        // coordinator 已删响应空转（线上复现：approval.respond 排队卡、审批永不生效）。
+        cmd === 'approval.respond' ||
+        cmd === 'approval.toggle');
 }
 export class CommandRouter {
     /** Valid agent kinds — single source of truth for resume.use / resume.page / cmdResume. */
@@ -114,6 +120,12 @@ export class CommandRouter {
      */
     restartSpawner;
     idleTimeoutMs;
+    /** Dev mode flag: --dev means the bridge was started from source (bun src/index.ts). */
+    devMode;
+    /** Cache file for version checks (<configDir>/update-cache.json). */
+    updateCachePath;
+    /** Injected update functions (for testability; defaults to real implementation). */
+    updateFns;
     pendingConfig = null; // /config 卡片编辑暂存区
     /**
      * Monotonic counter minting unique internal keys for order.exec enqueue
@@ -161,6 +173,13 @@ export class CommandRouter {
             this.bridge.setIdleTimeout(this.idleTimeoutMs);
         }
         this.sessionReaderRegistry = opts.sessionReaderRegistry;
+        this.devMode = opts.devMode ?? false;
+        this.updateCachePath = opts.updateCachePath;
+        this.updateFns = {
+            checkLatestVersion: opts.updateFns?.checkLatestVersion ?? defaultCheckLatestVersion,
+            isNewer: opts.updateFns?.isNewer ?? defaultIsNewer,
+            runInstallLatest: opts.updateFns?.runInstallLatest ?? defaultRunInstallLatest,
+        };
     }
     /**
      * Resolve the active session reader for the current defaultAgent.
@@ -223,12 +242,12 @@ export class CommandRouter {
                 return;
             case 'ls.page':
                 return this.handleLsPage(value, ctx);
+            case 'ws.page':
+                return this.handleWsPage(value, ctx);
             case 'ws.use':
                 return await this.handleWsUse(value, ctx);
             case 'ws.sort':
                 return await this.handleWsSort(value, ctx);
-            case 'ws.page':
-                return await this.handleWsPage(value, ctx);
             case 'ws.remove':
                 return await this.handleWsRemove(value, ctx);
             case 'resume.use': {
@@ -305,6 +324,15 @@ export class CommandRouter {
                 // 调 updateCardInPlace → Feishu API 乱序到达导致 toggle 卡死。
                 // 2026-07-18: 返回 enqueueConfigAction 的结果以支持 toast 响应
                 return this.enqueueConfigAction(value, ctx);
+            case 'approval.respond':
+            case 'approval.toggle':
+                return this.handleApprovalAction(value, ctx);
+            case 'codex.compact':
+                await this.bridge.handleCodexCompact(value, ctx);
+                return;
+            case 'resume.compact':
+                await this.bridge.handleResumeCompact(value, ctx);
+                return;
             default: {
                 // Help card buttons: help.<cmd> → execute /<cmd>
                 if (value.cmd.startsWith('help.')) {
@@ -322,7 +350,7 @@ export class CommandRouter {
                     }
                     return;
                 }
-                // AGENTS.md red-line: miss paths must reply via bridge.sendResult —
+                // Design constraint: miss paths must reply via bridge.sendResult —
                 // don't silently swallow unknown card actions.
                 getLogger().warn(`[router] unknown card action: ${value.cmd}`);
                 await this.bridge.sendResult({ text: `⚠️ 未知的卡片操作: ${value.cmd}` }, ctx);
@@ -330,6 +358,57 @@ export class CommandRouter {
             }
         }
     }
+    /**
+     * Handle approval-related card actions.
+     * Routes to the appropriate bridge method based on value.cmd.
+     * Returns a toast response for immediate user feedback.
+     */
+    async handleApprovalAction(value, _ctx) {
+        const { runId, requestId, decision, scope, nonce, permId } = value;
+        if (value.cmd === 'approval.respond') {
+            if (!runId || requestId === undefined || !decision || !nonce) {
+                return { toast: { type: 'error', content: '缺少审批响应参数' } };
+            }
+            try {
+                await this.bridge.handleApprovalRespond({
+                    runId,
+                    requestId,
+                    decision,
+                    scope,
+                    nonce,
+                });
+                return { toast: { type: 'success', content: '审批已提交' } };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                // 审批已过期：给用户明确反馈，不静默不误导（2026-08-12 事故：点了允许无任何反馈）。
+                const content = /state=expired/.test(msg)
+                    ? '⏰ 审批已过期，无法响应'
+                    : `审批响应失败：${msg}`;
+                return { toast: { type: 'error', content } };
+            }
+        }
+        if (value.cmd === 'approval.toggle') {
+            if (!runId || requestId === undefined || !permId || !nonce) {
+                return { toast: { type: 'error', content: '缺少权限切换参数' } };
+            }
+            try {
+                await this.bridge.handleApprovalToggle({
+                    runId,
+                    requestId,
+                    permId,
+                    nonce,
+                    selected: value.selected ?? true,
+                });
+                return { toast: { type: 'info', content: '已切换' } };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { toast: { type: 'error', content: `权限切换失败：${msg}` } };
+            }
+        }
+        return { toast: { type: 'error', content: '未知的审批操作' } };
+    }
     /**
      * Handle queue.cancel: remove this message from the queue.
      */
@@ -970,9 +1049,19 @@ export class CommandRouter {
         if (useResult.text && !useResult.text.includes('已切换')) {
             return { toast: { type: 'error', content: useResult.text } };
         }
-        // Success: if auto-resume produced a card, send it as a reply
-        if (useResult.card) {
-            await this.bridge.sendResult(useResult, ctx);
+        // Success: send auto-resume card, or a persistent text confirmation when
+        // there is no history session. Toast alone is insufficient: for this
+        // immediate action the callback response is swallowed by enqueueImmediate
+        // (fire-and-forget), and even if delivered it is transient — the user gets
+        // no perceivable feedback on the switch. Same rationale as config.save
+        // agent-switch notice: persistent message first, toast only as a
+        // fallback if sendResult fails.
+        let fallbackToast;
+        if (useResult.card || useResult.text) {
+            const sent = await this.bridge.sendResult(useResult, ctx);
+            if (!sent && useResult.text) {
+                fallbackToast = useResult.text;
+            }
         }
         // Refresh the /ws list card in place so "recent" sort is immediately visible
         const currentOffset = Math.max(0, Math.trunc(Number(value.offset) || 0));
@@ -980,11 +1069,11 @@ export class CommandRouter {
         if (refreshed.card) {
             await this.bridge.updateCardInPlace(refreshed.card, ctx);
         }
-        // Toast feedback (suppress text when auto-resume card was already sent)
+        // Toast feedback (suppress text when a persistent message was already sent)
         return {
             toast: {
                 type: 'success',
-                content: useResult.card ? '' : (useResult.text ?? `已切换到 workspace "${name}"`),
+                content: fallbackToast ?? '',
             },
         };
     }
@@ -1191,7 +1280,7 @@ export class CommandRouter {
                     this.config = setConfigValues(this.configPath, this.config, updates);
                     // P1-6：运行时传播（idleTimeout / clearRunners / syncAgentChoices /
                     // defaultAgent 切换的 session 处理）抽到共享方法，与文本直写路径共用。
-                    const switchNotice = this.propagateConfigSave(oldDefaultAgent, updates, ctx);
+                    const switchResult = this.propagateConfigSave(oldDefaultAgent, updates, ctx);
                     this.pendingConfig = null;
                     // 原地更新卡片：保存后卡片刷新为已保存状态（2026-07-04）
                     // 2026-08-03: 卡片刷新失败不吞切换通知——保存已成功，仅记录日志，
@@ -1202,14 +1291,15 @@ export class CommandRouter {
                     catch (refreshErr) {
                         getLogger().warn(`[router] config.save 卡片刷新失败（保存已成功）: ${refreshErr.message}`);
                     }
-                    // 2026-08-03: agent 切换时发送持久化消息通知用户（toast 不持久化，
-                    // 聊天记录不可回溯）；发送失败（resolve false，不 throw）时兜底回退
-                    // toast 即时反馈，复用同一个切换文案。
-                    if (switchNotice) {
-                        const sent = await this.bridge.sendResult({ text: switchNotice }, ctx);
+                    // 2026-08-13: agent 切换时发送 Resume 卡片（替代纯文本通知），
+                    // 让用户直观看到新 agent 的会话状态和历史。
+                    // 发送失败（resolve false）时兜底回退 toast 即时反馈。
+                    if (switchResult.notice) {
+                        const switchCard = this.buildConfigSwitchCard(switchResult, ctx);
+                        const sent = await this.bridge.sendResult(switchCard, ctx);
                         if (!sent) {
                             return {
-                                toast: { type: 'info', content: switchNotice },
+                                toast: { type: 'info', content: switchResult.notice },
                             };
                         }
                     }
@@ -1311,7 +1401,7 @@ export class CommandRouter {
      *
      * @param updates 以 config 路径形式给出的变更 key（卡片路径来自 diffConfig；
      *   直写路径传 mapAgentKey(key)，保证 pi./codex./opencode./kimi. 命中 agents.*）。
-     * @returns defaultAgent 切换时的通知文案（未切换返回 undefined）
+     * @returns 结构化切换结果（含 notice 文案 + 新 agent/sessionId 信息）
      */
     propagateConfigSave(oldDefaultAgent, updates, ctx) {
         this.bridge.setConfig(this.config);
@@ -1336,13 +1426,12 @@ export class CommandRouter {
         // 同时清除新 agent 的 sessionId（等效于 /new 命令），
         // 并支持 session 恢复 - 切换回来时如果条件满足则恢复之前的 session。
         let switchNotice;
+        let switchNewAgent;
+        let switchSessionId;
         if (hasDefaultAgentChange) {
             const newAgent = this.config.defaultAgent;
+            switchNewAgent = newAgent;
             // Step 0: 在清空 old 之前计算「用户活动」基线差（arrival 基线）：
-            // arrivalSessions[old] 是用户最近一次经 config.save 切换「到达」该 agent
-            // 时被赋予的 session id（清空到达 = ''）。当前 session 与到达基线不一致
-            // ⇒ 用户在 oldAgent 上产生过用户活动（发消息 /resume /new /cd 等，均
-            // 不更新 arrival），离开时恢复必须被阻断。
             const oldSessionId = this.sessionStore.getSessionId(ctx.userId, oldDefaultAgent);
             const oldArrivalSessionId = this.sessionStore.getArrivalSessionId(ctx.userId, oldDefaultAgent);
             const userChangedOld = (oldSessionId ?? '') !== (oldArrivalSessionId ?? '');
@@ -1352,48 +1441,36 @@ export class CommandRouter {
             }
             // Step 2: 清除旧 agent 的 session（保存后清除，为新会话腾出空间）
             this.sessionStore.clearSessionId(ctx.userId, oldDefaultAgent);
-            // Step 2.5: 显式选择判定——sessions[new] 非空且不等于到达基线 ⇒ 用户经 /resume
-            // 显式改选了 new 的 session（/resume 不更新 arrival），切换时必须让选择存活。
-            // 优先级：显式选择 > 停车恢复 > 清空；newSessionId 为空（防御）不触发本分支。
+            // Step 2.5: 显式选择判定
             const newSessionId = this.sessionStore.getSessionId(ctx.userId, newAgent);
             const newArrivalSessionId = this.sessionStore.getArrivalSessionId(ctx.userId, newAgent);
             const userSelectedNew = !!newSessionId && (newSessionId ?? '') !== (newArrivalSessionId ?? '');
-            // Step 3: 恢复判定——previousSessions[newAgent] 存在 且 用户在 oldAgent 上
-            // 没有用户活动（session 未变于到达基线）。判断方法：arrival 基线差
-            // userChangedOld 为 false 时，oldAgent 的 session 只可能是 config.save
-            // 自动恢复/清空得到的，不构成用户活动，恢复不被阻断。
+            // Step 3: 恢复判定
             const previousSessionId = this.sessionStore.getPreviousSessionId(ctx.userId, newAgent);
             const canRestore = !!previousSessionId && !userChangedOld;
             if (userSelectedNew) {
-                // 显式选择优先于停车恢复与用户活动阻断：保留 sessions[new]（不动），更新
-                // arrival 基线为所选 session；prev[new] 停车位原样保留（下次离开时会被
-                // sessions[new] 覆盖停车）。
                 this.sessionStore.setArrivalSessionId(ctx.userId, newAgent, newSessionId);
                 const newAgentName = agentDisplayName(newAgent);
                 switchNotice = `已切换到 ${newAgentName}，已使用所选 session，sessionId: ${newSessionId}`;
+                switchSessionId = newSessionId;
             }
             else if (canRestore) {
-                // 可以恢复之前的 session
                 this.sessionStore.setSessionId(ctx.userId, newAgent, previousSessionId);
-                // 恢复分支消费 previousSessions，并记录新的到达基线（自动恢复的 session
-                // 不构成用户活动，后续离开时 userChangedOld 仍为 false）
                 this.sessionStore.clearPreviousSessionId(ctx.userId, newAgent);
                 this.sessionStore.setArrivalSessionId(ctx.userId, newAgent, previousSessionId);
                 const newAgentName = agentDisplayName(newAgent);
                 switchNotice = `已切换到 ${newAgentName}，将继续之前的 session，sessionId: ${previousSessionId}`;
+                switchSessionId = previousSessionId;
             }
             else {
-                // Step 4: 清除新 agent 的 session（等效于 /new）
                 this.sessionStore.clearSessionId(ctx.userId, newAgent, { clearSessionCwd: true });
-                // 清空分支不清除 previousSessions[newAgent]（停车语义：被拒绝的恢复
-                // 机会保留，未来无用户活动的返回仍可恢复）；记录清空到达基线
                 this.sessionStore.setArrivalSessionId(ctx.userId, newAgent, '');
                 const newAgentName = agentDisplayName(newAgent);
                 switchNotice = `已切换到 ${newAgentName}，session 已清空，下次消息将启动新对话`;
+                switchSessionId = '';
             }
         }
         // 2026-07-13: 同步 agent 配置到 agentChoices（用于切换 agent 时恢复配置）
-        // 检测是否有当前 agent 的配置变更
         const currentAgent = this.config.defaultAgent;
         const currentAgentConfigKey = `agents.${currentAgent}`;
         const hasCurrentAgentUpdate = Object.keys(updates).some((k) => k === currentAgentConfigKey || k.startsWith(`${currentAgentConfigKey}.`));
@@ -1404,11 +1481,10 @@ export class CommandRouter {
             this.bridge.setConfig(this.config);
         }
         // 2026-07-13: 任何 agent 配置变更或 defaultAgent 切换，都清除 runner 缓存
-        // 否则 runner 仍使用旧配置值
         if (hasDefaultAgentChange || hasAgentConfigChange) {
             this.bridge.clearRunners();
         }
-        return switchNotice;
+        return { notice: switchNotice, newAgent: switchNewAgent, sessionId: switchSessionId };
     }
     async executeCommand(message, ctx) {
         const parts = message.slice(1).split(/\s+/);
@@ -1453,6 +1529,9 @@ export class CommandRouter {
             case 'order':
             case 'o':
                 return this.cmdOrder(args, ctx);
+            case 'update':
+            case 'u':
+                return await this.cmdUpdate(args, ctx);
             default:
                 return { text: `未知命令 /${cmd}，输入 /help 查看可用命令` };
         }
@@ -1472,6 +1551,7 @@ export class CommandRouter {
             { cmd: 'active', label: '/active', desc: '查看所有正在进行中的 session' },
             { cmd: 'exit', label: '/exit /e', desc: '退出 bridge' },
             { cmd: 'restart', label: '/restart', desc: '重启 bridge（新进程，config 不变）' },
+            { cmd: 'update', label: '/update /u', desc: '检查并升级到最新版本' },
             { cmd: 'status', label: '/status /s', desc: '显示当前状态' },
             { cmd: 'reconnect', label: '/reconnect', desc: '重连飞书' },
         ].sort((a, b) => a.label.length - b.label.length || a.cmd.localeCompare(b.cmd));
@@ -1658,6 +1738,47 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
             return { text: `重启失败：${err.message}，旧进程仍在运行` };
         }
     }
+    /**
+     * /update: check for newer version and upgrade if available.
+     * /update check: only check, don't upgrade.
+     *
+     * Flow: check version → if newer, install → report success (no auto-restart).
+     */
+    async cmdUpdate(args, ctx) {
+        const checkOnly = args[0] === 'check';
+        // 1. Version query（/update check 始终绕过缓存，/update 用 TTL 缓存）
+        let current;
+        let latest;
+        try {
+            const result = await this.updateFns.checkLatestVersion({
+                cachePath: this.updateCachePath,
+                bypassCache: checkOnly,
+            });
+            current = result.current;
+            latest = result.latest;
+        }
+        catch (err) {
+            return { text: `❌ 版本检查失败: ${err.message}` };
+        }
+        if (!this.updateFns.isNewer(current, latest)) {
+            return { text: `✅ 已是最新版本 ${current}` };
+        }
+        if (checkOnly) {
+            return { text: `📦 有新版本 ${latest} 可用（当前 ${current}），发送 /update 升级` };
+        }
+        // 2. Dev mode guard
+        if (this.devMode) {
+            return { text: '⚠️ 开发模式不支持自更新，请 git pull 后重新构建' };
+        }
+        // 3. Install (send intermediate status before the blocking operation)
+        await this.bridge.sendResult({ text: `⬆️ 正在升级 ${current} → ${latest} ...` }, ctx);
+        const installResult = await this.updateFns.runInstallLatest();
+        if (!installResult.success) {
+            return { text: `❌ 升级失败: ${installResult.error}` };
+        }
+        // 4. Report success (no auto-restart — user decides when to /restart)
+        return { text: `✅ 升级成功 (${current} → ${latest})，发送 /restart 重启后生效` };
+    }
     cmdNew(ctx) {
         // 只清 sessionId 保留 cwd — 否则 /new 之后 /resume 会提示"请先 /cd
         // 设置工作目录"，但用户的 workspace 还在。2026-06-21 复盘：用户
@@ -1816,6 +1937,11 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
                 ],
             });
         }
+        // Compact 按钮：仅 codex app-server 模式（runner 有 runCompact）且会话未在跑。
+        // 在途 run 会占住 app-server runner，压缩必然失败，此时不渲染。
+        if (!isActive && this.canCompactSession(this.config.defaultAgent)) {
+            actions.push(resumeCompactButton(session.sessionId, this.config.defaultAgent));
+        }
         // New session button always shown (use shared function for consistency)
         actions.push(newSessionButton());
         // Use column_set+column for 2.0 (action tag not supported in 2.0)
@@ -1840,6 +1966,146 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
         };
         return { card };
     }
+    /**
+     * Build card for config.save agent switch.
+     * When the new agent has a restored session, renders a Resume card (mirrors
+     * buildAutoResumeCard) with session history + stop/new buttons.
+     * When the session was cleared, renders a compact notice card instead.
+     */
+    buildConfigSwitchCard(switchResult, ctx) {
+        const newAgent = switchResult.newAgent;
+        const agentName = agentDisplayName(newAgent);
+        const cwd = this.sessionStore.getCwd(ctx.userId);
+        const sessionId = switchResult.sessionId;
+        // No cwd or no session → compact notice card
+        if (!cwd || !sessionId) {
+            const elements = [markdownDiv(switchResult.notice)];
+            // New session button
+            elements.push({
+                tag: 'column_set',
+                columns: [
+                    {
+                        tag: 'column',
+                        width: 'auto',
+                        elements: [newSessionButton()],
+                    },
+                ],
+            });
+            return {
+                card: {
+                    schema: '2.0',
+                    config: { wide_screen_mode: true },
+                    header: {
+                        title: { tag: 'plain_text', content: `🔀 切换到 ${agentName}` },
+                    },
+                    body: { elements },
+                },
+            };
+        }
+        // Has session → Resume card (mirrors buildAutoResumeCard)
+        // Guard: if the session reader for the new agent is not available (e.g. agent
+        // not registered), fall back to compact notice card to avoid NPE.
+        const readerForNewAgent = newAgent === this.config.defaultAgent
+            ? this.sessionReader
+            : this.sessionReaderRegistry.get(newAgent);
+        if (!readerForNewAgent) {
+            // Fallback: compact notice card with the notice text
+            const elements = [markdownDiv(switchResult.notice)];
+            elements.push({
+                tag: 'column_set',
+                columns: [
+                    {
+                        tag: 'column',
+                        width: 'auto',
+                        elements: [newSessionButton()],
+                    },
+                ],
+            });
+            return {
+                card: {
+                    schema: '2.0',
+                    config: { wide_screen_mode: true },
+                    header: { title: { tag: 'plain_text', content: `🔀 切换到 ${agentName}` } },
+                    body: { elements },
+                },
+            };
+        }
+        const { events: content, usage, isActive, aiTitle, recap, displayTitle, activeRunRunId, } = this.readSessionDisplayState(sessionId, cwd, {
+            agentKind: newAgent,
+            maxEvents: AUTO_RESUME_MAX_EVENTS,
+        });
+        let header = `📂 \`${cwd}\`\n已恢复会话: **${sessionId}**`;
+        const sections = [];
+        if (displayTitle) {
+            const label = aiTitle ? 'AI 标题' : '最近输入';
+            sections.push(`🏷️ **${label}**\n${displayTitle}`);
+        }
+        if (recap) {
+            const recapPreview = recap.length > 200 ? recap.slice(0, 197) + '...' : recap;
+            sections.push(`📝 **Recap**\n${recapPreview}`);
+        }
+        if (sections.length > 0) {
+            header += '\n\n' + sections.join('\n\n──\n\n');
+        }
+        const elements = [markdownDiv(header), { tag: 'hr' }];
+        if (content.length === 0) {
+            elements.push(markdownDiv('_该会话暂无新消息可显示（最后一条为用户输入）_'));
+        }
+        else {
+            content.forEach((ev, i) => {
+                elements.push(sessionEventPanel(ev, i, content.length, 2, newAgent));
+            });
+        }
+        if (usage) {
+            const usageStr = formatUsageStats(usage, { showResult: true, result: 'success' });
+            elements.push(markdownDiv(usageStr));
+        }
+        if (elements.length > 0 && elements[elements.length - 1].tag === 'hr') {
+            elements.pop();
+        }
+        // Action buttons
+        const actions = [];
+        if (isActive) {
+            actions.push({
+                tag: 'button',
+                text: { tag: 'plain_text', content: '⏹ 终止' },
+                type: 'danger',
+                behaviors: [{ type: 'callback', value: { cmd: 'stop', runId: activeRunRunId, cwd } }],
+            });
+        }
+        actions.push(newSessionButton());
+        elements.push({
+            tag: 'column_set',
+            columns: actions.map((btn) => ({
+                tag: 'column',
+                width: 'auto',
+                elements: [btn],
+            })),
+        });
+        return {
+            card: {
+                schema: '2.0',
+                config: { wide_screen_mode: true },
+                header: {
+                    title: {
+                        tag: 'plain_text',
+                        content: `${isActive ? '⏳ 切换 Agent（完成中）' : '🔀 切换 Agent'} · ${agentName}`,
+                    },
+                },
+                body: { elements },
+            },
+        };
+    }
+    /**
+     * Whether a session of the given agent kind can be compacted from a resume
+     * card. Compact (thread/compact/start) is only implemented by the codex
+     * app-server runner (`runCompact`), so the button is gated on
+     * `serviceMode === 'app-server'` — exec mode spawns a fresh CLI per message
+     * and has no persistent session to compact.
+     */
+    canCompactSession(agentKind) {
+        return (agentKind === 'codex' && getAgentConfig(this.config, 'codex')?.serviceMode === 'app-server');
+    }
     static LS_PAGE_SIZE = 30;
     cmdLs(args, ctx, offset = 0) {
         const cwd = this.sessionStore.getCwd(ctx.userId);
@@ -2361,7 +2627,7 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
                 }
                 const card = {
                     schema: '2.0',
-                    config: { wide_screen_mode: true },
+                    config: { wide_screen_mode: true, update_multi: true },
                     header: { title: { tag: 'plain_text', content: 'Workspaces' } },
                     body: { elements: bodyElements },
                 };
@@ -2476,6 +2742,11 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
                     behaviors: [{ type: 'callback', value: { cmd: 'stop', runId: activeRunRunId, cwd } }],
                 });
             }
+            // Compact 按钮：仅 codex app-server 模式（runner 有 runCompact）且会话未在跑。
+            // agentKind 来自 /resume [agent] <id> / resume.use 卡片值，非 defaultAgent。
+            if (!isActive && this.canCompactSession(agentKind)) {
+                buttons.push(resumeCompactButton(sessionIdArg, agentKind));
+            }
             if (buttons.length > 0) {
                 elements.push({
                     tag: 'column_set',
@@ -2906,8 +3177,14 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
                 // clearRunners / syncAgentChoices / defaultAgent 切换）。key 经 mapAgentKey
                 // 归一化，pi./codex./opencode./kimi. 命中 agents.* 判定；claude. 与
                 // defaultAgent 不再漏判。
-                this.propagateConfigSave(oldDefaultAgent, { [mapAgentKey(key)]: value }, ctx);
+                const switchResult = this.propagateConfigSave(oldDefaultAgent, { [mapAgentKey(key)]: value }, ctx);
                 this.pendingConfig = null; // 命令式写盘后清空暂存，避免不一致
+                // 2026-08-13: agent 切换时额外发送 Resume 卡片
+                if (switchResult.notice) {
+                    const switchCard = this.buildConfigSwitchCard(switchResult, ctx);
+                    // 文本路径返回 config card，Resume card 通过 bridge 异步发送
+                    void this.bridge.sendResult(switchCard, ctx);
+                }
                 const card = this.buildConfigCard();
                 if (discarded > 0 && card.card && typeof card.card === 'object') {
                     const body = card.card.body;
@@ -2942,9 +3219,7 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
         // Direct inline construction (not via ConfigField) so that text (display label)
         // and value (agentKind for config storage) can differ — uninstalled agents get
         // a "⚠️ (未安装)" suffix in the label while the value stays clean.
-        // Uninstalled agents sink to the bottom; installed ones keep registration
-        // order (claude → codex → pi → opencode → kimi).
-        const allAgents = sortAgentsByAvailability(listRegisteredAgents(), getCachedAvailability);
+        const allAgents = listRegisteredAgents();
         const agentOptions = allAgents.map((kind) => {
             const available = getCachedAvailability(kind);
             const label = available === false ? `${agentDisplayName(kind)} ⚠️ (未安装)` : agentDisplayName(kind);

package/dist/router/utils.d.ts

@@ -22,6 +22,8 @@ export declare function formatUsageStats(usage?: {
     contextLength?: number;
     contextLimit?: number;
     compactCount?: number;
+    /** 压缩前上下文水位；与 contextLength（压缩后）成对出现在 Compact 卡上。 */
+    compactPreContextLength?: number;
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
     /** Agent-declared total; when present the display uses max(total, sum of parts). */

package/dist/router/utils.js

@@ -46,13 +46,16 @@ export function formatUsageStats(usage, options) {
     if (options?.showResult && options?.result) {
         lines.push(`结果 - ${options.result}`);
     }
-    // 2. Context 长度
+    // 2. Context 长度（compact 卡同时展示压缩前水位）
     if (usage?.contextLength !== undefined) {
         const ctxLimit = usage.contextLimit;
         const ctxPercent = ctxLimit !== undefined && ctxLimit > 0
             ? ` (${Math.round((usage.contextLength / ctxLimit) * 100)}%)`
             : '';
-        lines.push(`Context - ${formatTokenK(usage.contextLength)}${ctxPercent}`);
+        const preCompact = usage.compactPreContextLength !== undefined
+            ? `（压缩前 ${formatTokenK(usage.compactPreContextLength)}）`
+            : '';
+        lines.push(`Context - ${formatTokenK(usage.contextLength)}${ctxPercent}${preCompact}`);
     }
     // 3. Compact 次数
     if (usage?.compactCount) {