cursor-feedback 2.2.0 → 2.3.1

package/dist/mcp-server.js

@@ -72,6 +72,16 @@ function debugLog(message) {
     const timestamp = new Date().toISOString();
     console.error(`[${timestamp}] ${message}`);
 }
+// 包版本真相源：package.json（dist/mcp-server.js 的上一级目录）。读不到时兜底 0.0.0。
+const PKG_VERSION = (() => {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
+        return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+})();
 /**
  * MCP Feedback Server
  */
@@ -95,11 +105,14 @@ class McpFeedbackServer {
         /** 面板在超时空窗内提交的反馈：暂存到下一轮 pending 注册时立即兑现 */
         this.panelStash = null;
         /**
-         * 忙时消息队列：AI 正在干活（该项目空间没有等待中的反馈请求）时用户发来的飞书消息
+         * 忙时消息队列：AI 正在干活（该项目空间没有等待中的反馈请求）时用户发来的消息
          * 不再丢弃，而是按项目空间排队；等 AI 下一轮调 interactive_feedback 时合并送达，
-         * 并附「任务期间追加」提示头。开关见 FeishuBridge.queueWhenBusy（面板 / FEISHU_QUEUE）。
+         * 并附「任务期间追加」提示头。飞书与面板消息共用同一个队列（按到达顺序），
+         * 飞书侧开关见 FeishuBridge.queueWhenBusy（面板 / FEISHU_QUEUE）；面板排队恒可用。
          */
         this.queuedInbound = [];
+        /** 队列项 id 自增序号（配合时间戳保证进程内唯一） */
+        this.queueSeq = 0;
         /** 暂存过期提示定时器：到点仍未被认领则「回复」那条消息告知没送到，避免静默丢弃 */
         this.stashExpiryTimer = null;
         // 最近一次被飞书回复 resolve 的请求：供插件端精确区分「飞书回复」与「超时」，
@@ -135,11 +148,16 @@ class McpFeedbackServer {
         // stop() 防重入：server.close() 会触发 transport.onclose → 回调里又调 stop()，
         // 无标志位会无限递归直至 "Maximum call stack size exceeded"（日志曾刷出数万条 Stopping server...）
         this.stopping = false;
+        /**
+         * 已结束请求的结果缓存（wire id → 当时的结果）：供「迟到的重复投递」精确重放。
+         * 容量与时效都收紧（feedback 结果可能含 base64 图片，不能无限囤积）。
+         */
+        this.settledByWire = new Map();
         this.port = port;
         this.basePort = port;
         this.server = new index_js_1.Server({
             name: 'cursor-feedback-server',
-            version: '0.0.1',
+            version: PKG_VERSION,
         }, {
             capabilities: {
                 tools: {},
@@ -211,14 +229,17 @@ class McpFeedbackServer {
             };
         });
         // 处理工具调用
-        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request, extra) => {
             // AI 发起调用，刷新活动时间，避免被 watchdog 误判为闲置
             this.lastActivityTime = Date.now();
             const { name, arguments: args } = request.params;
+            // JSON-RPC 请求 id（同一连接内唯一）：客户端把同一次 tool call 重复投递时若复用
+            // 同一 id，可据此做精确去重 / 结果重放（比 summary 内容启发式可靠）。
+            const wireKey = extra?.requestId !== undefined ? String(extra.requestId) : undefined;
             try {
                 switch (name) {
                     case 'interactive_feedback':
-                        return await this.handleInteractiveFeedback(args);
+                        return await this.handleInteractiveFeedback(args, wireKey);
                     case 'get_system_info':
                         return this.handleGetSystemInfo();
                     default:
@@ -239,8 +260,9 @@ class McpFeedbackServer {
     }
     /**
      * 处理交互式反馈请求
+     * @param wireKey 本次调用的 JSON-RPC 请求 id（用于重复投递的精确识别与结果重放）
      */
-    async handleInteractiveFeedback(args) {
+    async handleInteractiveFeedback(args, wireKey) {
         // 参数校验：project_directory 是必填项
         if (!args?.project_directory) {
             const receivedParams = JSON.stringify(args || {});
@@ -263,15 +285,29 @@ class McpFeedbackServer {
         const envTimeout = process.env.MCP_FEEDBACK_TIMEOUT ? parseInt(process.env.MCP_FEEDBACK_TIMEOUT, 10) : null;
         const timeout = envTimeout || args?.timeout || 300;
         const requestId = this.generateRequestId();
-        // 重复投递识别：同窗口 + 同 summary + 旧请求还很新 → 视为客户端/传输层对同一次调用的
-        // 重复投递（非新一轮），直接 join 旧等待共享结果：不发新卡、不顶旧请求（顶了会让
-        // 先到的那次调用收到 SUPERSEDED、AI 误以为被新会话取代而提前收尾）。
-        const dup = this.findDuplicatePending(projectDir, summary);
+        // 重复投递识别：客户端/传输层会把同一次 tool call 原样重复投递（实测某一时刻把进程内
+        // 所有 in-flight 调用各重投一遍，距原投递可晚至 3~8 分钟，无固定上限）。重复投递必须
+        // join 原等待共享结果，绝不能当新一轮：不发新卡、不顶旧请求——顶了会让原调用收到
+        // SUPERSEDED（AI 误以为被新会话取代而提前收尾），且重投开出的幽灵卡片没人认领，
+        // 用户回复它只会石沉大海。
+        const dup = this.findDuplicatePending(projectDir, summary, timeout, wireKey);
         if (dup) {
-            debugLog(`Duplicate delivery detected for request ${dup.id}; joining its wait instead of superseding`);
+            debugLog(`Duplicate delivery detected (matched by ${dup.via}) for request ${dup.id}; joining its wait instead of superseding`);
             const outcome = await new Promise((res) => dup.waiters.push(res));
+            this.rememberSettledWire(wireKey, outcome, dup.id);
             return this.outcomeToResult(outcome, dup.id);
         }
+        // 迟到的重复投递（原请求已结束）：同 wire id 精确命中已结束请求 → 原样重放当时的结果。
+        // 绝不能开新一轮：原调用早已返回、没人会认领新卡，用户回复只会丢失。
+        // 只按 wire id 匹配、绝不按 summary——AI 超时续期的新一轮常复用同一句 summary，
+        // 按内容重放旧超时会造成「新调用秒收超时 → 立即重调 → 又秒收」的快速空转。
+        if (wireKey) {
+            const settled = this.settledByWire.get(wireKey);
+            if (settled) {
+                debugLog(`Late duplicate delivery (wire id ${wireKey}) for settled request ${settled.requestId}; replaying its outcome`);
+                return this.outcomeToResult(settled.outcome, settled.requestId);
+            }
+        }
         // 作废上一轮残留的「僵尸」请求：单实例单窗口同时只应有一个活跃反馈请求。
         // 旧请求多半是对话被压缩 / 客户端取消后还卡在 await 的残留（要等 timeout 才自然结束），
         // 不清理会让 pendingCount 虚高、全局视角误判「多个窗口在等」
@@ -311,7 +347,8 @@ class McpFeedbackServer {
         }
         try {
             // 等待用户反馈
-            const outcome = await this.waitForFeedback(request, timeout * 1000);
+            const outcome = await this.waitForFeedback(request, timeout * 1000, wireKey);
+            this.rememberSettledWire(wireKey, outcome, requestId);
             return this.outcomeToResult(outcome, requestId);
         }
         catch (error) {
@@ -593,19 +630,49 @@ class McpFeedbackServer {
             this.pendingRequests.delete(reqId);
         }
     }
-    findDuplicatePending(projectDir, summary) {
+    /**
+     * 查找可 join 的「重复投递」等待，两级匹配：
+     * 1) wire id 精确匹配：同一条 JSON-RPC 请求（同 id）还在等待 → 必是重复投递；
+     * 2) 内容启发式：同窗口 + 同 summary + 同 timeout，且原请求仍在 pending（覆盖客户端
+     *    重投时换了新 wire id 的情况）。
+     * 内容启发式不设时间窗——旧实现的 90s 窗口被实测击穿（重投可晚至 3~8 分钟，无固定上限）。
+     * 不设窗口是安全的：pending 仍存活 = 原调用尚未返回 = 同一会话不可能已合法开启新一轮；
+     * 不同会话在同一窗口撞出一字不差的 summary + timeout 概率可忽略，即便撞上，
+     * join（双方共享同一份回复）也远比 supersede（悄悄掐掉别人的等待）安全。
+     */
+    findDuplicatePending(projectDir, summary, timeout, wireKey) {
         const owner = this.normalizePath(projectDir);
         for (const [id, pending] of this.pendingRequests) {
+            if (wireKey !== undefined && pending.wireId === wireKey) {
+                return { id, via: 'wire id', waiters: pending.waiters };
+            }
             if (this.normalizePath(pending.projectDir) !== owner)
                 continue;
             if (pending.request.summary !== summary)
                 continue;
-            if (Date.now() - pending.request.timestamp > McpFeedbackServer.DUP_JOIN_MS)
+            if (pending.request.timeout !== timeout)
                 continue;
-            return { id, waiters: pending.waiters };
+            return { id, via: 'content', waiters: pending.waiters };
         }
         return null;
     }
+    rememberSettledWire(wireKey, outcome, requestId) {
+        if (!wireKey)
+            return;
+        const now = Date.now();
+        this.settledByWire.set(wireKey, { outcome, requestId, at: now });
+        for (const [k, v] of this.settledByWire) {
+            if (now - v.at > McpFeedbackServer.SETTLED_WIRE_TTL_MS)
+                this.settledByWire.delete(k);
+        }
+        // Map 按插入序迭代，超限时先淘汰最早的
+        while (this.settledByWire.size > McpFeedbackServer.SETTLED_WIRE_MAX) {
+            const oldest = this.settledByWire.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.settledByWire.delete(oldest);
+        }
+    }
     /**
      * 把等待结果翻译成 MCP 工具响应（主等待与重复投递 join 的等待共用同一段收尾语义）。
      */
@@ -687,7 +754,7 @@ class McpFeedbackServer {
      * 等待用户反馈：注册 pending 并挂起，结果通过 waiters 广播——
      * 首个调用与后续 join 进来的重复投递调用都会收到同一份结果。
      */
-    waitForFeedback(request, timeoutMs) {
+    waitForFeedback(request, timeoutMs, wireKey) {
         return new Promise((resolve) => {
             const requestId = request.id;
             const projectDir = request.projectDir;
@@ -725,6 +792,7 @@ class McpFeedbackServer {
                 remainingMs: timeoutMs,
                 request,
                 waiters,
+                wireId: wireKey,
             });
             // 抢跑兑现：空窗期的面板提交（优先，用户显式点了发送）与飞书暂存消息，
             // 本轮 pending 一注册立即作为回复提交；最后是忙时队列里排队的追加消息
@@ -933,13 +1001,43 @@ class McpFeedbackServer {
         }
         return false;
     }
-    /** 队列里是否有属于某项目空间的排队消息 */
+    /** 队列里是否有属于某项目空间的排队消息（不看渠道开关：面板消息不受飞书队列开关约束） */
     hasQueuedFor(projectDir) {
-        if (!this.feishu.isQueueWhenBusy())
-            return false;
         const owner = this.normalizePath(projectDir);
         return this.queuedInbound.some((q) => this.pathsRelated(this.normalizePath(q.forProjectDir), owner));
     }
+    /** 某项目空间的排队消息快照（随 /api/feedback/current 下发给面板展示队列列表） */
+    queuedSnapshotFor(normalizedWs) {
+        if (!normalizedWs)
+            return [];
+        return this.queuedInbound
+            .filter((q) => this.pathsRelated(this.normalizePath(q.forProjectDir), normalizedWs))
+            .map((q) => ({
+            id: q.id,
+            at: q.at,
+            source: q.source,
+            text: q.text,
+            images: q.images.length,
+            files: q.files.length,
+        }));
+    }
+    /**
+     * 撤回一条排队消息（面板队列列表的小叉触发）。
+     * 飞书来源的消息同步回执「已撤回」，两边状态一致；面板消息撤掉后列表随轮询消失即回执。
+     * 返回 false = 没找到（可能已被消费或过期），面板下一秒轮询自然对齐，无需特殊处理。
+     */
+    removeQueuedById(id) {
+        const idx = this.queuedInbound.findIndex((q) => q.id === id);
+        if (idx < 0)
+            return false;
+        const [item] = this.queuedInbound.splice(idx, 1);
+        clearTimeout(item.expiryTimer);
+        debugLog(`Queued message recalled (id=${id}, source=${item.source}, queueSize=${this.queuedInbound.length})`);
+        if (item.source === 'feishu') {
+            this.feishu.replyToMessage(item.messageId || undefined, item.chatId, '🗑️ 这条排队消息已在插件面板被撤回，不会送达 AI。');
+        }
+        return true;
+    }
     /**
      * 用户回复了一张「已结束」的卡片（不在超时续接窗口内）→ 忙时排队：
      * - 该项目已有新一轮在等 → 引导回复最新卡片（避免旧回复窜入错误轮次），视为已处理；
@@ -962,23 +1060,29 @@ class McpFeedbackServer {
     /**
      * 消息入队 + 回执用户「已排队」。每条消息带 60 分钟过期兜底：
      * 到点仍未被 AI 读取（对话可能已结束）→ 引用回复告知未送达，绝不静默丢弃。
+     * 飞书与面板消息共用同一个队列（严格按到达顺序），但回执链路分渠道：
+     * 飞书走引用回复/表情，面板消息没有推送通道，靠轮询下发的队列列表反映在/不在。
      */
-    enqueueInbound(text, chatId, images, files, messageId, forProjectDir) {
+    enqueueInbound(text, chatId, images, files, messageId, forProjectDir, source = 'feishu') {
         // 上限保护：挤出最老的一条并告知未送达
         while (this.queuedInbound.length >= McpFeedbackServer.QUEUE_MAX) {
             const dropped = this.queuedInbound.shift();
             if (!dropped)
                 break;
             clearTimeout(dropped.expiryTimer);
-            this.feishu.replyToMessage(dropped.messageId || undefined, dropped.chatId, '⚠️ 排队消息过多，这条消息已被挤出队列、未送达 AI，请稍后重发。');
+            if (dropped.source === 'feishu') {
+                this.feishu.replyToMessage(dropped.messageId || undefined, dropped.chatId, '⚠️ 排队消息过多，这条消息已被挤出队列、未送达 AI，请稍后重发。');
+            }
         }
         const item = {
+            id: `q${Date.now()}_${++this.queueSeq}`,
             text,
             chatId,
             images,
             files,
             at: Date.now(),
             messageId,
+            source,
             forProjectDir,
             expiryTimer: undefined,
         };
@@ -987,12 +1091,16 @@ class McpFeedbackServer {
             if (idx < 0)
                 return; // 已被消费
             this.queuedInbound.splice(idx, 1);
-            this.feishu.replyToMessage(item.messageId || undefined, item.chatId, '⚠️ 这条排队消息等了 60 分钟仍未被 AI 读取（对话可能已结束），未能送达。需要的话请在 AI 下次询问时重发。');
+            if (item.source === 'feishu') {
+                this.feishu.replyToMessage(item.messageId || undefined, item.chatId, '⚠️ 这条排队消息等了 60 分钟仍未被 AI 读取（对话可能已结束），未能送达。需要的话请在 AI 下次询问时重发。');
+            }
         }, McpFeedbackServer.QUEUE_TTL_MS);
         item.expiryTimer.unref?.();
         this.queuedInbound.push(item);
-        debugLog(`Inbound queued for busy AI (project=${forProjectDir}, queueSize=${this.queuedInbound.length})`);
-        this.feishu.replyToMessage(messageId || undefined, chatId, `🤖 AI 正在工作中，这条消息已排队，将在「${this.projectName(forProjectDir)}」当前任务完成后自动读取。`);
+        debugLog(`Inbound queued for busy AI (source=${source}, project=${forProjectDir}, queueSize=${this.queuedInbound.length})`);
+        if (source === 'feishu') {
+            this.feishu.replyToMessage(messageId || undefined, chatId, `🤖 AI 正在工作中，这条消息已排队，将在「${this.projectName(forProjectDir)}」当前任务完成后自动读取。`);
+        }
     }
     /**
      * 队列兑现：新一轮 pending 注册时，把属于该项目空间的所有排队消息合并成一次反馈送达，
@@ -1022,7 +1130,8 @@ class McpFeedbackServer {
         });
         const text = '[QUEUED_MESSAGES] 以下是用户在你执行上一轮任务期间「追加」发送的消息（当时你正忙，消息已排队暂存）。' +
             '注意：这些内容不是对你最新一轮工作摘要的回复，请结合任务上下文阅读并处理；' +
-            '如与你摘要中的询问冲突，以用户追加内容为准。处理完后照常调用 interactive_feedback 继续对话。\n\n' +
+            '如与你摘要中的询问冲突，以用户追加内容为准。本次的 summary 用户并没有收到，如有必要可在下次带上。' +
+            '处理完后照常调用 interactive_feedback 继续对话。\n\n' +
             `=== 追加消息（${matched.length} 条）===\n` +
             lines.join('\n\n');
         debugLog(`Consuming ${matched.length} queued message(s) for request: ${requestId}`);
@@ -1037,9 +1146,12 @@ class McpFeedbackServer {
         this.feishu.clearPending(requestId);
         // 标记为「飞书渠道 resolve」：插件面板据此重置，避免对着已消失的请求提交
         this.lastFeishuResolved = { id: requestId, at: Date.now() };
-        // 送达回执：给每条排队消息补 ✅ 表情
+        // 送达回执：给每条飞书排队消息补 ✅ 表情（面板消息没有回执通道，
+        // 其送达状态由轮询下发的队列列表体现——消费后列表随即清空）
         for (const m of matched) {
-            this.feishu.reactDone(m.messageId || undefined, m.chatId);
+            if (m.source === 'feishu') {
+                this.feishu.reactDone(m.messageId || undefined, m.chatId);
+            }
         }
     }
     /** 「我的窗口」是否仍活着（无插件 host 无从判定，视为活跃） */
@@ -1293,9 +1405,66 @@ class McpFeedbackServer {
                             feishu: this.feishu.getStatus(),
                             feishuResolvedId: (this.lastFeishuResolved && Date.now() - this.lastFeishuResolved.at < 30000) ? this.lastFeishuResolved.id : null,
                             pause: this.getPauseStateFor(chosen?.id),
+                            // 该窗口的忙时排队消息快照（飞书 + 面板同队列），供面板展示队列列表
+                            queued: this.queuedSnapshotFor(pollWs),
                         }));
                         return;
                     }
+                    // 面板忙时排队：AI 正忙（该项目无等待中的请求）时，把面板消息排进忙时队列，
+                    // 与飞书消息共用同一队列（按到达顺序），下一轮 interactive_feedback 合并送达
+                    if (req.method === 'POST' && req.url === '/api/feedback/enqueue') {
+                        let body = '';
+                        req.on('data', (chunk) => { body += chunk.toString(); });
+                        req.on('end', () => {
+                            try {
+                                const { text, images, attachedFiles, projectDir } = JSON.parse(body);
+                                if (!projectDir) {
+                                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ queued: false, reason: 'projectDir required' }));
+                                    return;
+                                }
+                                // 忙时排队是全局开关（面板 UI 已隐藏排队入口，这里兜底防竞态）
+                                if (!this.feishu.isQueueWhenBusy()) {
+                                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ queued: false, reason: 'disabled' }));
+                                    return;
+                                }
+                                // 该项目有等待中的请求 → 不该排队，面板应直接提交（正常轮询下一秒就会显示该请求）
+                                if (this.hasPendingForProject(projectDir)) {
+                                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ queued: false, reason: 'pending' }));
+                                    return;
+                                }
+                                this.enqueueInbound(text || '', '', images || [], attachedFiles || [], '', projectDir, 'panel');
+                                res.writeHead(200, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ queued: true }));
+                            }
+                            catch {
+                                res.writeHead(400, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ queued: false, reason: 'invalid body' }));
+                            }
+                        });
+                        return;
+                    }
+                    // 撤回排队消息：面板队列列表的删除按钮触发，按队列项 id 定位。
+                    // 飞书来源的消息由 removeQueuedById 同步回执，保证两边状态一致
+                    if (req.method === 'POST' && req.url === '/api/feedback/queue/remove') {
+                        let body = '';
+                        req.on('data', (chunk) => { body += chunk.toString(); });
+                        req.on('end', () => {
+                            try {
+                                const { id } = JSON.parse(body);
+                                const removed = !!id && this.removeQueuedById(id);
+                                res.writeHead(200, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ removed }));
+                            }
+                            catch {
+                                res.writeHead(400, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ removed: false }));
+                            }
+                        });
+                        return;
+                    }
                     // 提交反馈
                     if (req.method === 'POST' && req.url === '/api/feedback/submit') {
                         let body = '';
@@ -1342,6 +1511,30 @@ class McpFeedbackServer {
                         return;
                     }
                     // 配置飞书（来自插件 UI；凭证未变只补 chatId，变了则重建长连接）
+                    // 扫码一键创建飞书应用：启动 Device Grant 流程并返回待扫码链接（等二维码就绪才响应）
+                    if (req.method === 'POST' && req.url === '/api/feishu/register/start') {
+                        this.feishu.startRegister().then((state) => {
+                            res.writeHead(200, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify(state));
+                        }).catch(() => {
+                            res.writeHead(500, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ status: 'error', error: 'internal' }));
+                        });
+                        return;
+                    }
+                    // 扫码创建流程状态（插件轮询直到 success / error）
+                    if (req.method === 'GET' && req.url === '/api/feishu/register/status') {
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(this.feishu.getRegisterState()));
+                        return;
+                    }
+                    // 取消进行中的扫码创建流程（用户关闭设置弹窗）
+                    if (req.method === 'POST' && req.url === '/api/feishu/register/cancel') {
+                        this.feishu.cancelRegister();
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true }));
+                        return;
+                    }
                     if (req.method === 'POST' && req.url === '/api/feishu/config') {
                         let body = '';
                         req.on('data', (chunk) => { body += chunk.toString(); });
@@ -1541,7 +1734,7 @@ class McpFeedbackServer {
                         res.writeHead(200, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify({
                             status: 'ok',
-                            version: '0.0.1',
+                            version: PKG_VERSION,
                             hasCurrentRequest: this.currentRequest !== null,
                             pid: process.pid,
                         }));
@@ -1792,12 +1985,8 @@ McpFeedbackServer.QUEUE_MAX = 100;
  *（只剩别的窗口在扫端口）→ 视为我的窗口已关、本实例是僵尸：不再上报 pending，避免污染全局计数。
  */
 McpFeedbackServer.OWNER_IDLE_MS = 12000;
-/**
- * 查找可 join 的「重复投递」等待：同窗口 + 同 summary + 注册时间在 DUP_JOIN_MS 内。
- * AI 每一轮的 summary 几乎不可能与上一轮一字不差，短窗口内完全相同基本可断定为
- * 客户端/传输层对同一次 tool call 的重复投递。
- */
-McpFeedbackServer.DUP_JOIN_MS = 90000;
+McpFeedbackServer.SETTLED_WIRE_TTL_MS = 10 * 60 * 1000;
+McpFeedbackServer.SETTLED_WIRE_MAX = 20;
 // 主函数
 async function main() {
     const port = 61927;

package/dist/webview/index.html

@@ -20,7 +20,7 @@
           <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="12" r="10"/><path d="M2 12h20"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/></svg>
         </button>
         <button id="autoRetryBtn" class="iconbtn" type="button" aria-label="Timeout keep-waiting / 超时续期" data-tip="Timeout keep-waiting / 超时续期">
-          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8"/><path d="M21 3v5h-5"/><path d="M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16"/><path d="M3 21v-5h5"/></svg>
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M5 22h14"/><path d="M5 2h14"/><path d="M17 22v-4.172a2 2 0 0 0-.586-1.414L12 12l-4.414 4.414A2 2 0 0 0 7 17.828V22"/><path d="M7 2v4.172a2 2 0 0 0 .586 1.414L12 12l4.414-4.414A2 2 0 0 0 17 6.172V2"/></svg>
         </button>
         <button id="themeAccentBtn" class="iconbtn" type="button" aria-label="Accent color / 主题色" data-tip="Accent color / 主题色">
           <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="13.5" cy="6.5" r=".5" fill="currentColor"/><circle cx="17.5" cy="10.5" r=".5" fill="currentColor"/><circle cx="8.5" cy="7.5" r=".5" fill="currentColor"/><circle cx="6.5" cy="12.5" r=".5" fill="currentColor"/><path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10c.926 0 1.648-.746 1.648-1.688 0-.437-.18-.835-.437-1.125-.29-.289-.438-.652-.438-1.125a1.64 1.64 0 0 1 1.668-1.668h1.996c3.051 0 5.555-2.503 5.555-5.555C21.965 6.012 17.461 2 12 2z"/></svg>
@@ -37,13 +37,20 @@
       </div>
     </header>
 
-    <!-- 等待态 -->
+    <!-- 等待态（排队模式下排队消息列表内嵌在此卡片中，整体高度由分隔条控制） -->
     <section id="waitingStatus" class="empty">
       <div class="empty__icon" aria-hidden="true">
         <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>
       </div>
       <p class="empty__title">{{i18n.waitingForAI}}</p>
       <p class="empty__hint">{{i18n.waitingHint}}</p>
+      <div id="queueCard" class="waiting-queue hidden">
+        <div class="waiting-queue__head">
+          <span class="waiting-queue__title">{{i18n.queuedTitle}}</span>
+          <span id="queueCount" class="queue-count"></span>
+        </div>
+        <div id="queueList" class="queue-list"></div>
+      </div>
     </section>
 
     <!-- 反馈表单 -->
@@ -55,6 +62,16 @@
             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M9.937 15.5A2 2 0 0 0 8.5 14.063l-6.135-1.582a.5.5 0 0 1 0-.962L8.5 9.936A2 2 0 0 0 9.937 8.5l1.582-6.135a.5.5 0 0 1 .962 0L14.063 8.5A2 2 0 0 0 15.5 9.937l6.135 1.581a.5.5 0 0 1 0 .964L15.5 14.063a2 2 0 0 0-1.437 1.437l-1.582 6.135a.5.5 0 0 1-.962 0z"/><path d="M20 3v4"/><path d="M22 5h-4"/></svg>
           </span>
           <h2 class="card__title">{{i18n.aiSummary}}</h2>
+          <!-- 历史摘要导航：存过 2 条以上时显示，可回看之前轮次的 AI 摘要 -->
+          <div id="summaryNav" class="summary-nav" hidden>
+            <button id="summaryPrevBtn" class="iconbtn summary-nav__btn" type="button" aria-label="{{i18n.summaryPrevTip}}" data-tip="{{i18n.summaryPrevTip}}">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m15 18-6-6 6-6"/></svg>
+            </button>
+            <span id="summaryNavPos" class="summary-nav__pos"></span>
+            <button id="summaryNextBtn" class="iconbtn summary-nav__btn" type="button" aria-label="{{i18n.summaryNextTip}}" data-tip="{{i18n.summaryNextTip}}">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m9 18 6-6-6-6"/></svg>
+            </button>
+          </div>
         </div>
         <div id="summaryContent" class="summary markdown-body"></div>
         <div id="projectInfo" class="project-chip"></div>
@@ -183,7 +200,17 @@
         </div>
       </div>
 
-      <!-- 区块②：飞书通知（推送开关 + 凭证 + 绑定状态） -->
+      <!-- 区块②：忙时消息排队（全局开关：飞书与面板消息共用忙时队列） -->
+      <div class="feishu-section">
+        <label class="feishu-switch">
+          <span class="feishu-switch__label feishu-switch__label--strong">{{i18n.queueWhenBusyLabel}}</span>
+          <input id="queueWhenBusyToggle" type="checkbox" class="feishu-switch__input">
+          <span class="feishu-switch__track"><span class="feishu-switch__thumb"></span></span>
+        </label>
+        <p class="feishu-modal__desc">{{i18n.queueWhenBusyDesc}}</p>
+      </div>
+
+      <!-- 区块③：飞书通知（推送开关 + 凭证 + 绑定状态） -->
       <div class="feishu-section">
         <label class="feishu-switch">
           <span class="feishu-switch__label feishu-switch__label--strong">{{i18n.feishuSettings}}</span>
@@ -199,14 +226,6 @@
           </label>
           <p class="feishu-modal__desc feishu-modal__desc--sub">{{i18n.feishuAckDesc}}</p>
         </div>
-        <div id="feishuQueueSub" class="feishu-subitem">
-          <label class="feishu-switch">
-            <span class="feishu-switch__label">{{i18n.feishuQueueLabel}}</span>
-            <input id="feishuQueueToggle" type="checkbox" class="feishu-switch__input">
-            <span class="feishu-switch__track"><span class="feishu-switch__thumb"></span></span>
-          </label>
-          <p class="feishu-modal__desc feishu-modal__desc--sub">{{i18n.feishuQueueDesc}}</p>
-        </div>
         <label class="feishu-field">
           <span class="feishu-field__label">{{i18n.feishuAppId}}</span>
           <input id="feishuAppId" class="feishu-input" type="text" placeholder="{{i18n.feishuAppIdPlaceholder}}" autocomplete="off" spellcheck="false">
@@ -226,7 +245,16 @@
           <span id="feishuStatusText" class="feishu-status__text">{{i18n.feishuStatusUnconfigured}}</span>
         </div>
         <div class="feishu-modal__actions">
-          <button id="feishuGuideBtn" class="feishu-link" type="button">{{i18n.feishuGuide}}</button>
+          <button id="feishuRegisterBtn" class="feishu-link feishu-link--primary" type="button">{{i18n.feishuRegisterBtn}}</button>
+        </div>
+        <!-- 扫码一键创建应用：点击上方按钮后展开，展示验证二维码与流程状态 -->
+        <div id="feishuRegisterPanel" class="feishu-register hidden">
+          <img id="feishuRegisterQr" class="feishu-register__qr hidden" alt="QR code">
+          <p id="feishuRegisterHint" class="feishu-register__hint"></p>
+          <div class="feishu-register__actions">
+            <button id="feishuRegisterOpenBtn" class="feishu-link hidden" type="button">{{i18n.registerOpenLink}}</button>
+            <button id="feishuRegisterRetryBtn" class="feishu-link hidden" type="button">{{i18n.registerRetry}}</button>
+          </div>
         </div>
         <p class="feishu-modal__hint">{{i18n.feishuHint}}</p>
       </div>