wezard 1.1.1 → 1.1.4

package/config.example.jsonc

@@ -62,6 +62,7 @@
   // ── PreToolUse approval (all tools → button card; align with auth-helper) ─
   "approval": {
     "enabled": true,
+    "mode": "all",               // all = 每次调用都发卡；danger = 只有命中下面危险名单的才发卡，其余静默放行
     "matcher": ".*",             // 全量拦截；Bash 只读命令(grep/ls/cat/...)走脚本 fast-path
     "approvers": [],             // ["user:zhangsan"] empty → defaultChat
     "hookTimeoutSec": 43210,     // hook curl --max-time (12h + 10s)

package/dist/daemon/approval.js

@@ -1,7 +1,8 @@
-import { createPending, getPending, getResolvedSnapshot, resolvePending, resolvePendingsByChat, failPending } from "./pending.js";
+import { closeSync, fstatSync, openSync, readFileSync, readSync } from "node:fs";
+import { createPending, getPending, getResolvedSnapshot, resolvePending, resolvePendingsByChat, failPending, stashResolved, markCardSent, isReloadError } from "./pending.js";
 import { cacheGet, cachePut, cacheKey, isAutoWindowActive, autoWindowRemainingMs, setAutoWindow, clearAutoWindow, getWindowMeta, } from "./session-cache.js";
 import { redact } from "./redact.js";
-import { dangerOf } from "./danger.js";
+import { dangerOf, dangerModeSkips } from "./danger.js";
 import { recordApproval, recordApprovalDecision, buildDetailUrl } from "./detail.js";
 import { json, readBody } from "./http.js";
 import { tagBadge, withTagHeader } from "../shared/session-label.js";
@@ -499,6 +500,53 @@ const parsePlanInput = (i) => {
     const p = i.plan;
     return typeof p === "string" ? p : "";
 };
+// CodeBuddy 的 ExitPlanMode 不带 plan 正文 (arguments=="{}"); plan 写在
+// ~/.codebuddy/plans/<slug>.md (plan mode 系统消息指定, 模型用 Write/Edit 逐步
+// 成型)。从 transcript 尾部倒查最后一次指向 plans 目录的 file_path, 再读文件
+// 取最新内容。arguments 是转义后的内嵌 JSON 串 (\"file_path\":\"...\") 且嵌着
+// 整份 plan (单行可能数百 KB), 用正则抠路径 (\\? 兼容转义/未转义), 不做 parse。
+const PLAN_PATH_RE = /\\?"file_path\\?"\s*:\s*\\?"([^"\\]*\/\.codebuddy\/plans\/[^"\\]+\.md)\\?"/;
+const TRANSCRIPT_TAIL_BYTES = 256 * 1024;
+const PLAN_FILE_CAP = 64 * 1024;
+const tailText = (p, bytes) => {
+    const fd = openSync(p, "r");
+    try {
+        const size = fstatSync(fd).size;
+        const start = Math.max(0, size - bytes);
+        const buf = Buffer.alloc(size - start);
+        readSync(fd, buf, 0, buf.length, start);
+        return buf.toString("utf8");
+    }
+    finally {
+        closeSync(fd);
+    }
+};
+const planPathFromTranscript = (transcriptPath) => {
+    const lines = tailText(transcriptPath, TRANSCRIPT_TAIL_BYTES).split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const m = PLAN_PATH_RE.exec(lines[i]);
+        if (m)
+            return m[1];
+    }
+    return undefined;
+};
+// tool_input.plan (Claude) → transcript 定位 plans 文件 (CodeBuddy) → ""。
+const resolvePlanText = (toolInput, transcriptPath) => {
+    const direct = parsePlanInput(toolInput);
+    if (direct)
+        return direct;
+    if (!transcriptPath)
+        return "";
+    try {
+        const p = planPathFromTranscript(transcriptPath);
+        if (!p)
+            return "";
+        return readFileSync(p, "utf8").slice(0, PLAN_FILE_CAP);
+    }
+    catch {
+        return "";
+    }
+};
 const PLAN_TITLE_MAX = 26;
 const PLAN_PREVIEW_LINES = 25;
 const PLAN_PREVIEW_CHARS = 1500;
