cursor-feedback 2.1.2 → 2.2.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 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)
 
 

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

@@ -177,6 +177,8 @@ class FeedbackViewProvider {
         this._feishuEnabled = true;
         // Get 表情回执子开关（飞书通知子项；关掉后用户飞书回复不加 Get 表情、也不发文字兜底）
         this._feishuAck = true;
+        // 忙时消息排队子开关（飞书通知子项；AI 正忙时用户消息入队，下一轮 feedback 自动送达）
+        this._feishuQueue = true;
         this._debugInfo = {
             portRange: '',
             workspacePath: '',
@@ -194,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;
     }
     /**
      * 获取翻译消息
@@ -277,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;
@@ -973,6 +979,7 @@ class FeedbackViewProvider {
                 bound: this._feishuBound,
                 feishuEnabled: this._feishuEnabled,
                 feishuAck: this._feishuAck,
+                feishuQueue: this._feishuQueue,
                 systemNotification: !!systemNotification,
                 osNotification: !!osNotification
             }
@@ -1007,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) {
@@ -1023,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;
@@ -1041,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(() => { });
@@ -1100,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",

package/dist/i18n/zh-CN.json

@@ -73,6 +73,8 @@
   "osNotifyDesc": "IDE 切到后台时，用系统通知提醒你。",
   "feishuAckLabel": "Get 表情回执",
   "feishuAckDesc": "你在飞书回复后，机器人加个 Get 表情表示「已收到」。",
+  "feishuQueueLabel": "忙时消息排队",
+  "feishuQueueDesc": "AI 正忙时你发的消息先排队，等它下一轮询问时自动送达，并附「任务期间追加」提示。",
   "quickReplyDefault1": "继续等待我的反馈",
   "quickReplyDefault2": "结束任务",
   "quickReplyEdit": "编辑快捷短语",

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 的请求：供插件端精确区分「飞书回复」与「超时」，
@@ -297,8 +303,10 @@ class McpFeedbackServer {
         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 {
@@ -353,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, '这条反馈已经结束了（可能已超时或已被回复）。');
@@ -375,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）。
@@ -495,7 +514,8 @@ class McpFeedbackServer {
         return Promise.all(posts).then((results) => results.some(Boolean));
     }
     /**
-     * 向其他窗口的 server 查询各自的 pending 列表（仅项目名，用于全局视角判断 + 提示文案）。
+     * 向其他窗口的 server 查询各自的 pending 列表（仅项目名，用于全局视角判断 + 提示文案），
+     * 以及实例归属窗口的存活状态（忙时排队用来定位「唯一活跃窗口」）。
      * 用于无 parent_id 的「无主消息」：飞书只推给一个窗口，需汇总全局才能正确决策。
      */
     queryRemotePending() {
@@ -508,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();
         });
     }
@@ -701,9 +727,10 @@ class McpFeedbackServer {
                 waiters,
             });
             // 抢跑兑现：空窗期的面板提交（优先，用户显式点了发送）与飞书暂存消息，
-            // 本轮 pending 一注册立即作为回复提交
+            // 本轮 pending 一注册立即作为回复提交；最后是忙时队列里排队的追加消息
             this.tryConsumePanelStash(requestId);
             this.tryConsumeStash(requestId);
+            this.tryConsumeQueue(requestId);
         });
     }
     /**
@@ -896,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();
+        });
+    }
     /**
      * 处理获取系统信息请求
      */
@@ -1134,6 +1357,7 @@ class McpFeedbackServer {
                                         appSecret: cfg.appSecret || '',
                                         enabled: cfg.enabled,
                                         ackReaction: cfg.ackReaction,
+                                        queueWhenBusy: cfg.queueWhenBusy,
                                         touched: true,
                                     });
                                     await this.feishu.configure(cfg);
@@ -1224,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 }));
@@ -1246,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 时认领提交
@@ -1275,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' });
@@ -1372,6 +1633,7 @@ class McpFeedbackServer {
             appSecret,
             enabled: process.env.FEISHU_ENABLED !== 'false',
             ackReaction: process.env.FEISHU_ACK !== 'false',
+            queueWhenBusy: process.env.FEISHU_QUEUE !== 'false',
         };
     }
     /**
@@ -1501,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');
@@ -1516,6 +1783,10 @@ 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，避免污染全局计数。

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);

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.2",
+  "version": "2.2.0",
   "icon": "icon.png",
   "author": "jianger666",
   "license": "MIT",