cursor-feedback 2.0.5 → 2.1.1

package/dist/mcp-server.js

@@ -90,6 +90,10 @@ class McpFeedbackServer {
          * 暂存后等下一轮 pending 一注册立即兑现，避免回复石沉大海（修复用户反馈的竞态 bug）。
          */
         this.stashedInbound = null;
+        /** 最近超时结束的请求（id → 归属窗口/时刻），供面板提交与飞书旧卡片回复「续接」下一轮 */
+        this.recentlyTimedOut = new Map();
+        /** 面板在超时空窗内提交的反馈：暂存到下一轮 pending 注册时立即兑现 */
+        this.panelStash = null;
         /** 暂存过期提示定时器：到点仍未被认领则「回复」那条消息告知没送到，避免静默丢弃 */
         this.stashExpiryTimer = null;
         // 最近一次被飞书回复 resolve 的请求：供插件端精确区分「飞书回复」与「超时」，
@@ -104,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 调用都会刷新）
@@ -118,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({
@@ -251,9 +262,18 @@ class McpFeedbackServer {
         // 不清理会让 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 = {
             id: requestId,
@@ -291,10 +311,7 @@ class McpFeedbackServer {
                 // 超时续期开关：MCP_AUTO_RETRY=false 时关闭（超时即结束），默认开启（超时返回续期提醒）。
                 // 关键：这里【绝不能】说成 "cancelled"——那会让 AI 误以为用户主动取消而结束对话，
                 // 这正是“超时后 AI 直接收尾、不再续命”的根因。改为明确区分“超时 ≠ 取消”。
-                // 优先用 UI 开关（autoRetryOverride），未设置时回退到环境变量 / 默认开启
-                const autoRetry = this.autoRetryOverride !== null
-                    ? this.autoRetryOverride
-                    : (process.env.MCP_AUTO_RETRY !== 'false');
+                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），可以结束本轮。】';
@@ -394,14 +411,20 @@ class McpFeedbackServer {
                     if (this.pendingRequests.has(reqId)) {
                         this.submitFromFeishu(reqId, text, chatId, images, files, messageId);
                     }
+                    else if (this.maybeStashForEndedCard(reqId, text, chatId, images, files, messageId)) {
+                        // 卡片刚超时、AI 正要续期重调 → 暂存续接到下一轮（超时未认领由 armStashExpiryNotice 回执）
+                    }
                     else {
-                        // 卡片是本实例发的，但请求已结束（超时 / 已回复）→ 明确告知，不必广播
+                        // 卡片是本实例发的，但请求确实已结束（已被回复 / 超时太久）→ 明确告知
                         this.feishu.replyText(chatId, '这条反馈已经结束了（可能已超时或已被回复）。');
                     }
                 }
                 else {
-                    // 不是本实例发出的卡片 → 广播给其他窗口的 server
-                    this.broadcastFeishuInbound(parentId, text, chatId, images, files, messageId);
+                    // 不是本实例发出的卡片 → 广播给其他窗口的 server；无人认领必须回执，绝不静默丢弃
+                    const claimed = await this.broadcastFeishuInbound(parentId, text, chatId, images, files, messageId);
+                    if (!claimed) {
+                        this.feishu.replyToMessage(messageId || undefined, chatId, '⚠️ 这张卡片对应的反馈已结束或其所在窗口已关闭，消息未能送达。请回复最新的卡片，或等 AI 下次询问时再发。');
+                    }
                 }
                 return;
             }
@@ -418,8 +441,7 @@ class McpFeedbackServer {
                 // 关键：此刻没有任何 AI 在等待，绝不能给「✅ 已收到」回执——那是虚假承诺，会让用户
                 // 误以为消息已被接收（实则 AI 这轮可能已结束、永远不会来认领，消息石沉大海）。
                 // 回执只在「真正送达某个等待中的请求」时给（见 tryConsumeStash → submitFromFeishu）。
-                this.stashedInbound = { text, chatId, images, files, at: Date.now(), messageId };
-                this.armStashExpiryNotice();
+                this.stashInbound(text, chatId, images, files, messageId, McpFeedbackServer.STASH_TTL_MS);
             }
             else if (globalCount === 1) {
                 if (localPending.length === 1) {
@@ -440,6 +462,12 @@ class McpFeedbackServer {
             }
         });
     }
+    /** 当前生效的超时续期开关（优先 UI 开关 autoRetryOverride，未设置时回退环境变量/默认开启） */
+    effectiveAutoRetry() {
+        return this.autoRetryOverride !== null
+            ? this.autoRetryOverride
+            : (process.env.MCP_AUTO_RETRY !== 'false');
+    }
     projectName(dir) {
         return dir.replace(/\\/g, '/').replace(/\/+$/, '').split('/').pop() || dir;
     }
@@ -447,6 +475,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);
@@ -457,7 +495,8 @@ class McpFeedbackServer {
             interactive_feedback: text,
             images,
             attachedFiles,
-            project_directory: this.currentRequest?.projectDir || '',
+            // 用 pending 自己的归属窗口：共享进程多窗口时 currentRequest 可能已是另一窗口的请求
+            project_directory: pending.projectDir || this.currentRequest?.projectDir || '',
         });
         this.pendingRequests.delete(requestId);
         this.feishu.clearPending(requestId);
@@ -470,31 +509,46 @@ class McpFeedbackServer {
             this.feishu.reactDone(ackMessageId || undefined, chatId);
         }
     }
