cursor-feedback 2.1.1 → 2.2.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [2.2.0](https://github.com/jianger666/cursor-feedback-extension/compare/v2.1.2...v2.2.0) (2026-07-03)
+
+
+### Features
+
+* **feishu:** 忙时消息排队——AI 干活期间的飞书消息不再丢失 ([fd8aa75](https://github.com/jianger666/cursor-feedback-extension/commit/fd8aa7540a787dbb44e85f35ea137a0c0ea9c03e))
+
+### [2.1.2](https://github.com/jianger666/cursor-feedback-extension/compare/v2.1.1...v2.1.2) (2026-07-03)
+
+
+### Bug Fixes
+
+* **mcp:** 多窗口/多对话共用进程的反馈路由修复——按窗口查询 + 重复投递去重 + 暂停保护 ([3b3d451](https://github.com/jianger666/cursor-feedback-extension/commit/3b3d451453ee5a04ce29929845d22191116e0f96))
+
 ### [2.1.1](https://github.com/jianger666/cursor-feedback-extension/compare/v2.1.0...v2.1.1) (2026-07-02)
 
 

package/README.md

@@ -227,6 +227,7 @@ Either way works — but you first need to set up the bot in the Feishu console:
 | `FEISHU_APP_SECRET` | - | Feishu app App Secret |
 | `FEISHU_ENABLED` | `true` | Whether to push feedback to Feishu. Set to `false` to disable |
 | `FEISHU_ACK` | `true` | Whether to react with a "Get" emoji after you reply. Set to `false` to disable |
+| `FEISHU_QUEUE` | `true` | Queue messages while the AI is busy: messages sent when no feedback request is waiting are queued and auto-delivered on the AI's next feedback round, prefixed with an "appended during the task" hint; the bot acknowledges with a "queued" reply. Set to `false` to disable (also toggleable in the panel's notification settings) |
 
 > Priority: **panel config (when credentials are filled) > env here > default**. The panel wins when App ID/Secret are filled; otherwise it falls back to env. You still need to send the bot one message in Feishu to complete binding.
 

package/README_CN.md

@@ -231,6 +231,7 @@ npm install -g cursor-feedback
 | `FEISHU_APP_SECRET` | - | 飞书应用 App Secret |
 | `FEISHU_ENABLED` | `true` | 是否推送反馈到飞书，设 `false` 关闭 |
 | `FEISHU_ACK` | `true` | 收到你的回复后是否回「Get」表情回执，设 `false` 关闭 |
+| `FEISHU_QUEUE` | `true` | 忙时消息排队：AI 正忙（没有等待中的反馈）时你发的消息先排队，等 AI 下一轮询问时自动送达并附「任务期间追加」提示；排队时机器人会回执「已排队，任务完成后自动读取」。设 `false` 关闭（也可在面板「通知设置」里切换） |
 
 > 优先级：**插件面板（填了凭证）> 这里的 env > 默认**。面板里填了 App ID/Secret 就以面板为准；没填则回退到 env。首次仍需在飞书里给机器人发一条消息完成绑定。
 

package/dist/extension.js

@@ -161,7 +161,12 @@ class FeedbackViewProvider {
         this._pendingInsert = null;
         this._activePort = null;
         this._portScanRange = 20; // 扫描端口范围
-        this._seenRequestIds = new Set(); // 已处理过的请求 ID
+        this._seenRequestIds = new Set(); // 见过的请求 ID（只用于「新鲜提醒」去重，不再挡显示）
+        // 本窗口已提交 / 已被外部渠道结束的请求 ID：绝不复显。
+        // 与 _seenRequestIds 分开的原因：同窗口多对话并存时（如一个等待被暂停、另一对话又发起新等待），
+        // 被覆盖的旧请求在新请求结束后会重新从 server 返回，此时它虽「见过」但没提交过，必须能回到面板；
+        // 旧实现用 seen 一刀切挡显示，旧请求就永远回不来了。
+        this._resolvedRequestIds = new Set();
         // 超时续期开关（由侧边栏按钮切换，随轮询同步给 MCP server）
         this._autoRetry = true;
         // 飞书配置（持久化在 globalState；secret 会回显给 webview，前端用小眼睛切换明文/掩码）
@@ -172,6 +177,8 @@ class FeedbackViewProvider {
         this._feishuEnabled = true;
         // Get 表情回执子开关（飞书通知子项；关掉后用户飞书回复不加 Get 表情、也不发文字兜底）
         this._feishuAck = true;
+        // 忙时消息排队子开关（飞书通知子项；AI 正忙时用户消息入队，下一轮 feedback 自动送达）
+        this._feishuQueue = true;
         this._debugInfo = {
             portRange: '',
             workspacePath: '',
@@ -189,6 +196,7 @@ class FeedbackViewProvider {
         this._feishuConfig = { appId: fc.appId || '', appSecret: fc.appSecret || '' };
         this._feishuEnabled = this._memento?.get('feishuEnabled', true) ?? true;
         this._feishuAck = this._memento?.get('feishuAck', true) ?? true;
+        this._feishuQueue = this._memento?.get('feishuQueue', true) ?? true;
     }
     /**
      * 获取翻译消息
@@ -272,6 +280,9 @@ class FeedbackViewProvider {
                 case 'toggleFeishuAck':
                     await this._handleToggleFeishuAck(!!data.payload?.enabled);
                     break;
+                case 'toggleFeishuQueue':
+                    await this._handleToggleFeishuQueue(!!data.payload?.enabled);
+                    break;
                 case 'testNotification':
                     this._sendTestNotification();
                     break;
@@ -336,15 +347,19 @@ class FeedbackViewProvider {
             // 如果有活跃端口，先尝试只轮询该端口
             if (this._activePort) {
                 const result = await this._checkPortForRequest(this._activePort);
-                // 检查是否仍然是我们的 Server（owner 可能是本工作区的子目录：AI 传的 project_directory）
+                // 检查是否仍然是我们的 Server。注意：多窗口/多对话共用一个 MCP 进程时，
+                // server 的 ownerWorkspace（进程归属，单值）可能是别的窗口——但只要它按窗口
+                // 返回了本工作区的请求（request 已在 _checkPortForRequest 里按 projectDir 过滤），
+                // 这个端口对本窗口就是有效的，不能因 owner 不匹配而丢弃请求。
                 if (result.connected) {
                     const serverOwner = result.ownerWorkspace ? normalizePath(result.ownerWorkspace) : '';
-                    const isMyServer = !serverOwner || pathsRelated(serverOwner, normalizedCurrentWorkspace);
+                    const isMyServer = !!result.request || !serverOwner || pathsRelated(serverOwner, normalizedCurrentWorkspace);
                     if (isMyServer) {
                         // 端口仍然有效，保持使用
                         this._debugInfo.connectedPorts = [this._activePort];
                         this._debugInfo.activePort = this._activePort;
-                        if (result.request && !this._seenRequestIds.has(result.request.id)) {
+                        // 只挡「已提交/已结束」的请求；_handleNewRequest 内部按当前显示态去重，重复调用无害
+                        if (result.request && !this._resolvedRequestIds.has(result.request.id)) {
                             this._debugInfo.lastStatus = this._t('statusListening', { port: this._activePort });
                             this._handleNewRequest(result.request, this._activePort);
                             this._updateDebugInfo();
@@ -375,14 +390,13 @@ class FeedbackViewProvider {
             const results = await Promise.all(ports.map(port => this._checkPortForRequest(port)));
             // 更新已连接的端口列表
             this._debugInfo.connectedPorts = results.filter(r => r.connected).map(r => r.port);
-            // 找出属于当前工作区的请求
-            const myRequests = results.filter(r => {
-                if (!r.request || this._seenRequestIds.has(r.request.id)) {
-                    return false;
-                }
-                const serverOwner = r.ownerWorkspace ? normalizePath(r.ownerWorkspace) : '';
-                return !serverOwner || pathsRelated(serverOwner, normalizedCurrentWorkspace);
-            }).sort((a, b) => b.request.timestamp - a.request.timestamp);
+            // 找出属于当前工作区的请求（只排除已提交/已结束的；「见过但没提交」的仍要能回到面板）。
+            // 不再用 server 进程级 ownerWorkspace 二次过滤：request 已在 _checkPortForRequest
+            // 按本窗口工作区过滤过（isPathInWorkspace）；多窗口共用一个 MCP 进程时 owner 只反映
+            // 首个对话的窗口，按它过滤会把其他窗口的请求全部滤掉（面板不显示、只有飞书收到）。
+            const myRequests = results
+                .filter(r => !!r.request && !this._resolvedRequestIds.has(r.request.id))
+                .sort((a, b) => b.request.timestamp - a.request.timestamp);
             // 处理最新的请求
             if (myRequests.length > 0) {
                 const newest = myRequests[0];
@@ -471,41 +485,50 @@ class FeedbackViewProvider {
         }
     }
     /**
-     * 处理新的反馈请求
+     * 处理新的反馈请求。
+     * 幂等：同一请求正在显示时重复调用直接跳过；已提交/已结束的绝不复显；
+     * 「见过但没提交」的请求（同窗口多对话时被新请求覆盖过）允许重新显示，只是不再重复提醒。
      */
     _handleNewRequest(request, port) {
-        // 如果已经处理过这个请求，跳过
-        if (this._seenRequestIds.has(request.id)) {
+        // 已提交 / 已被外部渠道结束 → 绝不复显（防旧版 server 的 currentRequest 清理滞后导致复弹）
+        if (this._resolvedRequestIds.has(request.id)) {
+            return;
+        }
+        // 正在显示的就是它 → 无事可做
+        if (this._currentRequest && request.id === this._currentRequest.id) {
             return;
         }
         // 判断是否为"新鲜"请求：创建后 10 秒内被发现
         const requestAge = Date.now() - request.timestamp;
         const isFreshRequest = requestAge < 10000; // 10秒内
-        // 标记为已见过
+        // seen 只用于「主动提醒」去重：同一请求只 focus / 系统通知一次，重新回到面板时安静显示
+        const alreadySeen = this._seenRequestIds.has(request.id);
         this._seenRequestIds.add(request.id);
         // 清理旧的请求 ID（保留最近 100 个）
         if (this._seenRequestIds.size > 100) {
             const ids = Array.from(this._seenRequestIds);
             this._seenRequestIds = new Set(ids.slice(-50));
         }
-        if (!this._currentRequest || request.id !== this._currentRequest.id) {
-            this._currentRequest = request;
-            this._activePort = port;
-            this._currentRequestPort = port;
-            // 「插件通知」主开关（配置 key 历史原因仍叫 systemNotification）：关掉后本窗口完全静默——
-            // 不推送内容、不弹面板、不抢焦点、不发系统通知；连用户之后主动切回 / 打开面板也不显示
-            // （见 resolveWebviewView 里 ready 与 onDidChangeVisibility 的同款判断）。
-            // 请求仍记录在 _currentRequest，仅用于去重与外部渠道（飞书 / 超时）resolve 关联。
-            if (!this._isPluginNotifyEnabled()) {
-                return;
-            }
-            // 开启：推送内容并显示面板
-            this._showFeedbackRequest(request);
-            // 只对新鲜请求做主动提醒（聚焦面板 + IDE 提示 + 失焦系统通知）
-            if (isFreshRequest) {
-                vscode.commands.executeCommand('cursorFeedback.feedbackView.focus');
-                this._sendSystemNotification(request);
-            }
+        if (this._resolvedRequestIds.size > 100) {
+            const ids = Array.from(this._resolvedRequestIds);
+            this._resolvedRequestIds = new Set(ids.slice(-50));
+        }
+        this._currentRequest = request;
+        this._activePort = port;
+        this._currentRequestPort = port;
+        // 「插件通知」主开关（配置 key 历史原因仍叫 systemNotification）：关掉后本窗口完全静默——
+        // 不推送内容、不弹面板、不抢焦点、不发系统通知；连用户之后主动切回 / 打开面板也不显示
+        // （见 resolveWebviewView 里 ready 与 onDidChangeVisibility 的同款判断）。
+        // 请求仍记录在 _currentRequest，仅用于去重与外部渠道（飞书 / 超时）resolve 关联。
+        if (!this._isPluginNotifyEnabled()) {
+            return;
+        }
+        // 推送内容并显示面板
+        this._showFeedbackRequest(request);
+        // 只对「新鲜且首次见到」的请求做主动提醒（聚焦面板 + IDE 提示 + 失焦系统通知）
+        if (isFreshRequest && !alreadySeen) {
+            vscode.commands.executeCommand('cursorFeedback.feedbackView.focus');
+            this._sendSystemNotification(request);
         }
     }
     /**
@@ -687,6 +710,7 @@ class FeedbackViewProvider {
         if (!this._currentRequest)
             return;
         this._seenRequestIds.add(this._currentRequest.id);
+        this._resolvedRequestIds.add(this._currentRequest.id);
         this._currentRequest = null;
         this._currentRequestPort = null;
         this._showWaitingState();
@@ -722,6 +746,8 @@ class FeedbackViewProvider {
             }));
             const result = JSON.parse(response);
             if (result.success) {
+                // 记入「已提交」：该请求此后绝不复显（server 端清理有滞后，轮询可能还会拿到它）
+                this._resolvedRequestIds.add(payload.requestId);
                 this._currentRequest = null;
                 this._currentRequestPort = null;
                 this._showWaitingState();
@@ -907,6 +933,14 @@ class FeedbackViewProvider {
                     payload: { requestId, paused: result.paused, remainingMs: result.remainingMs }
                 });
             }
+            else {
+                // 请求已在 server 端结束（超时/被回复）→ 明确提示，不能静默：
+                // 用户以为暂停成功离开，实际倒计时早没了，回来发现等待消失会一头雾水
+                this._view?.webview.postMessage({
+                    type: 'toast',
+                    payload: { text: this._i18n.pauseFailedEnded }
+                });
+            }
         }
         catch {
             // server 不支持（旧版本）或未连接：静默降级，倒计时照常走
@@ -945,6 +979,7 @@ class FeedbackViewProvider {
                 bound: this._feishuBound,
                 feishuEnabled: this._feishuEnabled,
                 feishuAck: this._feishuAck,
+                feishuQueue: this._feishuQueue,
                 systemNotification: !!systemNotification,
                 osNotification: !!osNotification
             }
@@ -979,6 +1014,7 @@ class FeedbackViewProvider {
         const appSecret = feishuStatus.appSecret || '';
         const enabled = feishuStatus.enabled !== false;
         const ack = feishuStatus.ackReaction !== false;
+        const queue = feishuStatus.queueWhenBusy !== false;
         const bound = !!feishuStatus.boundChatId;
         let changed = false;
         if (appId !== this._feishuConfig.appId || appSecret !== this._feishuConfig.appSecret) {
@@ -995,6 +1031,10 @@ class FeedbackViewProvider {
             this._feishuAck = ack;
             changed = true;
         }
+        if (queue !== this._feishuQueue) {
+            this._feishuQueue = queue;
+            changed = true;
+        }
         if (bound !== this._feishuBound) {
             this._feishuBound = bound;
             changed = true;
@@ -1013,6 +1053,7 @@ class FeedbackViewProvider {
             appSecret,
             enabled: this._feishuEnabled,
             ackReaction: this._feishuAck,
+            queueWhenBusy: this._feishuQueue,
         });
         for (const port of ports) {
             this._httpPost(`http://127.0.0.1:${port}/api/feishu/config`, body).catch(() => { });
@@ -1072,6 +1113,15 @@ class FeedbackViewProvider {
         this._broadcastFeishuConfig();
         this._postFeishuState();
     }
+    /**
+     * 切换「忙时消息排队」子开关（飞书通知的子项；透传到 server 端，控制忙时队列）
+     */
+    async _handleToggleFeishuQueue(enabled) {
+        this._feishuQueue = enabled;
+        await this._memento?.update('feishuQueue', enabled);
+        this._broadcastFeishuConfig();
+        this._postFeishuState();
+    }
     /**
      * HTTP GET 请求
      */

package/dist/feishu.js

@@ -63,6 +63,8 @@ class FeishuBridge {
         this.enabled = true;
         /** Get 表情轻回执开关（false 时用户回复后不加表情、也不发文字兜底） */
         this.ackReaction = true;
+        /** 忙时消息排队开关（true 时 AI 正忙的消息入队等下一轮，false 走旧的短暂存 + 过期提示） */
+        this.queueWhenBusy = true;
         /** 绑定关系（appId -> chat_id）持久化到磁盘：多个 server 进程共享、reload 不丢 */
         this.bindStorePath = path.join(os.homedir(), '.cursor-feedback', 'feishu-bind.json');
         /** 飞书凭证持久化到磁盘：多个 server 进程共享、reload/重启不丢，作为凭证的全局真相源 */
@@ -71,6 +73,9 @@ class FeishuBridge {
         this.cardToRequest = new Map();
         // requestId -> 卡片 message_id（清理用）
         this.requestToCard = new Map();
+        // requestId -> 归属项目空间：请求结束后仍保留（与卡片映射同生命周期），
+        // 供「回复已结束的旧卡片 → 忙时排队到对应项目」定位归属，随 FIFO 上界一起淘汰
+        this.requestProjects = new Map();
         // requestId -> 摘要信息（多窗口「列清单」提示用）
         this.pendingSummaries = new Map();
         /** 收到用户回复时的回调（由 mcp-server 注入，负责路由 / 转发） */
@@ -92,11 +97,15 @@ class FeishuBridge {
             connected: this.connected,
             enabled: this.enabled,
             ackReaction: this.ackReaction,
+            queueWhenBusy: this.queueWhenBusy,
             appId: this.config?.appId || '',
             appSecret: this.config?.appSecret || '',
             boundChatId: this.getBoundChatId(),
         };
     }
+    isQueueWhenBusy() {
+        return this.queueWhenBusy;
+    }
     isConfigured() {
         return !!this.config;
     }
@@ -175,9 +184,10 @@ class FeishuBridge {
      * - 凭证为空：视为「关闭飞书」
      */
     async configure(config) {
-        // 通知开关 / Get 表情回执开关随时可改（与凭证无关），总是更新
+        // 通知开关 / Get 表情回执开关 / 排队开关随时可改（与凭证无关），总是更新
         this.enabled = config.enabled !== false;
         this.ackReaction = config.ackReaction !== false;
+        this.queueWhenBusy = config.queueWhenBusy !== false;
         const sameCred = this.config &&
             this.config.appId === config.appId &&
             this.config.appSecret === config.appSecret;
@@ -514,11 +524,14 @@ class FeishuBridge {
                         break;
                     const oldReq = this.cardToRequest.get(oldest);
                     this.cardToRequest.delete(oldest);
-                    if (oldReq !== undefined)
+                    if (oldReq !== undefined) {
                         this.requestToCard.delete(oldReq);
+                        this.requestProjects.delete(oldReq);
+                    }
                 }
                 this.cardToRequest.set(messageId, requestId);
                 this.requestToCard.set(requestId, messageId);
+                this.requestProjects.set(requestId, projectDir);
                 this.pendingSummaries.set(requestId, { summary, projectDir });
             }
             return messageId;
@@ -534,6 +547,10 @@ class FeishuBridge {
             return null;
         return this.cardToRequest.get(parentId) || null;
     }
+    /** 查某 requestId 卡片的归属项目空间（请求结束后仍可查，用于忙时排队路由） */
+    projectDirOf(requestId) {
+        return this.requestProjects.get(requestId) || null;
+    }
     /** 本实例当前待回复的请求数（用于多窗口判断） */
     pendingCount() {
         return this.pendingSummaries.size;

package/dist/i18n/en.json

@@ -73,6 +73,8 @@
   "osNotifyDesc": "Sends a system notification when the IDE is in the background.",
   "feishuAckLabel": "Get emoji acknowledgement",
   "feishuAckDesc": "After you reply in Feishu, the bot adds a Get emoji as acknowledgement.",
+  "feishuQueueLabel": "Queue messages while AI is busy",
+  "feishuQueueDesc": "Messages sent while the AI is busy are queued and auto-delivered on its next feedback round, marked as appended during the task.",
   "quickReplyDefault1": "Keep waiting for my feedback",
   "quickReplyDefault2": "End the task",
   "quickReplyEdit": "Edit quick replies",
@@ -89,6 +91,7 @@
   "notifyTestBody": "This is a test notification · click to open Cursor",
   "toastSubmitted": "✓ Feedback sent",
   "toastQueued": "✓ Queued — AI will receive it next round",
+  "pauseFailedEnded": "Pause failed: this request has already ended (timed out or answered)",
   "historyBtn": "Feedback history",
   "historyEmpty": "No history yet — submitted feedback will show up here"
 }

package/dist/i18n/index.js

@@ -180,6 +180,7 @@ function getDefaultMessages() {
         notifyTestBody: "This is a test notification · click to open Cursor",
         toastSubmitted: "✓ Feedback sent",
         toastQueued: "✓ Queued — AI will receive it next round",
+        pauseFailedEnded: "Pause failed: this request has already ended (timed out or answered)",
         historyBtn: "Feedback history",
         historyEmpty: "No history yet — submitted feedback will show up here"
     };

package/dist/i18n/zh-CN.json

@@ -73,6 +73,8 @@
   "osNotifyDesc": "IDE 切到后台时，用系统通知提醒你。",
   "feishuAckLabel": "Get 表情回执",
   "feishuAckDesc": "你在飞书回复后，机器人加个 Get 表情表示「已收到」。",
+  "feishuQueueLabel": "忙时消息排队",
+  "feishuQueueDesc": "AI 正忙时你发的消息先排队，等它下一轮询问时自动送达，并附「任务期间追加」提示。",
   "quickReplyDefault1": "继续等待我的反馈",
   "quickReplyDefault2": "结束任务",
   "quickReplyEdit": "编辑快捷短语",
@@ -89,6 +91,7 @@
   "notifyTestBody": "这是一条测试通知 · 点击试试能否唤起 Cursor",
   "toastSubmitted": "✓ 反馈已发送",
   "toastQueued": "✓ 已暂存，AI 下一轮将自动收到",
+  "pauseFailedEnded": "暂停失败：该请求已结束（超时或已被回复）",
   "historyBtn": "反馈历史",
   "historyEmpty": "还没有历史记录，提交过的反馈会出现在这里"
 }

package/dist/mcp-server.js

@@ -94,6 +94,12 @@ class McpFeedbackServer {
         this.recentlyTimedOut = new Map();
         /** 面板在超时空窗内提交的反馈：暂存到下一轮 pending 注册时立即兑现 */
         this.panelStash = null;
+        /**
+         * 忙时消息队列：AI 正在干活（该项目空间没有等待中的反馈请求）时用户发来的飞书消息
+         * 不再丢弃，而是按项目空间排队；等 AI 下一轮调 interactive_feedback 时合并送达，
+         * 并附「任务期间追加」提示头。开关见 FeishuBridge.queueWhenBusy（面板 / FEISHU_QUEUE）。
+         */
+        this.queuedInbound = [];
         /** 暂存过期提示定时器：到点仍未被认领则「回复」那条消息告知没送到，避免静默丢弃 */
         this.stashExpiryTimer = null;
         // 最近一次被飞书回复 resolve 的请求：供插件端精确区分「飞书回复」与「超时」，
@@ -257,6 +263,15 @@ 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);
+        if (dup) {
+            debugLog(`Duplicate delivery detected for request ${dup.id}; joining its wait instead of superseding`);
+            const outcome = await new Promise((res) => dup.waiters.push(res));
+            return this.outcomeToResult(outcome, dup.id);
+        }
         // 作废上一轮残留的「僵尸」请求：单实例单窗口同时只应有一个活跃反馈请求。
         // 旧请求多半是对话被压缩 / 客户端取消后还卡在 await 的残留（要等 timeout 才自然结束），
         // 不清理会让 pendingCount 虚高、全局视角误判「多个窗口在等」
@@ -275,97 +290,29 @@ class McpFeedbackServer {
                 `request project ${normalizedProjectDir} differs and does not rewrite owner`);
         }
         // 创建反馈请求
-        this.currentRequest = {
+        const request = {
             id: requestId,
             summary,
             projectDir,
             timeout,
             timestamp: Date.now(),
         };
+        this.currentRequest = request;
         debugLog(`Feedback request created: ${requestId}`);
         debugLog(`Summary: ${summary}`);
         debugLog(`Project: ${projectDir}`);
         debugLog(`Timeout: ${timeout}s`);
         debugLog(`Waiting for VS Code extension to collect feedback...`);
-        // 飞书：已配置则推送一张反馈请求卡片（失败不影响插件主流程）
-        if (this.feishu.isConfigured()) {
+        // 飞书：已配置则推送一张反馈请求卡片（失败不影响插件主流程）。
+        // 例外：忙时队列里已有本项目的排队消息 → 本轮会在注册后立即被队列兑现，
+        // 卡片发出去马上就过期（用户回复只会得到「已结束」），干脆不发。
+        if (this.feishu.isConfigured() && !this.hasQueuedFor(projectDir)) {
             this.feishu.sendFeedbackCard(requestId, summary, projectDir).catch(() => { });
         }
         try {
             // 等待用户反馈
-            const outcome = await this.waitForFeedback(requestId, timeout * 1000, projectDir);
-            // 被同窗口/同进程的新一轮请求取代：安静结束，绝不能重试（否则多 agent 互相取消、忙等刷屏）。
-            if (outcome.kind === 'superseded') {
-                debugLog(`Request ${requestId} superseded by a newer request; ending this turn quietly`);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: '[SUPERSEDED] This feedback request was replaced by a newer interactive_feedback call (the same workspace started a new round, or another agent shares this MCP process). Do NOT call interactive_feedback again for this turn — just end your turn quietly. 【本反馈请求已被同窗口/同进程的新请求取代：不要再次调用 interactive_feedback，安静结束本轮，切勿重试。】',
-                        },
-                    ],
-                };
-            }
-            if (outcome.kind === 'timeout') {
-                debugLog('Feedback wait window elapsed without user input');
-                // 超时续期开关：MCP_AUTO_RETRY=false 时关闭（超时即结束），默认开启（超时返回续期提醒）。
-                // 关键：这里【绝不能】说成 "cancelled"——那会让 AI 误以为用户主动取消而结束对话，
-                // 这正是“超时后 AI 直接收尾、不再续命”的根因。改为明确区分“超时 ≠ 取消”。
-                const autoRetry = this.effectiveAutoRetry();
-                const timeoutMessage = autoRetry
-                    ? '[TIMEOUT_KEEP_WAITING] No feedback was submitted within the wait window. This is a TIMEOUT, NOT a cancellation — the user is most likely still away from the keyboard. You MUST immediately call the interactive_feedback tool again with the same project_directory to keep waiting. Do NOT end the conversation, do NOT summarize the task as finished. Only stop calling it when the user EXPLICITLY tells you to stop. 【这是超时续期，并非用户取消：请立即用相同 project_directory 再次调用 interactive_feedback 继续等待，不要结束对话、不要当作任务完成。】'
-                    : '[TIMEOUT_END] No feedback was submitted within the wait window and timeout auto-continue is disabled (MCP_AUTO_RETRY=false). You may end this turn now. 【超时未收到反馈，且已关闭超时续期（MCP_AUTO_RETRY=false），可以结束本轮。】';
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: timeoutMessage,
-                        },
-                    ],
-                };
-            }
-            const result = outcome.data;
-            debugLog(`Received feedback: ${result.interactive_feedback?.substring(0, 100)}...`);
-            const contentItems = [];
-            // 构建反馈文本
-            let feedbackText = '';
-            // 添加文字反馈
-            if (result.interactive_feedback) {
-                feedbackText += `=== User Feedback ===\n${result.interactive_feedback}`;
-            }
-            // 添加附加文件路径
-            if (result.attachedFiles && result.attachedFiles.length > 0) {
-                debugLog(`Processing ${result.attachedFiles.length} attached files`);
-                feedbackText += `\n\n=== Attached Files ===\n`;
-                for (const filePath of result.attachedFiles) {
-                    feedbackText += `${filePath}\n`;
-                }
-                feedbackText += `\nPlease read the above files to understand the context.`;
-            }
-            if (feedbackText) {
-                contentItems.push({
-                    type: 'text',
-                    text: feedbackText,
-                });
-            }
-            // 添加图片
-            if (result.images && result.images.length > 0) {
-                debugLog(`Processing ${result.images.length} images`);
-                for (const img of result.images) {
-                    contentItems.push({
-                        type: 'image',
-                        data: img.data,
-                        mimeType: this.getMimeType(img.name),
-                    });
-                }
-            }
-            if (contentItems.length === 0) {
-                contentItems.push({
-                    type: 'text',
-                    text: 'User did not provide any feedback.',
-                });
-            }
-            return { content: contentItems };
+            const outcome = await this.waitForFeedback(request, timeout * 1000);
+            return this.outcomeToResult(outcome, requestId);
         }
         catch (error) {
             debugLog(`Error collecting feedback: ${error}`);
@@ -414,6 +361,9 @@ class McpFeedbackServer {
                     else if (this.maybeStashForEndedCard(reqId, text, chatId, images, files, messageId)) {
                         // 卡片刚超时、AI 正要续期重调 → 暂存续接到下一轮（超时未认领由 armStashExpiryNotice 回执）
                     }
+                    else if (this.queueForEndedCard(reqId, text, chatId, images, files, messageId)) {
+                        // 忙时排队：AI 正忙（该项目无等待中的请求）→ 消息入队，等下一轮 feedback 自动送达
+                    }
                     else {
                         // 卡片是本实例发的，但请求确实已结束（已被回复 / 超时太久）→ 明确告知
                         this.feishu.replyText(chatId, '这条反馈已经结束了（可能已超时或已被回复）。');
@@ -436,8 +386,16 @@ class McpFeedbackServer {
             const remoteCount = remote.reduce((n, r) => n + r.list.length, 0);
             const globalCount = localPending.length + remoteCount;
             if (globalCount === 0) {
-                // 抢跑兜底：此刻全局无人等待，但很可能 AI 正要发起下一轮（卡片还没注册）。
-                // 暂存到收到消息的本实例，等下一轮 pending 注册时立即兑现。
+                // 忙时排队优先：全局无人等待 = AI 大概率正在干活。定位到唯一的活跃项目窗口时
+                // 直接把消息排队给它（含回执「已排队」），多个活跃窗口则引导用户回复对应卡片。
+                // 复用上面 queryRemotePending 的扫描结果，避免二次全端口扫描。
+                if (this.feishu.isQueueWhenBusy()) {
+                    const routed = await this.routeOrphanToQueue(text, chatId, images, files, messageId, remote);
+                    if (routed)
+                        return;
+                }
+                // 抢跑兜底：定位不到活跃窗口（或队列关闭）时，退回原有短暂存——很可能 AI 正要
+                // 发起下一轮（卡片还没注册），等 pending 注册时立即兑现。
                 // 关键：此刻没有任何 AI 在等待，绝不能给「✅ 已收到」回执——那是虚假承诺，会让用户
                 // 误以为消息已被接收（实则 AI 这轮可能已结束、永远不会来认领，消息石沉大海）。
                 // 回执只在「真正送达某个等待中的请求」时给（见 tryConsumeStash → submitFromFeishu）。
@@ -456,9 +414,14 @@ class McpFeedbackServer {
                 }
             }
             else {
-                // 多个窗口在等 → 不猜。项目名可能重复（同一项目开多窗口），逐项列出也无法区分，
-                // 故不逐项列，直接引导用户去点想回复的那张卡片——回复哪张就精确回到哪个窗口。
-                this.feishu.replyText(chatId, `当前有 ${globalCount} 个窗口在等反馈，没法自动判断你要回复哪个。\n请直接在你想回复的那张卡片上点「回复」再发，回复哪张就回到哪个窗口。`);
+                // 多个等待并存 → 不猜。注意措辞：多个等待可能来自同一窗口的多个对话（用户实测
+                // 「只开了一个窗口却提示多窗口」造成困惑），按「反馈请求」计数并列出项目名，
+                // 引导用户去点想回复的那张卡片——回复哪张就精确回到哪个请求。
+                const names = [
+                    ...localPending.map((p) => this.projectName(p.projectDir)),
+                    ...remote.flatMap((r) => r.list.map((x) => x.projectName)),
+                ];
+                this.feishu.replyText(chatId, `当前有 ${globalCount} 个反馈请求在等待（${names.join('、')}），可能来自不同窗口或同一窗口的多个对话，没法自动判断你要回复哪个。\n请在你想回复的那张卡片上点「回复」再发，回复哪张就送达哪个请求。`);
             }
         });
     }
@@ -551,7 +514,8 @@ class McpFeedbackServer {
         return Promise.all(posts).then((results) => results.some(Boolean));
     }
     /**
-     * 向其他窗口的 server 查询各自的 pending 列表（仅项目名，用于全局视角判断 + 提示文案）。
+     * 向其他窗口的 server 查询各自的 pending 列表（仅项目名，用于全局视角判断 + 提示文案），
+     * 以及实例归属窗口的存活状态（忙时排队用来定位「唯一活跃窗口」）。
      * 用于无 parent_id 的「无主消息」：飞书只推给一个窗口，需汇总全局才能正确决策。
      */
     queryRemotePending() {
@@ -564,21 +528,27 @@ class McpFeedbackServer {
     }
     fetchRemotePending(port) {
         return new Promise((resolve) => {
+            const empty = { port, list: [], ownerWorkspace: null, ownerAlive: false };
             const req = http.request({ hostname: '127.0.0.1', port, path: '/api/feishu/pending', method: 'GET', timeout: 1500 }, (res) => {
                 let body = '';
                 res.on('data', (chunk) => { body += chunk.toString(); });
                 res.on('end', () => {
                     try {
                         const j = JSON.parse(body);
-                        resolve({ port, list: Array.isArray(j.list) ? j.list : [] });
+                        resolve({
+                            port,
+                            list: Array.isArray(j.list) ? j.list : [],
+                            ownerWorkspace: j.ownerWorkspace || null,
+                            ownerAlive: !!j.ownerAlive,
+                        });
                     }
                     catch {
-                        resolve({ port, list: [] });
+                        resolve(empty);
                     }
                 });
             });
-            req.on('error', () => resolve({ port, list: [] }));
-            req.on('timeout', () => { req.destroy(); resolve({ port, list: [] }); });
+            req.on('error', () => resolve(empty));
+            req.on('timeout', () => { req.destroy(); resolve(empty); });
             req.end();
         });
     }
@@ -612,17 +582,121 @@ class McpFeedbackServer {
         for (const [reqId, pending] of this.pendingRequests) {
             if (this.normalizePath(pending.projectDir) !== owner)
                 continue;
+            // 用户显式暂停的等待不作废：暂停 = 用户明确表达「保住这轮、等我回来」，
+            // 不是僵尸残留。同窗口新旧请求并存时，/api/feedback/current 按「未暂停优先」
+            // 返回，active 的结束后暂停中的会重新回到面板，可恢复可提交。
+            if (pending.paused)
+                continue;
             clearTimeout(pending.timeout);
             pending.resolve(null); // → superseded：旧 await 安静结束，不触发重试
             this.feishu.clearPending(reqId);
             this.pendingRequests.delete(reqId);
         }
     }
+    findDuplicatePending(projectDir, summary) {
+        const owner = this.normalizePath(projectDir);
+        for (const [id, pending] of this.pendingRequests) {
+            if (this.normalizePath(pending.projectDir) !== owner)
+                continue;
+            if (pending.request.summary !== summary)
+                continue;
+            if (Date.now() - pending.request.timestamp > McpFeedbackServer.DUP_JOIN_MS)
+                continue;
+            return { id, waiters: pending.waiters };
+        }
+        return null;
+    }
+    /**
+     * 把等待结果翻译成 MCP 工具响应（主等待与重复投递 join 的等待共用同一段收尾语义）。
+     */
+    outcomeToResult(outcome, requestId) {
+        // 被同窗口/同进程的新一轮请求取代：安静结束，绝不能重试（否则多 agent 互相取消、忙等刷屏）。
+        if (outcome.kind === 'superseded') {
+            debugLog(`Request ${requestId} superseded by a newer request; ending this turn quietly`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: '[SUPERSEDED] This feedback request was replaced by a newer interactive_feedback call (the same workspace started a new round, or another agent shares this MCP process). Do NOT call interactive_feedback again for this turn — just end your turn quietly. 【本反馈请求已被同窗口/同进程的新请求取代：不要再次调用 interactive_feedback，安静结束本轮，切勿重试。】',
+                    },
+                ],
+            };
+        }
+        if (outcome.kind === 'timeout') {
+            debugLog('Feedback wait window elapsed without user input');
+            // 超时续期开关：MCP_AUTO_RETRY=false 时关闭（超时即结束），默认开启（超时返回续期提醒）。
+            // 关键：这里【绝不能】说成 "cancelled"——那会让 AI 误以为用户主动取消而结束对话，
+            // 这正是“超时后 AI 直接收尾、不再续命”的根因。改为明确区分“超时 ≠ 取消”。
+            const autoRetry = this.effectiveAutoRetry();
+            const timeoutMessage = autoRetry
+                ? '[TIMEOUT_KEEP_WAITING] No feedback was submitted within the wait window. This is a TIMEOUT, NOT a cancellation — the user is most likely still away from the keyboard. You MUST immediately call the interactive_feedback tool again with the same project_directory to keep waiting. Do NOT end the conversation, do NOT summarize the task as finished. Only stop calling it when the user EXPLICITLY tells you to stop. 【这是超时续期，并非用户取消：请立即用相同 project_directory 再次调用 interactive_feedback 继续等待，不要结束对话、不要当作任务完成。】'
+                : '[TIMEOUT_END] No feedback was submitted within the wait window and timeout auto-continue is disabled (MCP_AUTO_RETRY=false). You may end this turn now. 【超时未收到反馈，且已关闭超时续期（MCP_AUTO_RETRY=false），可以结束本轮。】';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: timeoutMessage,
+                    },
+                ],
+            };
+        }
+        const result = outcome.data;
+        debugLog(`Received feedback: ${result.interactive_feedback?.substring(0, 100)}...`);
+        const contentItems = [];
+        // 构建反馈文本
+        let feedbackText = '';
+        // 添加文字反馈
+        if (result.interactive_feedback) {
+            feedbackText += `=== User Feedback ===\n${result.interactive_feedback}`;
+        }
+        // 添加附加文件路径
+        if (result.attachedFiles && result.attachedFiles.length > 0) {
+            debugLog(`Processing ${result.attachedFiles.length} attached files`);
+            feedbackText += `\n\n=== Attached Files ===\n`;
+            for (const filePath of result.attachedFiles) {
+                feedbackText += `${filePath}\n`;
+            }
+            feedbackText += `\nPlease read the above files to understand the context.`;
+        }
+        if (feedbackText) {
+            contentItems.push({
+                type: 'text',
+                text: feedbackText,
+            });
+        }
+        // 添加图片
+        if (result.images && result.images.length > 0) {
+            debugLog(`Processing ${result.images.length} images`);
+            for (const img of result.images) {
+                contentItems.push({
+                    type: 'image',
+                    data: img.data,
+                    mimeType: this.getMimeType(img.name),
+                });
+            }
+        }
+        if (contentItems.length === 0) {
+            contentItems.push({
+                type: 'text',
+                text: 'User did not provide any feedback.',
+            });
+        }
+        return { content: contentItems };
+    }
     /**
-     * 等待用户反馈
+     * 等待用户反馈：注册 pending 并挂起，结果通过 waiters 广播——
+     * 首个调用与后续 join 进来的重复投递调用都会收到同一份结果。
      */
-    waitForFeedback(requestId, timeoutMs, projectDir) {
+    waitForFeedback(request, timeoutMs) {
         return new Promise((resolve) => {
+            const requestId = request.id;
+            const projectDir = request.projectDir;
+            const waiters = [resolve];
+            // 广播给所有 waiter（splice 清空防重复触发：timeout 与 resolve 竞态时只结算一次）
+            const settle = (outcome) => {
+                for (const w of waiters.splice(0))
+                    w(outcome);
+            };
             const onTimeout = () => {
                 debugLog(`Request ${requestId} timed out`);
                 this.pendingRequests.delete(requestId);
@@ -633,27 +707,30 @@ class McpFeedbackServer {
                         this.recentlyTimedOut.delete(id);
                 }
                 // 飞书侧的清理统一交给 handleInteractiveFeedback 的 finally（clearPending），这里不再重复。
-                resolve({ kind: 'timeout' });
+                settle({ kind: 'timeout' });
             };
             const timeout = setTimeout(onTimeout, timeoutMs);
             this.pendingRequests.set(requestId, {
                 // resolve 包一层：沿用「外部 resolve(feedback) / resolve(null)」旧约定，
                 // 但 null 一律映射为 superseded（被同进程新请求取代），绝不再走「超时重试」路径。
                 resolve: (value) => {
-                    resolve(value === null ? { kind: 'superseded' } : { kind: 'feedback', data: value });
+                    settle(value === null ? { kind: 'superseded' } : { kind: 'feedback', data: value });
                 },
-                reject: () => resolve({ kind: 'superseded' }),
+                reject: () => settle({ kind: 'superseded' }),
                 timeout,
                 projectDir,
                 onTimeout,
                 deadline: Date.now() + timeoutMs,
                 paused: false,
                 remainingMs: timeoutMs,
+                request,
+                waiters,
             });
             // 抢跑兑现：空窗期的面板提交（优先，用户显式点了发送）与飞书暂存消息，
-            // 本轮 pending 一注册立即作为回复提交
+            // 本轮 pending 一注册立即作为回复提交；最后是忙时队列里排队的追加消息
             this.tryConsumePanelStash(requestId);
             this.tryConsumeStash(requestId);
+            this.tryConsumeQueue(requestId);
         });
     }
     /**
@@ -683,20 +760,45 @@ class McpFeedbackServer {
             remainingMs: p.paused ? p.remainingMs : Math.max(0, p.deadline - Date.now()),
         };
     }
-    /** 当前请求的暂停态快照（随 /api/feedback/current 下发，供面板重建后恢复显示） */
-    getPauseState() {
-        const cur = this.currentRequest;
-        if (!cur)
+    /** 指定请求的暂停态快照（随 /api/feedback/current 下发，供面板重建后恢复显示） */
+    getPauseStateFor(requestId) {
+        if (!requestId)
             return null;
-        const p = this.pendingRequests.get(cur.id);
+        const p = this.pendingRequests.get(requestId);
         if (!p)
             return null;
         return {
-            requestId: cur.id,
+            requestId,
             paused: p.paused,
             remainingMs: p.paused ? p.remainingMs : Math.max(0, p.deadline - Date.now()),
         };
     }
+    /**
+     * 按窗口（workspace）从 pendingRequests 挑该窗口该看到的请求。
+     * 修复「多窗口共用一个 MCP 进程时 currentRequest 单值槽互相覆盖、被覆盖的窗口面板
+     * 显示不出自己的等待（只有飞书收到）」：每个窗口轮询时按自己的路径取自己的请求。
+     * 多个匹配时：未暂停的优先（active 请求先服务）；同暂停态取最新——active 的结束后
+     * 暂停中的会自然回到面板，用户可恢复。
+     */
+    pickRequestForWorkspace(normalizedWs) {
+        let best = null;
+        for (const [, p] of this.pendingRequests) {
+            if (!this.pathsRelated(this.normalizePath(p.projectDir), normalizedWs))
+                continue;
+            if (!best) {
+                best = p;
+                continue;
+            }
+            if (best.paused !== p.paused) {
+                if (best.paused)
+                    best = p;
+                continue;
+            }
+            if (p.request.timestamp > best.request.timestamp)
+                best = p;
+        }
+        return best ? best.request : null;
+    }
     /**
      * 写入/合并抢跑暂存：短时间内连发多条（含图文拆条后超出合并窗口的）合并为一条，
      * 绝不让后一条覆盖前一条（旧实现会把第一条静默丢掉）。
@@ -821,6 +923,202 @@ class McpFeedbackServer {
         this.pendingRequests.delete(requestId);
         this.feishu.clearPending(requestId);
     }
+    // ==================== 忙时消息队列 ====================
+    /** 某项目空间当前是否有等待中的反馈请求（路径互为前缀视为同一窗口语境） */
+    hasPendingForProject(projectDir) {
+        const owner = this.normalizePath(projectDir);
+        for (const [, p] of this.pendingRequests) {
+            if (this.pathsRelated(this.normalizePath(p.projectDir), owner))
+                return true;
+        }
+        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));
+    }
+    /**
+     * 用户回复了一张「已结束」的卡片（不在超时续接窗口内）→ 忙时排队：
+     * - 该项目已有新一轮在等 → 引导回复最新卡片（避免旧回复窜入错误轮次），视为已处理；
+     * - 该项目没有等待中的请求（AI 正忙）→ 入队，等下一轮 feedback 自动送达。
+     * 返回 true 表示已处理（排队或已引导），false 表示队列关闭 / 定位不到归属，走原有「已结束」回执。
+     */
+    queueForEndedCard(reqId, text, chatId, images, files, messageId) {
+        if (!this.feishu.isQueueWhenBusy())
+            return false;
+        const cardProject = this.feishu.projectDirOf(reqId);
+        if (!cardProject)
+            return false;
+        if (this.hasPendingForProject(cardProject)) {
+            this.feishu.replyToMessage(messageId || undefined, chatId, '这张卡片的反馈已结束，且该项目有新的反馈卡片正在等待。请「回复」最新的那张卡片。');
+            return true;
+        }
+        this.enqueueInbound(text, chatId, images, files, messageId, cardProject);
+        return true;
+    }
+    /**
+     * 消息入队 + 回执用户「已排队」。每条消息带 60 分钟过期兜底：
+     * 到点仍未被 AI 读取（对话可能已结束）→ 引用回复告知未送达，绝不静默丢弃。
+     */
+    enqueueInbound(text, chatId, images, files, messageId, forProjectDir) {
+        // 上限保护：挤出最老的一条并告知未送达
+        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，请稍后重发。');
+        }
+        const item = {
+            text,
+            chatId,
+            images,
+            files,
+            at: Date.now(),
+            messageId,
+            forProjectDir,
+            expiryTimer: undefined,
+        };
+        item.expiryTimer = setTimeout(() => {
+            const idx = this.queuedInbound.indexOf(item);
+            if (idx < 0)
+                return; // 已被消费
+            this.queuedInbound.splice(idx, 1);
+            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)}」当前任务完成后自动读取。`);
+    }
+    /**
+     * 队列兑现：新一轮 pending 注册时，把属于该项目空间的所有排队消息合并成一次反馈送达，
+     * 正文附「任务期间追加」提示头，并给每条排队消息补 ✅ 送达回执。
+     */
+    tryConsumeQueue(requestId) {
+        const pending = this.pendingRequests.get(requestId);
+        if (!pending)
+            return;
+        if (this.queuedInbound.length === 0)
+            return;
+        const owner = this.normalizePath(pending.projectDir);
+        const matched = this.queuedInbound.filter((q) => this.pathsRelated(this.normalizePath(q.forProjectDir), owner));
+        if (matched.length === 0)
+            return;
+        this.queuedInbound = this.queuedInbound.filter((q) => !matched.includes(q));
+        for (const m of matched)
+            clearTimeout(m.expiryTimer);
+        const two = (n) => String(n).padStart(2, '0');
+        const fmt = (at) => {
+            const d = new Date(at);
+            return `${two(d.getHours())}:${two(d.getMinutes())}:${two(d.getSeconds())}`;
+        };
+        const lines = matched.map((m) => {
+            const body = m.text || (m.images.length || m.files.length ? '[图片/附件]' : '');
+            return `[${fmt(m.at)}] ${body}`;
+        });
+        const text = '[QUEUED_MESSAGES] 以下是用户在你执行上一轮任务期间「追加」发送的消息（当时你正忙，消息已排队暂存）。' +
+            '注意：这些内容不是对你最新一轮工作摘要的回复，请结合任务上下文阅读并处理；' +
+            '如与你摘要中的询问冲突，以用户追加内容为准。处理完后照常调用 interactive_feedback 继续对话。\n\n' +
+            `=== 追加消息（${matched.length} 条）===\n` +
+            lines.join('\n\n');
+        debugLog(`Consuming ${matched.length} queued message(s) for request: ${requestId}`);
+        clearTimeout(pending.timeout);
+        pending.resolve({
+            interactive_feedback: text,
+            images: matched.flatMap((m) => m.images),
+            attachedFiles: matched.flatMap((m) => m.files),
+            project_directory: pending.projectDir,
+        });
+        this.pendingRequests.delete(requestId);
+        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);
+        }
+    }
+    /** 「我的窗口」是否仍活着（无插件 host 无从判定，视为活跃） */
+    isOwnerAlive() {
+        if (!this.everOwnerPolled)
+            return true;
+        return Date.now() - this.lastOwnerPollTime <= McpFeedbackServer.OWNER_IDLE_MS;
+    }
+    /**
+     * 「无主消息」的忙时排队路由：全局无人等待时，汇总所有实例的活跃项目窗口——
+     * - 恰好 1 个 → 消息排队给它（本地直接入队；远程实例经 /api/feishu/enqueue 转发）；
+     * - 多个 → 回执引导用户回复对应项目的卡片（回复旧卡片也会正确排队到该项目）；
+     * - 0 个 → 返回 false，调用方退回原有短暂存兜底。
+     */
+    async routeOrphanToQueue(text, chatId, images, files, messageId, remotes) {
+        const candidates = [];
+        if (this.ownerWorkspace && this.isOwnerAlive()) {
+            candidates.push({ port: null, workspace: this.ownerWorkspace });
+        }
+        for (const r of remotes) {
+            if (r.ownerAlive && r.ownerWorkspace) {
+                candidates.push({ port: r.port, workspace: r.ownerWorkspace });
+            }
+        }
+        // 按 workspace 去重（同窗口多对话共用/多实例只算一个活跃窗口；本地优先）
+        const seen = new Set();
+        const uniq = [];
+        for (const c of candidates) {
+            const key = this.normalizePath(c.workspace);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            uniq.push(c);
+        }
+        if (uniq.length === 1) {
+            const target = uniq[0];
+            if (target.port === null) {
+                this.enqueueInbound(text, chatId, images, files, messageId, target.workspace);
+                return true;
+            }
+            return this.forwardEnqueue(target.port, text, chatId, images, files, messageId);
+        }
+        if (uniq.length > 1) {
+            const names = uniq.map((c) => this.projectName(c.workspace));
+            this.feishu.replyToMessage(messageId || undefined, chatId, `当前有 ${uniq.length} 个项目窗口在工作（${names.join('、')}），没法判断这条消息要发给谁。\n` +
+                '请「回复」你要发送的那个项目的卡片（旧卡片也行），消息会排队到对应项目。');
+            return true;
+        }
+        return false;
+    }
+    /** 把无主消息转发给远程实例排队（远程会自己入队并回执用户）。返回是否排队成功 */
+    forwardEnqueue(port, text, chatId, images, files, messageId) {
+        const body = JSON.stringify({ text, chatId, images, attachedFiles: files, messageId });
+        return new Promise((resolve) => {
+            const req = http.request({
+                hostname: '127.0.0.1',
+                port,
+                path: '/api/feishu/enqueue',
+                method: 'POST',
+                timeout: 2000,
+                headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+            }, (res) => {
+                let resBody = '';
+                res.on('data', (chunk) => { resBody += chunk.toString(); });
+                res.on('end', () => {
+                    try {
+                        resolve(!!JSON.parse(resBody).queued);
+                    }
+                    catch {
+                        resolve(false);
+                    }
+                });
+            });
+            req.on('error', () => resolve(false));
+            req.on('timeout', () => { req.destroy(); resolve(false); });
+            req.write(body);
+            req.end();
+        });
+    }
     /**
      * 处理获取系统信息请求
      */
@@ -963,6 +1261,7 @@ class McpFeedbackServer {
                     if (req.method === 'GET' && req.url?.startsWith('/api/feedback/current')) {
                         // autoRetry 不再从轮询 query 同步（曾致多窗口互相覆盖、抖动）：
                         // 改由 POST /api/settings/autoRetry 广播 + 磁盘真相源，poll 只回读做 UI 回显。
+                        let pollWs = '';
                         try {
                             const u = new URL(req.url, 'http://127.0.0.1');
                             // 「我的窗口」心跳：仅当轮询带的 workspace 匹配本实例归属时刷新。
@@ -971,6 +1270,7 @@ class McpFeedbackServer {
                             // 匹配放宽为「路径互为前缀」：AI 传的 project_directory 可能是窗口工作区的子目录。
                             // 命中即确认 owner 身份（ownerConfirmed），此后 owner 不再被后续调用改写。
                             const ws = this.normalizePath(u.searchParams.get('workspace') || '');
+                            pollWs = ws;
                             if (ws && this.ownerWorkspace && this.pathsRelated(ws, this.ownerWorkspace)) {
                                 this.lastOwnerPollTime = Date.now();
                                 this.everOwnerPolled = true;
@@ -980,16 +1280,19 @@ class McpFeedbackServer {
                         catch {
                             // 忽略解析错误
                         }
+                        // 按窗口挑请求：多窗口/多对话共用本进程时各窗口各看各的等待，互不覆盖。
+                        // 不带 workspace（无工作区窗口 / 旧版插件）时回退全局 currentRequest 老行为。
+                        const chosen = pollWs ? this.pickRequestForWorkspace(pollWs) : (this.currentRequest || null);
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        // 返回当前请求、ownerWorkspace、startTime，以及当前生效的 autoRetry（供 UI 初始同步）
+                        // 返回该窗口的请求、ownerWorkspace、startTime，以及当前生效的 autoRetry（供 UI 初始同步）
                         res.end(JSON.stringify({
-                            request: this.currentRequest || null,
+                            request: chosen,
                             ownerWorkspace: this.ownerWorkspace,
                             startTime: this.startTime,
                             autoRetry: this.autoRetryOverride !== null ? this.autoRetryOverride : (process.env.MCP_AUTO_RETRY !== 'false'),
                             feishu: this.feishu.getStatus(),
                             feishuResolvedId: (this.lastFeishuResolved && Date.now() - this.lastFeishuResolved.at < 30000) ? this.lastFeishuResolved.id : null,
-                            pause: this.getPauseState(),
+                            pause: this.getPauseStateFor(chosen?.id),
                         }));
                         return;
                     }
@@ -1054,6 +1357,7 @@ class McpFeedbackServer {
                                         appSecret: cfg.appSecret || '',
                                         enabled: cfg.enabled,
                                         ackReaction: cfg.ackReaction,
+                                        queueWhenBusy: cfg.queueWhenBusy,
                                         touched: true,
                                     });
                                     await this.feishu.configure(cfg);
@@ -1144,6 +1448,12 @@ class McpFeedbackServer {
                                     res.writeHead(200, { 'Content-Type': 'application/json' });
                                     res.end(JSON.stringify({ handled: true }));
                                 }
+                                else if (reqId &&
+                                    this.queueForEndedCard(reqId, text, chatId, images || [], attachedFiles || [], messageId || '')) {
+                                    // 本实例的卡片、请求已结束且 AI 正忙 → 消息已排队（或已引导回复新卡片）
+                                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ handled: true }));
+                                }
                                 else {
                                     res.writeHead(200, { 'Content-Type': 'application/json' });
                                     res.end(JSON.stringify({ handled: false }));
@@ -1166,7 +1476,13 @@ class McpFeedbackServer {
                             ? []
                             : this.feishu.listPending().map((p) => ({ projectName: this.projectName(p.projectDir) }));
                         res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ count: list.length, list }));
+                        // ownerWorkspace / ownerAlive：供其他实例的忙时排队路由定位「活跃项目窗口」
+                        res.end(JSON.stringify({
+                            count: list.length,
+                            list,
+                            ownerWorkspace: this.ownerWorkspace,
+                            ownerAlive: !!this.ownerWorkspace && !ownerGone,
+                        }));
                         return;
                     }
                     // 接收「无主消息」转发：仅当本实例恰好持有唯一 pending 时认领提交
@@ -1195,6 +1511,31 @@ class McpFeedbackServer {
                         });
                         return;
                     }
+                    // 接收「无主消息」的忙时排队转发：本实例是全局唯一活跃窗口时，把消息排进本实例队列
+                    // （入队与「已排队」回执都由本实例完成，转发方只关心 queued 结果）
+                    if (req.method === 'POST' && req.url === '/api/feishu/enqueue') {
+                        let body = '';
+                        req.on('data', (chunk) => { body += chunk.toString(); });
+                        req.on('end', () => {
+                            try {
+                                const { text, chatId, images, attachedFiles, messageId } = JSON.parse(body);
+                                if (this.feishu.isQueueWhenBusy() && this.ownerWorkspace) {
+                                    this.enqueueInbound(text, chatId, images || [], attachedFiles || [], messageId || '', this.ownerWorkspace);
+                                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ queued: true }));
+                                }
+                                else {
+                                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ queued: false }));
+                                }
+                            }
+                            catch {
+                                res.writeHead(400);
+                                res.end('{}');
+                            }
+                        });
+                        return;
+                    }
                     // 健康检查
                     if (req.method === 'GET' && req.url === '/api/health') {
                         res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -1292,6 +1633,7 @@ class McpFeedbackServer {
             appSecret,
             enabled: process.env.FEISHU_ENABLED !== 'false',
             ackReaction: process.env.FEISHU_ACK !== 'false',
+            queueWhenBusy: process.env.FEISHU_QUEUE !== 'false',
         };
     }
     /**
@@ -1421,6 +1763,11 @@ class McpFeedbackServer {
             pending.resolve(null);
         }
         this.pendingRequests.clear();
+        // 清理忙时队列的过期定时器（进程将退出，消息由 60 分钟兜底逻辑以外的重启场景自然失效）
+        for (const q of this.queuedInbound) {
+            clearTimeout(q.expiryTimer);
+        }
+        this.queuedInbound = [];
         // 关闭 MCP 服务器
         this.server.close();
         debugLog('Server stopped');
@@ -1436,11 +1783,21 @@ McpFeedbackServer.STASH_TTL_MS = 5000;
  * 都应暂存并续接到下一轮，而不是报「Request not found / 已结束」把用户内容丢掉。
  */
 McpFeedbackServer.REJOIN_TTL_MS = 15000;
+/** 队列消息未被读取的兜底时长：超过视为对话已结束，回执用户避免静默丢失 */
+McpFeedbackServer.QUEUE_TTL_MS = 60 * 60 * 1000;
+/** 队列长度上限：极端情况下防止无限堆积 */
+McpFeedbackServer.QUEUE_MAX = 100;
 /**
  * 「我的窗口」判定为已关闭的空闲阈值：本实例曾被自己窗口插件轮询，但超过此时长没再收到
  *（只剩别的窗口在扫端口）→ 视为我的窗口已关、本实例是僵尸：不再上报 pending，避免污染全局计数。
  */
 McpFeedbackServer.OWNER_IDLE_MS = 12000;
+/**
+ * 查找可 join 的「重复投递」等待：同窗口 + 同 summary + 注册时间在 DUP_JOIN_MS 内。
+ * AI 每一轮的 summary 几乎不可能与上一轮一字不差，短窗口内完全相同基本可断定为
+ * 客户端/传输层对同一次 tool call 的重复投递。
+ */
+McpFeedbackServer.DUP_JOIN_MS = 90000;
 // 主函数
 async function main() {
     const port = 61927;

package/dist/webview/index.html

@@ -199,6 +199,14 @@
           </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">

package/dist/webview/script.js

@@ -98,8 +98,10 @@
   const systemNotifyToggle = document.getElementById('systemNotifyToggle');
   const osNotifyToggle = document.getElementById('osNotifyToggle');
   const feishuAckToggle = document.getElementById('feishuAckToggle');
+  const feishuQueueToggle = document.getElementById('feishuQueueToggle');
   const osNotifySub = document.getElementById('osNotifySub');
   const feishuAckSub = document.getElementById('feishuAckSub');
+  const feishuQueueSub = document.getElementById('feishuQueueSub');
   const notifyTestBtn = document.getElementById('notifyTestBtn');
   const notifyTestHint = document.getElementById('notifyTestHint');
   const historyBtn = document.getElementById('historyBtn');
@@ -239,6 +241,9 @@
   feishuAckToggle.addEventListener('change', () => {
     vscode.postMessage({ type: 'toggleFeishuAck', payload: { enabled: feishuAckToggle.checked } });
   });
+  feishuQueueToggle.addEventListener('change', () => {
+    vscode.postMessage({ type: 'toggleFeishuQueue', payload: { enabled: feishuQueueToggle.checked } });
+  });
 
   // 发送测试通知：一键验证系统通知链路通不通（权限被拒时收不到，配合上方排查提示定位）
   let notifyTestHintTimer = null;
@@ -257,6 +262,8 @@
     const feishuOn = feishuEnabledToggle.checked;
     feishuAckToggle.disabled = !feishuOn;
     if (feishuAckSub) feishuAckSub.classList.toggle('is-disabled', !feishuOn);
+    feishuQueueToggle.disabled = !feishuOn;
+    if (feishuQueueSub) feishuQueueSub.classList.toggle('is-disabled', !feishuOn);
   }
 
   function updateFeishuUI(state) {
@@ -276,6 +283,9 @@
     if (typeof state.feishuAck === 'boolean') {
       feishuAckToggle.checked = state.feishuAck;
     }
+    if (typeof state.feishuQueue === 'boolean') {
+      feishuQueueToggle.checked = state.feishuQueue;
+    }
     syncSubSwitchDisabled();
     feishuStatusEl.classList.toggle('is-configured', !!state.configured && !state.bound);
     feishuStatusEl.classList.toggle('is-bound', !!state.bound);
@@ -1263,6 +1273,11 @@
           ? (i18n.toastQueued || 'Queued — will be delivered to AI next round')
           : (i18n.toastSubmitted || 'Feedback sent'));
         break;
+
+      case 'toast':
+        // extension 侧的通用轻提示（如暂停失败：请求已结束）
+        if (message.payload && message.payload.text) showToast(message.payload.text);
+        break;
     }
   });
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "cursor-feedback",
   "displayName": "Cursor Feedback",
   "description": "One Cursor conversation, unlimited AI interactions - Save your monthly request quota! Interactive feedback loop for AI chat via MCP",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "icon": "icon.png",
   "author": "jianger666",
   "license": "MIT",