@@ -512,7 +560,7 @@ const buildPlanMarkdown = (plan) => {
     }
     return `**📋 计划待审批**\n\n${body}`;
 };
-const buildPlanCard = (reqId, _sessionId, cwd, transcriptTail, approver) => {
+const buildPlanCard = (reqId, _sessionId, cwd, transcriptTail, approver, hasPlan) => {
     const tail = oneLine(transcriptTail).trim();
     const tag = emojiFor(approver);
     const dir = dirName(cwd);
@@ -520,7 +568,9 @@ const buildPlanCard = (reqId, _sessionId, cwd, transcriptTail, approver) => {
         card_type: "button_interaction",
         source: buildSource(tail),
         main_title: { title: TRUNC(`📋 计划审批 · ${tag}${dir}/`, PLAN_TITLE_MAX + 12) },
-        sub_title_text: "审阅上方计划后选择:同意开始执行,或让 Claude 继续完善。",
+        sub_title_text: hasPlan
+            ? "审阅上方计划后选择:同意开始执行,或让 Claude 继续完善。"
+            : "完整计划见 CLI。选择:同意开始执行,或继续完善。",
         task_id: reqId,
         button_list: [
             { text: "✏️ 继续改", style: 4, key: encodePlanKey(reqId, "revise") },
@@ -541,6 +591,8 @@ const buildPlanResolvedCard = (reqId, action, cwd, transcriptTail, approver) =>
     };
 };
 const handleExitPlanMode = async ({ cfg, log, client, body, getMirrorTarget, flushBeforeCard }) => {
+    // 此分支只服务 Claude 家族 (hook 即时触发, tool_input.plan 带正文)。
+    // codebuddy 的 ExitPlanMode 不过 hook → 见 runMirrorPlanFlow。
     const plan = parsePlanInput(body.tool_input);
     if (!plan)
         return { decision: "ask", reason: "plan_unparsable" };
@@ -576,18 +628,20 @@ const handleExitPlanMode = async ({ cfg, log, client, body, getMirrorTarget, flu
         catch (e) {
             log.warn({ err: e.message }, "plan flushBeforeCard failed; sending card anyway");
         }
-        try {
-            await client.sendMessage(target, {
-                msgtype: "markdown",
-                markdown: { content: withTagHeader(approver, buildPlanMarkdown(plan)) },
-            });
-        }
-        catch (e) {
-            log.warn({ err: e.message }, "plan markdown prelude send failed");
+        if (plan) {
+            try {
+                await client.sendMessage(target, {
+                    msgtype: "markdown",
+                    markdown: { content: withTagHeader(approver, buildPlanMarkdown(plan)) },
+                });
+            }
+            catch (e) {
+                log.warn({ err: e.message }, "plan markdown prelude send failed");
+            }
         }
         await client.sendMessage(target, {
             msgtype: "template_card",
-            template_card: buildPlanCard(reqId, body.session_id, body.cwd ?? "", body.transcript_tail ?? "", approver),
+            template_card: buildPlanCard(reqId, body.session_id, body.cwd ?? "", body.transcript_tail ?? "", approver, true),
         });
         log.info({ reqId, approver }, "plan card sent");
     }
@@ -648,7 +702,39 @@ const freshSlot = (sessionId) => {
     return s;
 };
 export const hasMirrorAskq = (sessionId) => freshSlot(sessionId) !== undefined;
-export const runMirrorAskqFlow = async ({ log, client, sessionId, chatKey, toolInput, voteTimeoutMs, inject }) => {
+export const buildAskqDriveActions = (questions, picks) => {
+    const maxOpts = questions.reduce((m, q) => Math.max(m, q.options.length), 0);
+    const acts = [{ kind: "keys", keys: Array(maxOpts + 3).fill("Up") }];
+    questions.forEach((q, i) => {
+        const N = q.options.length;
+        const picked = (picks[i] ?? []).filter((n) => Number.isInteger(n) && n >= 0 && n < N).sort((a, b) => a - b);
+        if (!q.multiSelect) {
+            const n = picked[0] ?? 0;
+            acts.push({ kind: "keys", keys: [...Array(n).fill("Down"), "Enter"] });
+            return;
+        }
+        const keys = [];
+        let cur = 0;
+        for (const n of picked) {
+            keys.push(...Array(n - cur).fill("Down"), "Enter");
+            cur = n;
+        }
+        // 多选的前进行在第 N+1 位 (0..N-1 选项, N 自定义行, N+1 下一题行)。
+        keys.push(...Array(N + 1 - cur).fill("Down"), "Enter");
+        acts.push({ kind: "keys", keys });
+    });
+    // 提交页光标初始 0 = "1. Submit answers"。
+    acts.push({ kind: "keys", keys: ["Enter"] });
+    return acts;
+};
+// 「聊聊这个」: 光标钳 0 后落到第 N 行 (自定义文本行), 贴入引导语提交 — 自由文本
+// 答案本身即语义完整 (hook 若触发, deny+reason 会再覆盖成同款文案)。
+export const buildAskqChatDriveActions = (q) => [
+    { kind: "keys", keys: [...Array(q.options.length + 3).fill("Up"), ...Array(q.options.length).fill("Down")] },
+    { kind: "text", text: "先不回答，我想和你讨论一下这个问题" },
+    { kind: "keys", keys: ["Enter"] },
+];
+export const runMirrorAskqFlow = async ({ log, client, sessionId, chatKey, toolInput, voteTimeoutMs, drive }) => {
     const questions = parseAskqInput(toolInput);
     if (!questions || questions.length === 0)
         return;
@@ -659,6 +745,7 @@ export const runMirrorAskqFlow = async ({ log, client, sessionId, chatKey, toolI
     const target = targetChatId(chatKey);
     const total = questions.length;
     const answers = [];
+    const picks = [];
     const flowStart = Date.now();
     const note = async (content) => {
         try {
@@ -722,7 +809,7 @@ export const runMirrorAskqFlow = async ({ log, client, sessionId, chatKey, toolI
             await note("⌛ 问题卡已超时，请在 CLI 中作答。");
             return;
         }
-        // 本地先答, hook 侧作废了这张卡 — 中止整流, 不注入不覆盖。
+        // 本地先答, hook 侧作废了这张卡 — 中止整流, 不驱动不覆盖。
         if (raw === "moot") {
             log.info({ reqId, sessionId }, "mirror askq mooted by local answer");
             mirrorAskqSlots.delete(sessionId);
@@ -739,34 +826,166 @@ export const runMirrorAskqFlow = async ({ log, client, sessionId, chatKey, toolI
                 reason: `Instead of answering "${q.header || q.question}", the user wants to chat about it first. Discuss the question with them before re-asking.`,
                 at: Date.now(),
             });
-            const r = await inject("先不回答，我想和你讨论一下这个问题");
+            const r = await drive(buildAskqChatDriveActions(q));
             if (!r.ok) {
-                log.warn({ sessionId, reason: r.reason }, "mirror askq chat inject failed");
-                await note("⚠️ 已记录，但注入 CLI 面板失败，请回到 CLI 手动处理。");
+                log.warn({ sessionId, reason: r.reason }, "mirror askq chat drive failed");
+                await note("⚠️ 已记录，但驱动 CLI 面板失败，请回到 CLI 手动处理。");
+            }
+            else {
+                mirrorAskqSlots.delete(sessionId);
             }
             return;
         }
         answers.push(`"${q.header || q.question}": ${ans.labels}`);
+        // 按键驱动要的是选项下标, raw 编码 picked:i,j 里直接取 (与 interpret 同源)。
+        picks.push(raw.slice(ASKQ_PICKED_PREFIX.length)
+            .split(",")
+            .map((s) => parseInt(s, 10))
+            .filter((n) => Number.isInteger(n) && n >= 0 && n < q.options.length));
     }
     const reason = total === 1
         ? `User answered ${answers[0]} via WeCom`
         : `User answered ${total} questions via WeCom — ${answers.join("; ")}`;
     mirrorAskqSlots.set(sessionId, { reason, at: Date.now() });
-    // 触发文本只是面板提交的载体 — hook 到达后 deny+reason 会覆盖它。万一 hook
-    // 不触发, 它本身也是一段有意义的自由文本答案 (降级通道)。
-    const trigger = total === 1 ? (answers[0] ?? "已在企业微信作答") : answers.join("; ");
-    const r = await inject(trigger);
+    // 驱动前再确认槽还是自己的: 用户若在收票期间本地答了 (hook 到达会清槽),
+    // 面板已经消失, 按键会落进主输入框 (Down 翻历史 / Enter 误提交) — 必须放弃。
+    if (freshSlot(sessionId)?.reason !== reason) {
+        log.info({ sessionId }, "mirror askq slot lost before drive — local answer won");
+        return;
+    }
+    const acts = buildAskqDriveActions(questions, picks);
+    log.info({ sessionId, acts: acts.length, picks }, "mirror askq drive start");
+    const r = await drive(acts);
     if (!r.ok) {
-        log.warn({ sessionId, reason: r.reason }, "mirror askq inject failed");
-        await note("⚠️ 答案已记录，但注入 CLI 面板失败，请回到 CLI 手动处理。");
+        // 驱动失败: 保留 reason 槽 — 用户手动提交面板时 hook 到达仍以记录答案覆盖。
+        log.warn({ sessionId, reason: r.reason }, "mirror askq drive failed");
+        await note("⚠️ 答案已记录，但驱动 CLI 面板失败，请回到 CLI 手动处理。");
         return;
     }
+    log.info({ sessionId }, "mirror askq drive done");
+    // 驱动成功 = 面板已按 WeCom 答案提交, 结果随工具自然落地。清槽放掉后续提问;
+    // hook 若迟到, 无槽 → allow → 本地 (即我们驱动的) 答案原样生效, 语义一致。
+    mirrorAskqSlots.delete(sessionId);
     // 回执同 hook 流: 答完后 model 进入不可见长 thinking, 先确认答案已落地。
     await note(total === 1 ? "✅ 已回传，Claude 处理中…" : `✅ ${total} 题已回传，Claude 处理中…`);
 };
+const mirrorPlanSlots = new Map();
+const MIRROR_PLAN_SLOT_TTL_MS = 12 * 3600_000; // 与 approval.longPollSec 对齐
+const freshPlanSlot = (sessionId) => {
+    const s = mirrorPlanSlots.get(sessionId);
+    if (!s)
+        return undefined;
+    if (Date.now() - s.at > MIRROR_PLAN_SLOT_TTL_MS) {
+        mirrorPlanSlots.delete(sessionId);
+        return undefined;
+    }
+    return s;
+};
+export const hasMirrorPlan = (sessionId) => freshPlanSlot(sessionId) !== undefined;
+export const mootMirrorPlan = (sessionId) => {
+    const s = freshPlanSlot(sessionId);
+    if (!s)
+        return;
+    if (s.reqId)
+        resolvePending(s.reqId, "moot");
+    mirrorPlanSlots.delete(sessionId);
+};
+export const runMirrorPlanFlow = async ({ log, client, sessionId, chatKey, cwd, jsonlPath, voteTimeoutMs, sendKey }) => {
+    if (!client.isConnected)
+        return;
+    const target = targetChatId(chatKey);
+    const note = async (content) => {
+        try {
+            await client.sendMessage(target, { msgtype: "markdown", markdown: { content: withTagHeader(chatKey, content) } });
+        }
+        catch { /* best-effort */ }
+    };
+    const plan = resolvePlanText(undefined, jsonlPath);
+    if (!plan)
+        log.warn({ sessionId }, "mirror plan: plan text not found — card without prelude");
+    const { reqId, promise } = createPending({
+        meta: {
+            kind: "generic",
+            createdAt: Date.now(),
+            toolName: "ExitPlanMode",
+            toolInput: {},
+            cwd,
+            sessionId,
+            chatKey,
+            transcriptTail: "",
+        },
+        timeoutMs: voteTimeoutMs,
+    });
+    mirrorPlanSlots.set(sessionId, { reqId, at: Date.now() });
+    try {
+        if (plan) {
+            try {
+                await client.sendMessage(target, {
+                    msgtype: "markdown",
+                    markdown: { content: withTagHeader(chatKey, buildPlanMarkdown(plan)) },
+                });
+            }
+            catch (e) {
+                log.warn({ err: e.message }, "mirror plan markdown prelude send failed");
+            }
+        }
+        await client.sendMessage(target, {
+            msgtype: "template_card",
+            template_card: buildPlanCard(reqId, sessionId, cwd, "", chatKey, Boolean(plan)),
+        });
+        log.info({ reqId, chatKey }, "mirror plan card sent");
+    }
+    catch (e) {
+        log.error({ err: e.message }, "mirror plan send failed");
+        resolvePending(reqId, "deny");
+        mirrorPlanSlots.delete(sessionId);
+        return;
+    }
+    let raw;
+    try {
+        raw = (await promise);
+    }
+    catch {
+        mirrorPlanSlots.delete(sessionId);
+        await note("⌛ 计划卡已超时，请在 CLI 中处理。");
+        return;
+    }
+    // 本地先答 (function_call_result 落盘触发的 moot)。
+    if (raw === "moot") {
+        log.info({ reqId, sessionId }, "mirror plan mooted by local answer");
+        mirrorPlanSlots.delete(sessionId);
+        return;
+    }
+    const approve = raw === `${PLAN_PICKED_PREFIX}approve`;
+    const r = await sendKey(approve ? "Enter" : "Escape");
+    mirrorPlanSlots.delete(sessionId);
+    if (!r.ok) {
+        log.warn({ sessionId, reason: r.reason }, "mirror plan sendKey failed");
+        await note("⚠️ 已记录选择，但本地对话框按键注入失败，请回到 CLI 手动处理。");
+        return;
+    }
+    log.info({ reqId, sessionId, approve }, "mirror plan resolved via send-keys");
+    await note(approve ? "✅ 已同意，退出 plan mode 开始执行…" : "✏️ 已选择继续完善计划。");
+};
 // 多问题: 逐题顺序发卡 → 收答 → 下一题。任一题选「CLI」整体转 CLI,选「聊聊」
 // 整体转讨论; 全部答完合并成单个 deny+reason 注入。卡不会一次性轰炸 N 张。
 const handleAskUserQuestion = async ({ cfg, log, client, body, getMirrorTarget, flushBeforeCard, clientGone }) => {
+    // ── codebuddy 镜像流去重 ────────────────────────────────────────────────
+    // codebuddy 的 hook 只在本地面板被提交后到达。mirror 早已发过 vote 卡:
+    //   - 槽里有 reason = 面板是被我们的注入提交的 → 用记录的 reason 覆盖, 不再发卡。
+    //   - 无记录 = 用户在本地答的 → allow 让本地答案生效, 并作废挂着的 vote 卡。
+    const slot = freshSlot(body.session_id);
+    if (slot?.reason) {
+        mirrorAskqSlots.delete(body.session_id);
+        log.info({ sessionId: body.session_id }, "askq hook: overriding with mirror-collected answer");
+        return { decision: "deny", reason: slot.reason };
+    }
+    if (body.cli_backend === "codebuddy") {
+        if (slot?.reqId)
+            resolvePending(slot.reqId, "moot");
+        mirrorAskqSlots.delete(body.session_id);
+        return { decision: "allow", reason: "codebuddy_local_panel" };
+    }
     const questions = parseAskqInput(body.tool_input);
     if (!questions || questions.length === 0)
         return { decision: "ask", reason: "askq_unparsable" };
@@ -957,6 +1176,11 @@ export const makeApproveHandler = ({ cfg, log, client, getMirrorTarget, flushBef
                 template_card: card,
             });
             log.info({ batchId: batch.batchId, count: batch.members.length, multi: isMulti, approver: batch.approver, tool: batch.toolName }, "batch flushed");
+            // 只给单卡打「可续接」标: 批量卡的点击要靠内存里的 batchById 才能一次
+            // resolve N 个成员, 那张表撑不过重启 —— 续接了反而会让成员干等一张点了
+            // 没反应的卡。批量成员维持原行为 (drain → fallbackOnError)。
+            if (!isMulti)
+                markCardSent(batch.members[0].reqId);
         }
         catch (e) {
             log.error({ batchId: batch.batchId, err: e.message }, "batch send failed");
@@ -1022,6 +1246,7 @@ export const makeApproveHandler = ({ cfg, log, client, getMirrorTarget, flushBef
                     tool_input: toolInput,
                     cwd,
                     transcript_tail: transcriptTail,
+                    cli_backend: body.cli_backend,
                 },
             });
             json(res, 200, resp);
@@ -1041,6 +1266,8 @@ export const makeApproveHandler = ({ cfg, log, client, getMirrorTarget, flushBef
                     tool_input: toolInput,
                     cwd,
                     transcript_tail: transcriptTail,
+                    cli_backend: body.cli_backend,
+                    transcript_path: body.transcript_path,
                 },
             });
             json(res, 200, resp);
@@ -1054,6 +1281,11 @@ export const makeApproveHandler = ({ cfg, log, client, getMirrorTarget, flushBef
         const danger = dangerOf(cfg, toolName, toolInput);
         if (danger)
             log.info({ toolName, sessionId, rule: danger.rule }, "danger hit — forcing single approval");
+        // danger 模式: 名单之外的调用不打扰人, 直接放行 (卡只留给真正危险的操作)。
+        if (dangerModeSkips(cfg, danger)) {
+            json(res, 200, { decision: "allow", reason: "danger_mode_skip" });
+            return;
+        }
         // Auto-approve window: while active for THIS chat, requests short-circuit to allow.
         if (!danger && approver && isAutoWindowActive(approver)) {
             const remainSec = Math.ceil(autoWindowRemainingMs(approver) / 1000);
@@ -1096,6 +1328,9 @@ export const makeApproveHandler = ({ cfg, log, client, getMirrorTarget, flushBef
             }
         })();
         const longPollMs = cfg.approval.longPollSec * 1000;
+        // Reload 续接: hook 带着上一轮的 req_id 回来, 复用同一个 id 重新挂起 ——
+        // WeCom 上那张卡的按钮编的就是它, 于是旧卡的点击照样能 resolve 这次长轮询。
+        const resumeId = (body.resume_req_id ?? "").trim();
         const { reqId, promise } = createPending({
             meta: {
                 kind: "approval",
@@ -1107,8 +1342,10 @@ export const makeApproveHandler = ({ cfg, log, client, getMirrorTarget, flushBef
                 chatKey: approver,
                 transcriptTail,
                 danger: danger?.rule,
+                cardSent: Boolean(resumeId), // 续接的前提就是卡已经在群里
             },
             timeoutMs: longPollMs,
+            reqId: resumeId || undefined,
         });
         recordApproval({
             id: reqId,
@@ -1121,11 +1358,15 @@ export const makeApproveHandler = ({ cfg, log, client, getMirrorTarget, flushBef
         // Batch coalesce: 同 session 同 tool 的并发请求合流为一张卡。窗口内首位
         // 创建 batch + 计时器, 后续到达者只追加成员, 不发卡。flush 时依据成员数
         // 选择普通 buildCard 或 buildBatchCard。0 = 关闭聚合, 立即 flush。
+        // 续接的请求不再进 batch: 卡已经在群里, 重发就是重复轰炸。
         const member = { reqId, toolInput: display, originalToolInput: toolInput, toolInputStr, cwd, transcriptTail };
         const bk = batchKeyOf(sessionId, toolName);
         // 危险请求既不 join 也不被 join — 一次危险操作 = 一张卡 = 一次点击。
         const existing = danger ? undefined : activeBatches.get(bk);
-        if (existing && !existing.flushed) {
+        if (resumeId) {
+            // no-op: 直接进下面的长轮询, 等旧卡上的点击。
+        }
+        else if (existing && !existing.flushed) {
             existing.members.push(member);
             log.info({ batchId: existing.batchId, count: existing.members.length, reqId }, "batch joined");
         }
@@ -1156,6 +1397,13 @@ export const makeApproveHandler = ({ cfg, log, client, getMirrorTarget, flushBef
             decision = await promise;
         }
         catch (e) {
+            // Reload drain: 卡还挂在 WeCom 上, 让 hook 带着同一个 reqId 等 daemon 回来
+            // 重新长轮询 —— 而不是 fallback 成 ask 把权限框弹回本地 CLI。
+            if (isReloadError(e)) {
+                log.info({ reqId, toolName, sessionId }, "approval parked for reload — telling hook to resume");
+                json(res, 200, { decision: "retry", reason: "daemon_reloading", req_id: reqId });
+                return;
+            }
             log.warn({ err: e.message, reqId }, "approval timed out");
             json(res, 200, fallback(cfg, "approver_timeout", danger));
             return;
@@ -1254,6 +1502,9 @@ export const installApprovalEventListener = (client, log, cfg, onApproved) => {
                     ? "chat"
                     : `${ASKQ_PICKED_PREFIX}${numericIdxs.join(",")}`;
             const ok = resolvePending(askq.reqId, resolved);
+            // 留 resolved 快照: 重复点击已决卡时据此跳过"已失效"重绘 (卡已是终态)。
+            if (ok && meta)
+                stashResolved(askq.reqId, meta, resolved);
             log.info({ reqId: askq.reqId, outcome, ok }, "askq event resolved");
             if (q) {
                 try {
@@ -1263,6 +1514,23 @@ export const installApprovalEventListener = (client, log, cfg, onApproved) => {
                     log.warn({ err: e.message, reqId: askq.reqId }, "askq updateTemplateCard failed");
                 }
             }
+            else if (!ok && !getResolvedSnapshot(askq.reqId)) {
+                // 死卡点击 (超时 / 本地先答已作废 / daemon 重启丢 pending): 给终态反馈,
+                // 别让用户对着无反应的卡干瞪眼。有 resolved 快照 = 已决卡的重复点击,
+                // 卡片已是终态, 不重绘。
+                try {
+                    await client.updateTemplateCard(frame, {
+                        card_type: "button_interaction",
+                        main_title: { title: "🤔 问题卡已失效" },
+                        sub_title_text: "该卡已超时或已在别处处理，请以最新上下文为准。",
+                        task_id: cbTaskId || askq.reqId,
+                        button_list: [{ text: "⌛ 已失效", style: 4, key: encodeAskqNoopKey(askq.reqId) }],
+                    });
+                }
+                catch (e) {
+                    log.warn({ err: e.message, reqId: askq.reqId }, "askq stale-card update failed");
+                }
+            }
             return;
         }
         // ── ExitPlanMode 计划审批卡: 在普通 approval 解码前匹配 PLAN| 前缀。