-    /** 把飞书回复广播给其他窗口的 server（跨实例路由兜底） */
+    /**
+     * 把飞书回复广播给其他窗口的 server（跨实例路由兜底）。
+     * 返回是否有任一实例认领（handled）——无人认领时调用方必须回执用户，不能静默丢弃。
+     */
     broadcastFeishuInbound(parentId, text, chatId, images = [], attachedFiles = [], messageId) {
         const body = JSON.stringify({ parentId, text, chatId, images, attachedFiles, messageId });
+        const posts = [];
         for (let p = this.basePort; p < this.basePort + McpFeedbackServer.PORT_SCAN_RANGE; p++) {
             if (p === this.port)
                 continue;
-            const req = http.request({
-                hostname: '127.0.0.1',
-                port: p,
-                path: '/api/feishu/inbound',
-                method: 'POST',
-                timeout: 2000,
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Content-Length': Buffer.byteLength(body),
-                },
-            }, (res) => {
-                res.on('data', () => { });
-                res.on('end', () => { });
-            });
-            req.on('error', () => { });
-            req.on('timeout', () => req.destroy());
-            req.write(body);
-            req.end();
+            posts.push(new Promise((resolve) => {
+                const req = http.request({
+                    hostname: '127.0.0.1',
+                    port: p,
+                    path: '/api/feishu/inbound',
+                    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).handled);
+                        }
+                        catch {
+                            resolve(false);
+                        }
+                    });
+                });
+                req.on('error', () => resolve(false));
+                req.on('timeout', () => { req.destroy(); resolve(false); });
+                req.write(body);
+                req.end();
+            }));
         }
