wezard 1.2.18 → 1.2.21

package/README.md

@@ -194,6 +194,44 @@ tagged session 的每条回复自带 `emoji #tag` 前缀（emoji 由 tag 名 has
 
 ---
 
+## 跨聊天：给聊天命名
+
+一个 WeCom 聊天的身份是 `chat:wrkS…` 这种既读不出也打不进去的 id。所以在给聊天起名之前，跨聊天叫人只有一条路：**赌 tag 全局唯一**——两个群各有一个 `#fix`，就谁也叫不动谁，唯一的出路是回去改别人的 tag。
+
+起个名字，这个聊天就有了能写进消息、也能传给工具的地址。
+
+```
+/name daily        给本聊天起名为 daily
+/name              查看当前名字
+/name -            取消命名
+/chats             列出所有已知聊天、各自跑着哪些会话
+```
+
+**名字规则**：1–32 个字符，字母 / 数字 / `_` / `-`（不能有空格、`#`、`/`、`:`）。全机唯一、大小写不敏感，重名会被拒；改名即覆盖，一个聊天只留一个名字。名字写在 `~/.wezard/config.jsonc` 的 `chats` 里，手改也行。
+
+**地址空间**随之变成两级，老写法一字不改：
+
+| 写法 | 指向 |
+|---|---|
+| `fix` | 本聊天的 `#fix`；本聊天没有，才回退去找全机唯一的 `#fix` |
+| `daily#fix` | daily 这个聊天的 `#fix`——不问 tag 全不全局唯一 |
+| `daily#` | daily 的默认（无 tag）会话 |
+| `chat:wr…#fix` | 全量 key，`/chats`、`list_peers` 吐出来的原样也能用 |
+
+起完名之后，在**别的群**里直接说人话即可：
+
+```
+让 daily#fix 看一眼这个报错          → AI 调 send_peer("daily#fix", …)
+在 daily 里开个 #ingest 跑 ~/repo    → AI 调 new_claude_session({ chat: "daily", tag: "ingest", cwd })
+别的群还有谁在跑                      → AI 调 list_chats
+```
+
+最后一块是**跨群建会话**：`new_claude_session` 的 `chat` 参数可以直接在另一个已命名的聊天里拉起 peer，「目标 peer 还不存在」不再需要找个人去那个群手打 `/new`。跨群的每一次 `send_peer`，两边聊天都会收到 relay 气泡——被叫的那侧不会莫名其妙冒出一句话。
+
+> **未命名的聊天既不可寻址、也不可被建入**，这是刻意的：往一个谁也读不出的 `chat:wr…` id 里塞会话，等于把它扔进一个调用方根本不该进的群。想让某个群能被叫到，就在那个群里发一次 `/name`。
+
+---
+
 ## 多 CLI 后端（`claude` / `claude-internal` / `codebuddy`）
 
 daemon 同时挂载所有已安装的 CLI，不是二选一：你可以一个 tmux 窗口跑 `claude`、另一个跑 `codebuddy`，各自绑不同的 IM 聊天。**会话身份就是它的 jsonl 路径**，daemon 由路径反推是哪个 CLI 写的，`--resume` 用哪个二进制、jsonl 用哪套 schema 解析、project-dir 怎么编码，全部由此派生。
