cursor-feedback 2.1.0 → 2.1.2

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.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)
+
+
+### Bug Fixes
+
+* **mcp:** 等待反馈期间不再被僵尸判定误杀——Connection closed 断连根因修复 ([39cc9d5](https://github.com/jianger666/cursor-feedback-extension/commit/39cc9d5fe5730023069014c8a749841993117efa))
+
 ## [2.1.0](https://github.com/jianger666/cursor-feedback-extension/compare/v2.0.5...v2.1.0) (2026-07-02)
 
 

package/dist/extension.js

@@ -46,6 +46,12 @@ let feedbackViewProvider = null;
 function normalizePath(p) {
     return (p || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
 }
+/** 两个已归一化的路径互为前缀（相等 / 一方是另一方的子目录）即视为同一窗口语境 */
+function pathsRelated(a, b) {
+    if (!a || !b)
+        return false;
+    return a === b || a.startsWith(b + '/') || b.startsWith(a + '/');
+}
 function activate(context) {
     // 注册侧边栏 WebView（端口从 61927 开始自动扫描）
     feedbackViewProvider = new FeedbackViewProvider(context.extensionUri, 61927, context.globalState);
@@ -109,8 +115,9 @@ function getWorkspacePaths() {
     return folders.map(f => f.uri.fsPath);
 }
 /**
- * 检查路径是否匹配当前工作区（精确匹配）
- * - 有工作区的窗口：只接收匹配工作区路径的消息
+ * 检查路径是否匹配当前工作区
+ * - 有工作区的窗口：接收匹配工作区路径的消息（相等或互为子目录——AI 传的
+ *   project_directory 常是工作区的子目录，精确匹配会漏收，面板收不到、心跳也失配）
  * - 没有工作区的窗口：只接收没有指定项目路径的消息
  */
 function isPathInWorkspace(targetPath) {
@@ -128,9 +135,7 @@ function isPathInWorkspace(targetPath) {
         return false;
     }
     for (const wsPath of workspacePaths) {
-        const normalizedWs = normalizePath(wsPath);
-        // 精确匹配：只匹配完全相同的路径
-        if (normalizedTarget === normalizedWs) {
+        if (pathsRelated(normalizedTarget, normalizePath(wsPath))) {
             return true;
         }
     }
@@ -156,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，前端用小眼睛切换明文/掩码）
@@ -331,15 +341,19 @@ class FeedbackViewProvider {
             // 如果有活跃端口，先尝试只轮询该端口
             if (this._activePort) {
                 const result = await this._checkPortForRequest(this._activePort);
-                // 检查是否仍然是我们的 Server
+                // 检查是否仍然是我们的 Server。注意：多窗口/多对话共用一个 MCP 进程时，
+                // server 的 ownerWorkspace（进程归属，单值）可能是别的窗口——但只要它按窗口
+                // 返回了本工作区的请求（request 已在 _checkPortForRequest 里按 projectDir 过滤），
+                // 这个端口对本窗口就是有效的，不能因 owner 不匹配而丢弃请求。
                 if (result.connected) {
                     const serverOwner = result.ownerWorkspace ? normalizePath(result.ownerWorkspace) : '';
-                    const isMyServer = !serverOwner || 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();
@@ -370,14 +384,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 || 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];
@@ -466,41 +479,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);
         }
     }
     /**
@@ -682,6 +704,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();
@@ -717,6 +740,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();
@@ -902,6 +927,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 不支持（旧版本）或未连接：静默降级，倒计时照常走

package/dist/i18n/en.json

@@ -89,6 +89,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

@@ -89,6 +89,7 @@
   "notifyTestBody": "这是一条测试通知 · 点击试试能否唤起 Cursor",
   "toastSubmitted": "✓ 反馈已发送",
   "toastQueued": "✓ 已暂存，AI 下一轮将自动收到",
+  "pauseFailedEnded": "暂停失败：该请求已结束（超时或已被回复）",
   "historyBtn": "反馈历史",
   "historyEmpty": "还没有历史记录，提交过的反馈会出现在这里"
 }

package/dist/mcp-server.js

@@ -108,6 +108,10 @@ class McpFeedbackServer {
         // 所属工作区（只在 AI 调用 feedback 时设置）
         // 只有来自同一工作区的轮询才会更新活动时间
         this.ownerWorkspace = null;
+        // owner 身份是否已被真实窗口的轮询验证过。验证后 ownerWorkspace 不再被后续调用改写：
+        // AI 传的 project_directory 是「正在操作的项目」，不一定等于窗口工作区（同窗口操作兄弟/子目录很常见），
+        // 每次改写会让插件心跳失配 → 实例被防线 3 当僵尸误杀（等待反馈中直接 Connection closed）。
+        this.ownerConfirmed = false;
         // Server 启动时间
         this.startTime = Date.now();
         // 最近一次活动时间（任意 HTTP 轮询 / MCP 调用都会刷新）
@@ -122,6 +126,9 @@ class McpFeedbackServer {
         this.everOwnerPolled = false;
         // 看门狗定时器（兜底退出，防止进程残留 / CPU 占满）
         this.watchdogTimer = null;
+        // stop() 防重入：server.close() 会触发 transport.onclose → 回调里又调 stop()，
+        // 无标志位会无限递归直至 "Maximum call stack size exceeded"（日志曾刷出数万条 Stopping server...）
+        this.stopping = false;
         this.port = port;
         this.basePort = port;
         this.server = new index_js_1.Server({
@@ -250,22 +257,41 @@ 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 虚高、全局视角误判「多个窗口在等」
         //（即你看到的两个一模一样的 cursor-feedback-extension）。
         this.cancelStalePending(projectDir);
-        // AI 调用 feedback 时设置 ownerWorkspace（这是唯一正确的时机）
-        this.ownerWorkspace = this.normalizePath(projectDir);
-        debugLog(`Owner workspace set to: ${this.ownerWorkspace}`);
+        // AI 调用 feedback 时设置 ownerWorkspace；但 owner 一旦被真实窗口的轮询验证过（ownerConfirmed）
+        // 就锁定不再改写——project_directory 只代表 AI 正在操作的项目，改写已验证的窗口身份
+        // 会让心跳失配、实例被防线 3 误杀。
+        const normalizedProjectDir = this.normalizePath(projectDir);
+        if (!this.ownerConfirmed) {
+            this.ownerWorkspace = normalizedProjectDir;
+            debugLog(`Owner workspace set to: ${this.ownerWorkspace}`);
+        }
+        else if (normalizedProjectDir !== this.ownerWorkspace) {
+            debugLog(`Owner workspace kept as ${this.ownerWorkspace} (confirmed by window polling); ` +
+                `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}`);
@@ -277,79 +303,8 @@ class McpFeedbackServer {
         }
         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}`);
@@ -440,9 +395,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请在你想回复的那张卡片上点「回复」再发，回复哪张就送达哪个请求。`);
             }
         });
     }
@@ -459,6 +419,16 @@ class McpFeedbackServer {
     normalizePath(p) {
         return (p || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
     }
+    /**
+     * 两个已归一化的路径是否属于同一窗口语境：相等，或一方是另一方的子目录。
+     * 用于 owner 心跳匹配——AI 传的 project_directory 常是窗口工作区的子目录（monorepo 子包等），
+     * 精确相等会漏判、心跳失配导致实例被防线 3 误杀。
+     */
+    pathsRelated(a, b) {
+        if (!a || !b)
+            return false;
+        return a === b || a.startsWith(b + '/') || b.startsWith(a + '/');
+    }
     /** 飞书回复命中某 requestId → resolve 该 pending，并回执用户 */
     submitFromFeishu(requestId, text, chatId, images = [], attachedFiles = [], ackMessageId) {
         const pending = this.pendingRequests.get(requestId);
@@ -586,17 +556,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);
@@ -607,22 +681,24 @@ 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 一注册立即作为回复提交
@@ -657,20 +733,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;
+    }
     /**
      * 写入/合并抢跑暂存：短时间内连发多条（含图文拆条后超出合并窗口的）合并为一条，
      * 绝不让后一条覆盖前一条（旧实现会把第一条静默丢掉）。
@@ -937,30 +1038,38 @@ 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 匹配本实例归属时刷新。
                             // 别的活跃窗口对全端口的扫描虽刷 lastActivityTime，但 workspace 不匹配、不刷此字段，
                             // 故已关窗口的残留 server 不会被别人续命，可被 watchdog / 僵尸自检识别。
+                            // 匹配放宽为「路径互为前缀」：AI 传的 project_directory 可能是窗口工作区的子目录。
+                            // 命中即确认 owner 身份（ownerConfirmed），此后 owner 不再被后续调用改写。
                             const ws = this.normalizePath(u.searchParams.get('workspace') || '');
-                            if (ws && ws === this.ownerWorkspace) {
+                            pollWs = ws;
+                            if (ws && this.ownerWorkspace && this.pathsRelated(ws, this.ownerWorkspace)) {
                                 this.lastOwnerPollTime = Date.now();
                                 this.everOwnerPolled = true;
+                                this.ownerConfirmed = true;
                             }
                         }
                         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;
                     }
@@ -1352,8 +1461,13 @@ class McpFeedbackServer {
             }
             // 防线 3：本实例曾被自己窗口插件轮询，但久未再收到（只剩别的活跃窗口在扫端口刷 lastActivityTime）
             // → 我的窗口已关、本实例是僵尸 → 退出，避免持续被全局 pending 计数误算成「另一个在等的窗口」。
+            // ⚠️ 与防线 2 同款约束：还有 pending 反馈在等用户时绝不退——曾因缺这一条，AI 在等待反馈期间
+            //    传了与窗口工作区不同的 project_directory（改写 owner 后心跳失配），30 秒后实例被当僵尸杀掉，
+            //    正在等待的 interactive_feedback 直接报 "MCP error -32000: Connection closed"。
             const ownerIdle = Date.now() - this.lastOwnerPollTime;
-            if (this.everOwnerPolled && ownerIdle > IDLE_TIMEOUT) {
+            if (this.everOwnerPolled &&
+                this.pendingRequests.size === 0 &&
+                ownerIdle > IDLE_TIMEOUT) {
                 debugLog(`Owner window idle for ${ownerIdle}ms, stale instance, exiting...`);
                 this.stop();
                 process.exit(0);
@@ -1363,9 +1477,13 @@ class McpFeedbackServer {
         this.watchdogTimer.unref();
     }
     /**
-     * 停止服务器
+     * 停止服务器（幂等：重复调用 / server.close() 触发 onclose 再次进入时直接返回）
      */
     stop() {
+        if (this.stopping) {
+            return;
+        }
+        this.stopping = true;
         debugLog('Stopping server...');
         // 关闭看门狗定时器
         if (this.watchdogTimer) {
@@ -1403,6 +1521,12 @@ McpFeedbackServer.REJOIN_TTL_MS = 15000;
  *（只剩别的窗口在扫端口）→ 视为我的窗口已关、本实例是僵尸：不再上报 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/script.js

@@ -1263,6 +1263,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.0",
+  "version": "2.1.2",
   "icon": "icon.png",
   "author": "jianger666",
   "license": "MIT",