+        return Promise.all(posts).then((results) => results.some(Boolean));
     }
     /**
      * 向其他窗口的 server 查询各自的 pending 列表（仅项目名，用于全局视角判断 + 提示文案）。
@@ -569,12 +623,19 @@ class McpFeedbackServer {
      */
     waitForFeedback(requestId, timeoutMs, projectDir) {
         return new Promise((resolve) => {
-            const timeout = setTimeout(() => {
+            const onTimeout = () => {
                 debugLog(`Request ${requestId} timed out`);
                 this.pendingRequests.delete(requestId);
+                // 记录「刚超时」：续期空窗内的面板提交 / 旧卡片回复可续接到下一轮（顺手清理过期记录）
+                this.recentlyTimedOut.set(requestId, { projectDir, at: Date.now() });
+                for (const [id, v] of this.recentlyTimedOut) {
+                    if (Date.now() - v.at > McpFeedbackServer.REJOIN_TTL_MS * 4)
+                        this.recentlyTimedOut.delete(id);
+                }
                 // 飞书侧的清理统一交给 handleInteractiveFeedback 的 finally（clearPending），这里不再重复。
                 resolve({ kind: 'timeout' });
-            }, timeoutMs);
+            };
+            const timeout = setTimeout(onTimeout, timeoutMs);
             this.pendingRequests.set(requestId, {
                 // resolve 包一层：沿用「外部 resolve(feedback) / resolve(null)」旧约定，
                 // 但 null 一律映射为 superseded（被同进程新请求取代），绝不再走「超时重试」路径。
@@ -584,19 +645,114 @@ class McpFeedbackServer {
                 reject: () => resolve({ kind: 'superseded' }),
                 timeout,
                 projectDir,
+                onTimeout,
+                deadline: Date.now() + timeoutMs,
+                paused: false,
+                remainingMs: timeoutMs,
             });
-            // 抢跑兑现：用户在空窗期「无主」发来的消息已被暂存，本轮 pending 一注册立即作为回复提交
+            // 抢跑兑现：空窗期的面板提交（优先，用户显式点了发送）与飞书暂存消息，
+            // 本轮 pending 一注册立即作为回复提交
+            this.tryConsumePanelStash(requestId);
             this.tryConsumeStash(requestId);
         });
     }
     /**
-     * 暂存「无主消息」后，启动过期提示定时器：到 STASH_TTL_MS 仍没被 AI 认领，就「回复」
+     * 暂停/恢复某个待反馈请求的超时倒计时（用户在面板点暂停按钮触发）。
+     * 暂停 = 冻结真实计时器并记下剩余时间；恢复 = 用剩余时间重新起表。
+     * 暂停期间 AI 一直挂在 interactive_feedback 调用上等待，正是期望行为（等同无限超时）。
+     */
+    setPaused(requestId, paused) {
+        const p = this.pendingRequests.get(requestId);
+        if (!p)
+            return { ok: false, paused: false, remainingMs: 0 };
+        if (paused && !p.paused) {
+            clearTimeout(p.timeout);
+            p.remainingMs = Math.max(0, p.deadline - Date.now());
+            p.paused = true;
+            debugLog(`Request ${requestId} countdown paused (${p.remainingMs}ms left)`);
+        }
+        else if (!paused && p.paused) {
+            p.paused = false;
+            p.deadline = Date.now() + p.remainingMs;
+            p.timeout = setTimeout(p.onTimeout, p.remainingMs);
+            debugLog(`Request ${requestId} countdown resumed (${p.remainingMs}ms left)`);
+        }
+        return {
+            ok: true,
+            paused: p.paused,
+            remainingMs: p.paused ? p.remainingMs : Math.max(0, p.deadline - Date.now()),
+        };
+    }
+    /** 当前请求的暂停态快照（随 /api/feedback/current 下发，供面板重建后恢复显示） */
+    getPauseState() {
+        const cur = this.currentRequest;
+        if (!cur)
+            return null;
+        const p = this.pendingRequests.get(cur.id);
+        if (!p)
+            return null;
+        return {
+            requestId: cur.id,
+            paused: p.paused,
+            remainingMs: p.paused ? p.remainingMs : Math.max(0, p.deadline - Date.now()),
+        };
+    }
+    /**
+     * 写入/合并抢跑暂存：短时间内连发多条（含图文拆条后超出合并窗口的）合并为一条，
+     * 绝不让后一条覆盖前一条（旧实现会把第一条静默丢掉）。
+     */
+    stashInbound(text, chatId, images, files, messageId, ttlMs, forProjectDir) {
+        const prev = this.stashedInbound;
+        if (prev && Date.now() - prev.at <= prev.ttlMs && prev.chatId === chatId) {
+            // 未过期的同会话暂存 → 合并追加，刷新时间与 TTL
+            this.stashedInbound = {
+                text: [prev.text, text].filter(Boolean).join('\n'),
+                chatId,
+                images: [...prev.images, ...images],
+                files: [...prev.files, ...files],
+                at: Date.now(),
+                messageId: messageId || prev.messageId,
+                ttlMs: Math.max(prev.ttlMs, ttlMs),
+                forProjectDir: forProjectDir ?? prev.forProjectDir,
+            };
+        }
+        else {
+            this.stashedInbound = { text, chatId, images, files, at: Date.now(), messageId, ttlMs, forProjectDir };
+        }
+        this.armStashExpiryNotice();
+    }
+    /**
+     * 用户回复了一张「刚超时」的卡片：超时续期开启时 AI 马上会重新发起下一轮，
+     * 把回复暂存续接到下一轮，而不是回一句「已结束」把用户的内容丢掉。
+     * 返回 true 表示已暂存（调用方无需再回执）。
+     */
+    maybeStashForEndedCard(reqId, text, chatId, images, files, messageId) {
+        const rt = this.recentlyTimedOut.get(reqId);
+        if (!rt)
+            return false; // 不是「刚超时」的请求（可能已被回复过，或结束太久）
+        if (Date.now() - rt.at > McpFeedbackServer.REJOIN_TTL_MS)
+            return false;
+        if (!this.effectiveAutoRetry())
+            return false; // 续期关闭 → 不会有下一轮，别让用户空等
+        // 同窗口已有新一轮在等 → 用户该回复新卡片，不做续接（避免旧回复窜入错误轮次）
+        const owner = this.normalizePath(rt.projectDir);
+        for (const [, pending] of this.pendingRequests) {
+            if (this.normalizePath(pending.projectDir) === owner)
+                return false;
+        }
+        debugLog(`Reply to recently timed-out card ${reqId}, stashing for next round`);
+        this.stashInbound(text, chatId, images, files, messageId, McpFeedbackServer.REJOIN_TTL_MS, rt.projectDir);
+        return true;
+    }
+    /**
+     * 暂存后启动过期提示定时器：到 TTL 仍没被 AI 认领，就「回复」
      * 那条消息明确告知没送到、引导重发（不再静默丢弃，也不给虚假回执）。
-     * 每来一条无主消息都重置，避免连发时多个定时器并存。
+     * 每来一条都重置，避免连发时多个定时器并存。
      */
     armStashExpiryNotice() {
         if (this.stashExpiryTimer)
             clearTimeout(this.stashExpiryTimer);
+        const ttl = this.stashedInbound?.ttlMs ?? McpFeedbackServer.STASH_TTL_MS;
         this.stashExpiryTimer = setTimeout(() => {
             this.stashExpiryTimer = null;
             const stash = this.stashedInbound;
@@ -608,23 +764,31 @@ class McpFeedbackServer {
             // 且引导「待 AI 回复后再重发」：AI 只有重新调起 feedback（即回复）时才会等待接收，
             // 此刻立即重发仍会落空。
             this.feishu.replyToMessage(stash.messageId, stash.chatId, '⚠️ 消息未能送达 AI（它可能正忙于上一轮任务，或这轮对话已结束）。需要的话请待 AI 回复后重新发送一次。');
-        }, McpFeedbackServer.STASH_TTL_MS);
+        }, ttl);
     }
     /**
-     * 抢跑暂存兑现：若存在近期「无主」飞书消息，立即作为指定请求的回复提交。
-     * 超过 STASH_TTL_MS 的暂存视为与当前任务无关，直接丢弃。
+     * 抢跑暂存兑现：若存在近期暂存的飞书消息，立即作为指定请求的回复提交。
+     * 过期的暂存视为与当前任务无关，直接丢弃；带窗口限定的暂存只给对应窗口。
      */
     tryConsumeStash(requestId) {
         const stash = this.stashedInbound;
         if (!stash)
             return;
+        const pending = this.pendingRequests.get(requestId);
+        if (!pending)
+            return; // 请求已不在（不能消费暂存，留给真正等待中的下一轮）
+        // 带窗口限定的暂存（回复旧卡片的续接）只给同一窗口的新一轮，不给别的项目
+        if (stash.forProjectDir &&
+            this.normalizePath(stash.forProjectDir) !== this.normalizePath(pending.projectDir)) {
+            return;
+        }
         this.stashedInbound = null;
         // 已被 AI 认领，取消「没送到」提示定时器
         if (this.stashExpiryTimer) {
             clearTimeout(this.stashExpiryTimer);
             this.stashExpiryTimer = null;
         }
-        if (Date.now() - stash.at > McpFeedbackServer.STASH_TTL_MS) {
+        if (Date.now() - stash.at > stash.ttlMs) {
             debugLog('Stashed inbound expired, dropped');
             return;
         }
@@ -633,6 +797,30 @@ class McpFeedbackServer {
         // 暂存阶段不再预先回执，避免「没人接却假装已收到」误导用户。
         this.submitFromFeishu(requestId, stash.text, stash.chatId, stash.images, stash.files, stash.messageId);
     }
+    /**
+     * 面板暂存兑现：用户在「刚超时、AI 正要续期重调」的空窗内点了提交，
+     * 反馈已被 /api/feedback/submit 暂存，这里在下一轮注册时立即送达。
+     */
+    tryConsumePanelStash(requestId) {
+        const stash = this.panelStash;
+        if (!stash)
+            return;
+        const pending = this.pendingRequests.get(requestId);
+        if (!pending)
+            return;
+        if (this.normalizePath(stash.projectDir) !== this.normalizePath(pending.projectDir))
+            return;
+        this.panelStash = null;
+        if (Date.now() - stash.at > McpFeedbackServer.REJOIN_TTL_MS) {
+            debugLog('Panel stash expired, dropped');
+            return;
+        }
+        debugLog(`Consuming panel stash for request: ${requestId}`);
+        clearTimeout(pending.timeout);
+        pending.resolve(stash.feedback);
+        this.pendingRequests.delete(requestId);
+        this.feishu.clearPending(requestId);
+    }
     /**
      * 处理获取系统信息请求
      */
@@ -780,10 +968,13 @@ class McpFeedbackServer {
                             // 「我的窗口」心跳：仅当轮询带的 workspace 匹配本实例归属时刷新。
                             // 别的活跃窗口对全端口的扫描虽刷 lastActivityTime，但 workspace 不匹配、不刷此字段，
                             // 故已关窗口的残留 server 不会被别人续命，可被 watchdog / 僵尸自检识别。
+                            // 匹配放宽为「路径互为前缀」：AI 传的 project_directory 可能是窗口工作区的子目录。
+                            // 命中即确认 owner 身份（ownerConfirmed），此后 owner 不再被后续调用改写。
                             const ws = this.normalizePath(u.searchParams.get('workspace') || '');
-                            if (ws && ws === this.ownerWorkspace) {
+                            if (ws && this.ownerWorkspace && this.pathsRelated(ws, this.ownerWorkspace)) {
                                 this.lastOwnerPollTime = Date.now();
                                 this.everOwnerPolled = true;
+                                this.ownerConfirmed = true;
                             }
                         }
                         catch {
@@ -798,6 +989,7 @@ class McpFeedbackServer {
                             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(),
                         }));
                         return;
                     }
@@ -813,6 +1005,7 @@ class McpFeedbackServer {
                                 const { requestId, feedback } = data;
                                 debugLog(`Received feedback submission for request: ${requestId}`);
                                 const pending = this.pendingRequests.get(requestId);
+                                const recentTimeout = this.recentlyTimedOut.get(requestId);
                                 if (pending) {
                                     clearTimeout(pending.timeout);
                                     pending.resolve(feedback);
@@ -821,6 +1014,16 @@ class McpFeedbackServer {
                                     res.writeHead(200, { 'Content-Type': 'application/json' });
                                     res.end(JSON.stringify({ success: true }));
                                 }
+                                else if (recentTimeout &&
+                                    this.effectiveAutoRetry() &&
+                                    Date.now() - recentTimeout.at <= McpFeedbackServer.REJOIN_TTL_MS) {
+                                    // 提交撞上「刚超时、AI 正要续期重调」的空窗：暂存并在下一轮注册时立即送达，
+                                    // 不再报 "Request not found" 把用户刚敲的反馈打回去
+                                    debugLog(`Request ${requestId} timed out moments ago; queueing panel feedback for next round`);
+                                    this.panelStash = { feedback, projectDir: recentTimeout.projectDir, at: Date.now() };
+                                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ success: true, queued: true }));
+                                }
                                 else {
                                     debugLog(`Request ${requestId} not found`);
                                     res.writeHead(404, { 'Content-Type': 'application/json' });
@@ -865,6 +1068,35 @@ class McpFeedbackServer {
                         });
                         return;
                     }