@@ -256,6 +294,8 @@ IM 里发 `/help` 可随时拉出完整命令表；每次 `/new`、`/clear` 之
 /new · /clear · /stop · /n          会话控制
 /sessions [emoji|id]                 列出 / 切换 live 会话
 /new <cli> [#tag]                    切换 CLI 后端 / 开并行会话
+/peers                               本聊天的会话及忙闲状态
+/name [名字|-] · /chats              给本聊天起名 / 跨聊天目录
 /id · /pwd · /usage · /cost · /audit  信息查询（免授权）
 /help                                全部命令
 ```

package/dist/daemon/approval.js

@@ -235,16 +235,18 @@ const bodyBlocks = (a, r) => {
 const quoteArea = (text, url) => (url
     ? { type: 1, url, quote_text: text }
     : { type: 0, quote_text: text });
-// 危险卡: 只有 ❌ / ✅ — 不给「N 分钟全过」「✅总是」的入口, 否则一次点击就把
-// 后续所有危险操作也放行了, 名单等于失效。
-const approveButtons = (a) => a.danger
+// 必发卡 (危险名单 / askRules / `.claude/**` 守卫): 只有 ❌ / ✅ — 不给「N 分钟
+// 全过」「✅总是」的入口, 否则一次点击就把后续所有这类操作也放行了, 名单等于失效。
+// 判据是 forceSingle 而非 danger: 另两个来源的卡同样吃 handler 侧的 `!mustCard`
+// 短路, 只按 danger 收按钮的话它们会画出点了没反应、也不 sweep 同批的死按钮。
+const approveButtons = (a) => a.danger || a.forceSingle
     ? [
         { text: "❌", style: 4, key: encodeKey(a.reqId, "deny") },
         { text: "✅ 确认执行", style: 4, key: encodeKey(a.reqId, "allow") },
     ]
     : [
         { text: "❌", style: 4, key: encodeKey(a.reqId, "deny") },
-        { text: windowLabel(a.windowMinutes), style: 1, key: encodeKey(a.reqId, "allow_window") },
+        { text: windowLabel(a.windowMinutes), style: 4, key: encodeKey(a.reqId, "allow_window") },
         // 「总是」= 由本次调用生成一条 allowRules 并落盘, 对齐 Claude Code 原生
         // 弹窗的 Always allow。危险卡上没有这个入口 (与「⏱全过」同理)。
         { text: "✅总是", style: 4, key: encodeKey(a.reqId, "allow_always") },
@@ -288,7 +290,8 @@ const buildCard = (a) => {
 };
 const fmtWindow = (min) => min % 60 === 0 ? `${min / 60}h` : `${min}min`;
 // 按钮上的时间窗文案: 裸「10h」看不出是放行, 补 ⏱ + 「自动过」点明语义。
-// (style 也从 3 改成 1 — 企微 3 渲染成红色, 与「放行」相悖。)
+// (style 跟 ❌/✅总是/✅ 一律 4 —— 3 渲染成红色, 1 渲染成蓝色, 都让这颗按钮
+//  在一排里显得像另一类操作; 它和其余三颗是同级选项, 不该被强调。)
 const windowLabel = (min) => `⏱${fmtWindow(min)}自动过`;
 const verbOf = (d, windowMinutes) => {
     switch (d) {
@@ -416,7 +419,7 @@ const buildBatchCard = (batch, transcriptTail) => ({
     task_id: batch.batchId,
     button_list: [
         { text: "❌", style: 4, key: encodeBatchKey(batch.batchId, "deny") },
-        { text: windowLabel(batch.windowMinutes), style: 1, key: encodeBatchKey(batch.batchId, "allow_window") },
+        { text: windowLabel(batch.windowMinutes), style: 4, key: encodeBatchKey(batch.batchId, "allow_window") },
         // 批量卡同样给「总是」: 合流的成员是同一个工具的 N 次调用, 逐个点「总是」与
         // 点一次的结果相同(每位成员各自走一遍规则生成, 已被现有规则覆盖的不重复加)。
         { text: "✅总是", style: 4, key: encodeBatchKey(batch.batchId, "allow_always") },
@@ -553,7 +556,7 @@ export const buildAskqCard = (reqId, q, transcriptTail, approver) => {
     const tail = oneLine(transcriptTail).trim();
     return {
         card_type: "vote_interaction",
-        source: buildSource(tail),
+        source: buildSource(undefined, tail),
         main_title: { title: TRUNC(`🤔 ${emojiFor(approver)}${q.header || "请选择"}`, ASKQ_TITLE_MAX) },
         task_id: reqId,
         checkbox: {
@@ -586,7 +589,7 @@ const buildAskqResolvedCard = (reqId, q, outcome, transcriptTail, approver) => {
     const tail = oneLine(transcriptTail).trim();
     return {
         card_type: "button_interaction",
-        source: buildSource(tail),
+        source: buildSource(undefined, tail),
         main_title: { title: TRUNC(`🤔 ${emojiFor(approver)}${q.header || "已回答"}`, ASKQ_TITLE_MAX) },
         sub_title_text: TRUNC(q.question, ASKQ_SUB_MAX),
         task_id: reqId,
@@ -686,7 +689,7 @@ const buildPlanCard = (reqId, _sessionId, cwd, transcriptTail, approver, hasPlan
     const dir = dirName(cwd);
     return {
         card_type: "button_interaction",
-        source: buildSource(tail),
+        source: buildSource(undefined, tail),
         main_title: { title: TRUNC(`📋 计划审批 · ${tag}${dir}/`, PLAN_TITLE_MAX + 12) },
         sub_title_text: hasPlan
             ? "审阅上方计划后选择:同意开始执行,或让 Claude 继续完善。"
@@ -704,7 +707,7 @@ const buildPlanResolvedCard = (reqId, action, cwd, transcriptTail, approver) =>
     const summary = action === "approve" ? "✅ 已同意 · 开始执行" : "✏️ 继续完善计划";
     return {
         card_type: "button_interaction",
-        source: buildSource(tail),
+        source: buildSource(undefined, tail),
         main_title: { title: TRUNC(`📋 计划 · ${emojiFor(approver)}${dir}/`, PLAN_TITLE_MAX + 12) },
         task_id: reqId,
         button_list: [{ text: summary, style: 4, key: encodePlanNoopKey(reqId) }],
@@ -1238,9 +1241,14 @@ const handleAskUserQuestion = async ({ cfg, log, client, body, getMirrorTarget,
     return { decision: "deny", reason };
 };
 const decisionToHook = (d) => (d === "deny" ? "deny" : "allow");
-// 必发卡的请求 (危险名单 / askRules / `.claude/**` 守卫) 永不走 fallbackOnError:
-// "allow" — 超时/断线时降级为 ask, 交回本地 CLI 由人来确认, 而不是静默放行一次
-// rm。只判 danger 的话, 用户自己配的 askRules 在 daemon 挂掉时反而失效。
+// 必发卡的请求 (危险名单 / askRules) 永不走 fallbackOnError: "allow" — 超时/断线时
+// 降级为 ask, 交回本地 CLI 由人来确认, 而不是静默放行一次 rm。只判 danger 的话,
+// 用户自己配的 askRules 在 daemon 挂掉时反而失效。
+//
+// `.claude/**` 守卫虽然不进 mustCard, 但在**错误面**也要走同一条降级: 正常出口靠
+// settleGuard 事后按框, 而这三条 (no_approver / ws_disconnected / approver_timeout)
+// 要么没有 approver 可按、要么 pane 早已在等框 —— 静默 allow 就是把死锁原样放回来。
+// 所以调用点传的是 `mustCard || guardActive`, 见 handler 里那三处。
 const fallback = (cfg, reason, forceSingle) => ({
     decision: forceSingle && cfg.approval.fallbackOnError === "allow" ? "ask" : cfg.approval.fallbackOnError,
     reason: forceSingle ? `${reason}:force_single` : reason,
@@ -1297,7 +1305,7 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
     // 按不掉时不干等: Esc 取消掉这次调用, 再把原因作为一条用户消息注入 pane。模型
     // 收到的就是明确的"这条路走不通 + 该怎么绕", 而不是静默卡住 —— 等价于预拦截
     // deny + reason, 只是走镜像通道传达。
-    const settleClaudeConfigModal = async (sessionId, approver, hit) => {
+    const settleOne = async (sessionId, approver, hit) => {
         const nm = nativeModal;
         if (!nm)
             return;
@@ -1326,6 +1334,22 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
         await notify(approver, `⚠️ 原生确认框未能代按（${r.status}）。已${cancelled.ok ? "" : "尝试"}发 Esc 取消本次调用`
             + `${told.ok ? "，并把原因告知了会话" : `（原因注入失败：${told.reason ?? "unknown"}，请到 tmux 里看一眼）`}。`);
     };
+    // 同一 pane 上的收尾必须串行。守卫退出 mustCard 之后, 一轮里 N 个 `.claude/**` 写
+    // 会一起走窗口/缓存/规则的快路径、同刻返回 —— 以前每张卡等人点, 天然串成一列。
+    // 并发进 answer() 的话两个协程会看见同一个框都按下去, 第二下落到下一个框或输入框上。
+    // 按 sessionId 串一条 promise 链: 每次收尾等前一次跑完, 失败也不断链。
+    const settleChains = new Map();
+    const settleClaudeConfigModal = (sessionId, approver, hit) => {
+        const next = (settleChains.get(sessionId) ?? Promise.resolve())
+            .then(() => settleOne(sessionId, approver, hit));
+        // 链尾自清: 只有还是自己时才删, 避免把后来者的链一起抹掉。
+        const tail = next.catch(() => { }).finally(() => {
+            if (settleChains.get(sessionId) === tail)
+                settleChains.delete(sessionId);
+        });
+        settleChains.set(sessionId, tail);
+        return next;
+    };
     // Flush 一个 batch: 单成员 → 普通卡 (与未启用聚合一致); 多成员 → 批量卡。
     // 发送失败时调用 failPending 让每位成员的 handler 走 fallbackOnError 路径,
     // 与单卡路径上 sendMessage 抛错时的语义一致。
@@ -1354,6 +1378,7 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
                     transcriptTail: m.transcriptTail,
                     windowMinutes: batch.windowMinutes,
                     danger: batch.danger,
+                    forceSingle: batch.forceSingle,
                     sessionName: batch.sessionName,
                     denyReason: batch.denyReason,
                     detailUrl: detailUrlFor(m.reqId, batch.approver),
@@ -1446,8 +1471,24 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
         const guardHit = cfg.approval.claudeConfigGuard ? claudeConfigWrite(toolName, toolInput) : undefined;
         const guardActive = Boolean(guardHit && nativeModal?.hasPane(sessionId));
         if (guardHit) {
-            log.info({ toolName, sessionId, path: guardHit.path, why: guardHit.why, guardActive }, guardActive ? "claude-config guard force card" : "claude-config write detected (no live pane, passing through)");
+            log.info({ toolName, sessionId, path: guardHit.path, why: guardHit.why, guardActive }, guardActive ? "claude-config guard armed" : "claude-config write detected (no live pane, passing through)");
         }
+        const approver = resolveApprover(cfg, sessionId, getMirrorTarget);
+        // 守卫的收尾 = 把 CC 那个不过 hook 的原生确认框按掉。它挂在**每一条 allow 出口**
+        // 上, 而不是靠"强制发卡 + 人工点"来触发 —— 死锁的成因是没人按框, 不是没人点卡。
+        //
+        // 这条区别是有代价的历史: 守卫曾经进 mustCard, 于是 ⏱窗口/缓存/合流/sweep 全被
+        // 它短路, 卡上那颗「⏱10h自动过」点了等于一次性放行, 窗口从来没开过。现在窗口
+        // 照常生效, 框照样有人按。
+        //
+        // 必须在 json(res) 之后调用: CC 要等 hook 进程退出才会把框渲染出来。
+        const settleGuard = () => {
+            if (!guardActive || !guardHit || !approver)
+                return;
+            void settleClaudeConfigModal(sessionId, approver, guardHit).catch((e) => {
+                log.warn({ err: e.message, sessionId }, "settleClaudeConfigModal failed");
+            });
+        };
         // 危险名单 (daemon/danger.ts): 内置的 rm / 强推 / DROP / 敏感路径等。语义上
         // 是「出厂自带的 askRules」—— 所以它必须和用户写的 askRules 站在同一层, 排在
         // allowRules 之前。放在后面的话, 一条 `Bash(git *)` 这样的宽 allow 规则 (尤其
@@ -1455,8 +1496,9 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
         const danger = dangerOf(cfg, toolName, toolInput);
         if (danger)
             log.info({ toolName, sessionId, rule: danger.rule }, "danger hit — forcing single approval");
-        // 必发卡 = 危险名单 或 askRules 命中 或 守卫生效。三者都要压过放行/窗口/缓存。
-        const mustCard = Boolean(danger) || Boolean(askHit) || guardActive;
+        // 必发卡 = 危险名单 或 askRules 命中。这两者的语义是「每次都要人单独看一眼」,
+        // 所以压过放行/窗口/缓存。守卫不在其列 —— 见上面 settleGuard 的注释。
+        const mustCard = Boolean(danger) || Boolean(askHit);
         // allowRules: matcher 拦下的工具里再挖细粒度豁免 (Bash 可按命令前缀区分)。
         // 交互卡工具 (AskUserQuestion 等) 在引擎内部硬保护, 规则写了也不放行。
         // 用 evaluateAllow 而非 ruleAllows: 未命中时要把"因为哪一段"带到卡上,
@@ -1466,6 +1508,7 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
             const ruleHit = [...new Set(verdict.hits)].join(" + ");
             log.info({ toolName, sessionId, rule: ruleHit }, "allow-rule skip");
             json(res, 200, { decision: "allow", reason: `allow_rule:${ruleHit}` });
+            settleGuard();
             return;
         }
         const denyReason = verdict.allowed ? undefined : verdict.reason;
@@ -1529,21 +1572,18 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
             json(res, 200, resp);
             return;
         }
-        // Approver 提前解析: auto-window 现在按 chat 维度生效, isAutoWindowActive
-        // 检查要拿到 chatKey (= approver principal) 才能查。approver 缺失时 window
-        // 检查跳过 (window 需要一个 chat 才存在), 走后面的 no_approver fallback。
-        const approver = resolveApprover(cfg, sessionId, getMirrorTarget);
         // danger.skip / danger 模式的早退。第三个参数是「除 danger 外还有没有别的必发卡
-        // 理由」—— askRules 与 `.claude/**` 守卫不能被 danger 的开关顺带关掉, 判定与
-        // 理由见 dangerEarlyExit 的注释 (守卫被绕过会让 pane 死锁)。
-        const earlyExit = dangerEarlyExit(cfg, danger, Boolean(askHit) || guardActive);
+        // 理由」—— askRules 不能被 danger 的开关顺带关掉。守卫不在其列: 它要的是事后按框,
+        // 早退照样能给 (settleGuard), 拿它挡早退等于把 danger 的开关废掉。
+        const earlyExit = dangerEarlyExit(cfg, danger, Boolean(askHit));
         if (earlyExit) {
             log.info({ toolName, sessionId, reason: earlyExit }, "danger switch early exit");
             json(res, 200, { decision: "allow", reason: earlyExit });
+            settleGuard();
             return;
         }
         // Auto-approve window: while active for THIS chat, requests short-circuit to allow.
-        // mustCard (危险名单 / askRules / `.claude/**` 守卫) 的请求不吃窗口 — 即使开着 ⏱ 也逐条确认。
+        // mustCard (危险名单 / askRules) 的请求不吃窗口 — 即使开着 ⏱ 也逐条确认。
         if (!mustCard && approver && isAutoWindowActive(approver)) {
             const remainSec = Math.ceil(autoWindowRemainingMs(approver) / 1000);
             log.info({ toolName, sessionId, chatKey: approver, remainSec }, "auto-window allow");
@@ -1551,11 +1591,12 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
                 decision: "allow",
                 reason: `auto_window:${remainSec}s`,
             });
+            settleGuard();
             return;
         }
         // Session cache (mustCard 的请求同样不吃缓存)
         const ck = cacheKey(sessionId, toolName, toolInput);
-        // mustCard(危险名单 / askRules / 守卫)一律不吃缓存 —— 缓存的语义是「这个调用批过一次
+        // mustCard(危险名单 / askRules)一律不吃缓存 —— 缓存的语义是「这个调用批过一次
         // 就不再问」, 与「每次都要单独确认」直接冲突。
         const cached = mustCard ? undefined : cacheGet(ck);
         if (cached) {
@@ -1564,16 +1605,18 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
                 decision: decisionToHook(cached),
                 reason: `cached:${cached}`,
             });
+            if (decisionToHook(cached) === "allow")
+                settleGuard();
             return;
         }
         if (!approver) {
             log.warn("no approver configured");
-            json(res, 200, fallback(cfg, "no_approver", mustCard));
+            json(res, 200, fallback(cfg, "no_approver", mustCard || guardActive));
             return;
         }
         if (!client.isConnected) {
             log.warn("ws not connected");
-            json(res, 200, fallback(cfg, "ws_disconnected", mustCard));
+            json(res, 200, fallback(cfg, "ws_disconnected", mustCard || guardActive));
             return;
         }
         // Build pending + card
@@ -1644,6 +1687,7 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
                 approver,
                 windowMinutes: cfg.approval.windowMinutes,
                 danger: danger?.rule,
+                forceSingle: mustCard,
                 sessionName,
                 denyReason,
                 members: [member],
@@ -1673,7 +1717,7 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
                 return;
             }
             log.warn({ err: e.message, reqId }, "approval timed out");
-            json(res, 200, fallback(cfg, "approver_timeout", mustCard));
+            json(res, 200, fallback(cfg, "approver_timeout", mustCard || guardActive));
             return;
         }
         // 必发卡的决策一律不留痕: 不写 session cache、不开自动窗口 (卡上本就没这两个
@@ -1696,14 +1740,9 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
                 await notify(approver, `⚠️ 该操作命中危险名单「${danger.rule}」，不支持「总是」：这类操作每次都要单独确认。`
                     + `本次已放行。如确要长期免审，请在 config.jsonc 的 \`approval.danger.allowPatterns\` 里加豁免正则。`);
             }
-            // `.claude/**` 守卫生效的调用同理, 但理由更硬: 规则存了不只是"永远被压过"——
-            // 万一日后关掉守卫, 这条 allow 就会把静默死锁原样放回来(不发卡 + pane 阻塞)。
-            // 所以这里只做一次性放行, 并说清为什么「总是」在这个场景不成立。
-            if (!askHit && !danger && guardActive) {
-                await notify(approver, `⚠️ \`.claude/**\` 写操作不支持「总是」：这类改动会触发 CLI 原生确认框，`
-                    + `而那个框只有在你点过卡之后才能被代按 —— 免审就等于回到静默死锁。本次已放行。`);
-            }
-            const gen = askHit || danger || guardActive
+            // `.claude/**` 守卫命中的调用现在可以正常存规则: 守卫不再靠"强制发卡"兜底,
+            // settleGuard 挂在每条 allow 出口上 —— 规则放行的那一次同样会去按原生框。
+            const gen = askHit || danger
                 ? []
                 : alwaysAllowRulesFor(toolName, toolInput, cfg.approval.allowRules);
             const added = gen.filter((r) => !cfg.approval.allowRules.includes(r));
@@ -1721,7 +1760,7 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
                 log.info({ toolName, added, persisted: Boolean(sourcePath) }, "allow_always rules saved");
                 await notify(approver, `📌 已保存永久放行规则：${added.map((r) => `\`${r}\``).join("、")}`);
             }
-            else if (!askHit && !danger && !guardActive && gen.length === 0) {
+            else if (!askHit && !danger && gen.length === 0) {
                 // 提炼不出可靠字面规则 —— 本次一次性放行并告知。文案必须指对排查方向:
                 // 成因有四种, 笼统说"引号/结构有问题"会把用户带偏 (例如真凶是 fd 重定向
                 // 的 `&` 被当成后台执行符时, 用户会去查引号)。
@@ -1776,11 +1815,8 @@ export const makeApproveHandler = ({ cfg, log, client, sourcePath, getMirrorTarg
         // 放行 `.claude/**` 写操作后, CC 会在 hook 退出后立起自己的原生确认框 —— 必须
         // 等响应发出去才能去按 (框此刻还不存在)。fire-and-forget: 这条 HTTP 请求已经
         // 结束, 失败也只能靠告知, 不能再改判决。
-        if (guardActive && guardHit && decisionToHook(decision) === "allow") {
-            void settleClaudeConfigModal(sessionId, approver, guardHit).catch((e) => {
-                log.warn({ err: e.message, sessionId }, "settleClaudeConfigModal failed");
-            });
-        }
+        if (decisionToHook(decision) === "allow")
+            settleGuard();
     };
 };
 // ── Card click event → resolvePending + update card in place ────────────