cursor-feedback 2.0.4 → 2.1.0

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 的请求：供插件端精确区分「飞书回复」与「超时」，
@@ -250,7 +254,7 @@ class McpFeedbackServer {
         // 旧请求多半是对话被压缩 / 客户端取消后还卡在 await 的残留（要等 timeout 才自然结束），
         // 不清理会让 pendingCount 虚高、全局视角误判「多个窗口在等」
         //（即你看到的两个一模一样的 cursor-feedback-extension）。
-        this.cancelStalePending();
+        this.cancelStalePending(projectDir);
         // AI 调用 feedback 时设置 ownerWorkspace（这是唯一正确的时机）
         this.ownerWorkspace = this.normalizePath(projectDir);
         debugLog(`Owner workspace set to: ${this.ownerWorkspace}`);
@@ -273,16 +277,25 @@ class McpFeedbackServer {
         }
         try {
             // 等待用户反馈
-            const result = await this.waitForFeedback(requestId, timeout * 1000);
-            if (!result) {
+            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 直接收尾、不再续命”的根因。改为明确区分“超时 ≠ 取消”。
-                // 优先用 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），可以结束本轮。】';
@@ -295,6 +308,7 @@ class McpFeedbackServer {
                     ],
                 };
             }
+            const result = outcome.data;
             debugLog(`Received feedback: ${result.interactive_feedback?.substring(0, 100)}...`);
             const contentItems = [];
             // 构建反馈文本
@@ -381,14 +395,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;
             }
@@ -405,8 +425,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) {
@@ -427,6 +446,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;
     }
@@ -444,7 +469,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);
@@ -457,31 +483,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 列表（仅项目名，用于全局视角判断 + 提示文案）。
@@ -532,48 +573,160 @@ class McpFeedbackServer {
         req.end();
     }
     /**
-     * 作废本实例所有未决的反馈请求（在每次新请求进来时调用）。
-     * 单个 server 实例服务单个 Cursor 窗口的单个对话，同时只应有一个活跃反馈请求；
-     * resolve(null) 让旧的 await 自然返回走超时分支，其 finally 因 id 不匹配不会误清新请求。
+     * 作废「同一窗口（projectDir）」此前残留的未决反馈请求（每次新请求进来时调用）。
+     * 关键：绝不能动其他窗口 / agent 的 pending——多窗口或 AgentWindow 会复用同一个 MCP 进程，
+     * 误清它们会让对方被当成超时而立即重试，多个 agent 互相取消，形成「取消风暴」（高频刷调用）。
+     * 被作废者 resolve(null) → waitForFeedback 映射为 superseded，旧 await 安静结束、不重试；
+     * 其 finally 因 id 不匹配也不会误清新请求。
      */
-    cancelStalePending() {
+    cancelStalePending(projectDir) {
         if (this.pendingRequests.size === 0)
             return;
+        const owner = this.normalizePath(projectDir);
         for (const [reqId, pending] of this.pendingRequests) {
+            if (this.normalizePath(pending.projectDir) !== owner)
+                continue;
             clearTimeout(pending.timeout);
-            pending.resolve(null);
+            pending.resolve(null); // → superseded：旧 await 安静结束，不触发重试
             this.feishu.clearPending(reqId);
+            this.pendingRequests.delete(reqId);
         }
-        this.pendingRequests.clear();
     }
     /**
      * 等待用户反馈
      */
-    waitForFeedback(requestId, timeoutMs) {
+    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(null);
-            }, timeoutMs);
+                resolve({ kind: 'timeout' });
+            };
+            const timeout = setTimeout(onTimeout, timeoutMs);
             this.pendingRequests.set(requestId, {
-                resolve,
-                reject: () => resolve(null),
-                timeout
+                // resolve 包一层：沿用「外部 resolve(feedback) / resolve(null)」旧约定，
+                // 但 null 一律映射为 superseded（被同进程新请求取代），绝不再走「超时重试」路径。
+                resolve: (value) => {
+                    resolve(value === null ? { kind: 'superseded' } : { kind: 'feedback', data: value });
+                },
+                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;
@@ -585,23 +738,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;
         }
@@ -610,6 +771,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);
+    }
     /**
      * 处理获取系统信息请求
      */
@@ -775,6 +960,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;
                     }
@@ -790,6 +976,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);
@@ -798,6 +985,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' });
@@ -842,6 +1039,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 = '';
@@ -883,6 +1109,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 }));
@@ -1085,10 +1317,13 @@ class McpFeedbackServer {
      * Cursor 关闭后，stdin 的 EOF 在该中间层下不可靠，node 易变成孤儿进程残留；
      * 叠加 HTTP server 是常驻 active handle，进程无法自然退出。
      *
-     * 两道防线：
-     * 1) 父进程死亡（被 init/launchd 收养，ppid 变为 1）→ 立即退出；
-     * 2) 超过 IDLE_TIMEOUT 没有任何插件轮询 / MCP 调用 → 判定所有 Cursor 窗口已关闭 → 退出。
-     *    （插件每秒轮询 HTTP，只要还有任意 Cursor 窗口存活就会持续刷新活动时间）
+     * 防线（按环境自适应）：
+     * 1) 父进程死亡（被 init/launchd 收养，ppid 变为 1）→ 立即退出。**所有环境通用**。
+     * 2) 超过 IDLE_TIMEOUT 无活动 → 判定所有 Cursor 窗口已关闭 → 退出。
+     *    **仅 Cursor 插件环境（everOwnerPolled）且无 pending 等待时才退**：插件每秒轮询 HTTP 刷新活动时间、
+     *    停了就是关窗。无插件 host（Claude Desktop / CLI / 其他 MCP 客户端 / fe-ai-flow）没有轮询心跳、
+     *    idle 是常态、不靠它退出、只走防线 1 + stdin EOF（见 main 的 stdin close/end/error）。
+     * 3) 曾被本窗口插件轮询、但久未再收到（僵尸实例、只剩别的窗口扫端口续命）→ 退出。
      */
     startWatchdog() {
         const IDLE_TIMEOUT = process.env.MCP_FEEDBACK_IDLE_TIMEOUT
@@ -1101,9 +1336,16 @@ class McpFeedbackServer {
                 this.stop();
                 process.exit(0);
             }
-            // 防线 2：长时间无任何活动 = Cursor 已全部关闭
+            // 防线 2：长时间无任何活动 = Cursor 已全部关闭。
+            // 仅对「Cursor 插件环境」（everOwnerPolled：曾被自己窗口插件轮询过）生效——插件每秒轮询、
+            // 停了就是关窗。无插件 host（Claude Desktop / CLI / 其他 MCP 客户端 / fe-ai-flow 等）没有轮询心跳、
+            // idle 是常态、绝不能据此退出：否则 AI 调 interactive_feedback 等用户飞书回复的那几分钟里进程会自杀、
+            // 回复永远回不来。这类 host 完全靠 stdin close/end/error（见 main）+ 防线 1（ppid===1）退出。
+            // 另外：只要还有 pending 反馈在等用户、任何环境都不 idle 退出（正在等用户，绝不能死）。
             const idle = Date.now() - this.lastActivityTime;
-            if (idle > IDLE_TIMEOUT) {
+            if (this.everOwnerPolled &&
+                this.pendingRequests.size === 0 &&
+                idle > IDLE_TIMEOUT) {
                 debugLog(`No activity for ${idle}ms (> ${IDLE_TIMEOUT}ms), assuming Cursor closed, exiting...`);
                 this.stop();
                 process.exit(0);
@@ -1150,6 +1392,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>