+                    // 暂停/恢复倒计时（来自插件 UI 的暂停按钮）
+                    if (req.method === 'POST' && req.url === '/api/feedback/pause') {
+                        let body = '';
+                        req.on('data', (chunk) => { body += chunk.toString(); });
+                        req.on('end', () => {
+                            try {
+                                const { requestId, paused } = JSON.parse(body);
+                                if (!requestId || typeof paused !== 'boolean') {
+                                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ error: 'requestId and paused are required' }));
+                                    return;
+                                }
+                                const result = this.setPaused(requestId, paused);
+                                if (result.ok) {
+                                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ success: true, paused: result.paused, remainingMs: result.remainingMs }));
+                                }
+                                else {
+                                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                                    res.end(JSON.stringify({ error: 'Request not found' }));
+                                }
+                            }
+                            catch {
+                                res.writeHead(400, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ error: 'Invalid body' }));
+                            }
+                        });
+                        return;
+                    }
                     // 超时续期开关（来自插件 UI；磁盘做真相源，跨窗口/重启一致；不再走轮询 query）
                     if (req.method === 'POST' && req.url === '/api/settings/autoRetry') {
                         let body = '';
@@ -906,6 +1138,12 @@ class McpFeedbackServer {
                                     res.writeHead(200, { 'Content-Type': 'application/json' });
                                     res.end(JSON.stringify({ handled: true }));
                                 }
+                                else if (reqId &&
+                                    this.maybeStashForEndedCard(reqId, text, chatId, images || [], attachedFiles || [], messageId || '')) {
+                                    // 本实例的卡片刚超时 → 暂存续接下一轮，向广播方声明已认领（未送达时由过期提示回执）
+                                    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 }));
@@ -1143,8 +1381,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);
@@ -1154,9 +1397,13 @@ class McpFeedbackServer {
         this.watchdogTimer.unref();
     }
     /**
-     * 停止服务器
+     * 停止服务器（幂等：重复调用 / server.close() 触发 onclose 再次进入时直接返回）
      */
     stop() {
+        if (this.stopping) {
+            return;
+        }
+        this.stopping = true;
         debugLog('Stopping server...');
         // 关闭看门狗定时器
         if (this.watchdogTimer) {
@@ -1183,6 +1430,12 @@ McpFeedbackServer.PORT_SCAN_RANGE = 20; // 与插件端扫描范围保持一致
 /** 抢跑暂存有效期：覆盖「AI 刚结束、正要调下一轮 feedback」的竞态间隙（通常 1-3s）。
  *  取 5s——太长会把已脱离语境的旧消息硬塞进很久后才出现的新一轮，造成上下文错乱（像答非所问）。 */
 McpFeedbackServer.STASH_TTL_MS = 5000;
+/**
+ * 「刚超时」请求的续接窗口：超时续期开启时，AI 收到 TIMEOUT_KEEP_WAITING 后重新发起下一轮
+ * 通常要 2~10s（取决于模型和上下文大小）。这段空窗内用户的面板提交 / 对旧卡片的回复
+ * 都应暂存并续接到下一轮，而不是报「Request not found / 已结束」把用户内容丢掉。
+ */
+McpFeedbackServer.REJOIN_TTL_MS = 15000;
 /**
  * 「我的窗口」判定为已关闭的空闲阈值：本实例曾被自己窗口插件轮询，但超过此时长没再收到
  *（只剩别的窗口在扫端口）→ 视为我的窗口已关、本实例是僵尸：不再上报 pending，避免污染全局计数。

package/dist/webview/index.html

@@ -73,6 +73,9 @@
           <h2 id="feedbackLabel" class="card__title">{{i18n.yourFeedback}}</h2>
         </div>
 
+        <!-- 快捷回复短语：点击直接发送；铅笔进入编辑模式可增删自定义 -->
+        <div id="quickReplies" class="quick-replies"></div>
+
         <div class="composer">
           <div id="refChips" class="ref-chips"></div>
           <textarea id="feedbackInput" class="composer__input" rows="4"
@@ -88,6 +91,9 @@
               <button id="insertContextBtn" class="iconbtn" type="button" data-tip="{{i18n.insertSelection}}" aria-label="{{i18n.insertSelection}}">
                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/></svg>
               </button>
+              <button id="historyBtn" class="iconbtn" type="button" data-tip="{{i18n.historyBtn}}" aria-label="{{i18n.historyBtn}}">
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/><path d="M12 7v5l4 2"/></svg>
+              </button>
             </div>
             <span class="composer__hint">{{i18n.contextHint}}</span>
             <span id="charCount" class="composer__count">0</span>
@@ -104,6 +110,10 @@
     <footer id="submitBar" class="submitbar hidden">
       <!-- 倒计时进度 -->
       <div id="timeoutWrap" class="countdown" hidden>
+        <button id="pauseBtn" class="iconbtn countdown__pause" type="button" aria-label="{{i18n.pauseCountdown}}" data-tip="{{i18n.pauseCountdown}}">
+          <svg class="countdown__pause-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="6" y="4" width="4" height="16" rx="1"/><rect x="14" y="4" width="4" height="16" rx="1"/></svg>
+          <svg class="countdown__play-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polygon points="6 3 20 12 6 21 6 3"/></svg>
+        </button>
         <div class="countdown__track" role="progressbar" aria-label="Time remaining">
           <div id="timeoutBar" class="countdown__bar"></div>
         </div>
@@ -164,6 +174,12 @@
             <span class="feishu-switch__track"><span class="feishu-switch__thumb"></span></span>
           </label>
           <p class="feishu-modal__desc feishu-modal__desc--sub">{{i18n.osNotifyDesc}}</p>
+          <!-- 权限被拒的排查指引（按平台注入文案，linux 为空则整行隐藏） -->
+          <p class="feishu-modal__desc feishu-modal__desc--sub feishu-troubleshoot">{{i18n.notifyTroubleshoot}}</p>
+          <div class="feishu-test-row">
+            <button id="notifyTestBtn" class="feishu-link" type="button">{{i18n.notifyTestBtn}}</button>
+            <span id="notifyTestHint" class="feishu-test-hint"></span>
+          </div>
         </div>
       </div>
 
@@ -212,6 +228,12 @@
   <!-- @ 文件引用浮层（fixed 定位，避免被裁切） -->
   <div id="mentionPopup" class="mention-popup hidden" role="listbox" aria-label="{{i18n.mentionFiles}}"></div>
 
+  <!-- 反馈历史浮层（点击条目回填到输入框） -->
+  <div id="historyPopup" class="history-popup hidden" role="listbox" aria-label="{{i18n.historyBtn}}"></div>
+
+  <!-- 提交结果轻提示（toast，几秒后自动消失） -->
+  <div id="toast" class="toast hidden" role="status" aria-live="polite"></div>
+
   <!-- 注入 i18n 数据 -->
   <script>window.i18n = {{I18N_JSON}};</script>
   <script src="{{SCRIPT_JS_URI}}"></script>