dsh-rule-engine 0.5.10 → 0.5.11

package/lib/core/text-detect.js

@@ -5,15 +5,21 @@ import {
   PROMISE_WORDS,
   SOURCE_MARK,
   TIME_WORDS,
+  EVIDENCE_MARK_RE,
   URL_RE,
   TECH_TERM_RE,
   TERM_EXPLANATION_RE,
   SUGGEST_RE,
   isNegatingSuggestion,
-  isPromiseQuoteContext
+  isQuoteOrParaphraseContext
 } from "./patterns.js";
 import { detectOverengineeringText } from "./overengineering.js";
 
+// F2（2026-08-28 阶段三）：交付声明强模式（规则 23④ verify-gap 词面）——
+// 裸"完成"太宽（"完成社区检索/尚未完成/正在完成"误触）→ 强完成声明 + 否定/进行态排除。
+// 模块级导出（纯函数模块，可测试锁定）；LLM 裁决层（deliverSuspects）兜底不变。
+export const DELIVERY_RE = /(?:已完成|全部(?:[^\s，。；！？]{0,12})完成|已[^\s，。；！？]{0,8}完成|修复完成|落盘完成|验证[^\s，。；！？]{0,6}(?:通过|成功)|全部通过|全部[^\s，。；！？]{0,10}通过|已通过|已修复|搞定)(?:\s*了|!|！|，[^。]*)?(?![^。]*(?:尚未|没有|未|没|还没|未完|待做|待完成))/;
+
 /** 从 assistant message 内容中提取纯文本 */
 export function extractAssistantText(message) {
   if (!message) return "";
@@ -21,8 +27,7 @@ export function extractAssistantText(message) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
     return content
-      .map((b) => (b && typeof b === "object" && b.type === "text" ? b.text : ""))
-      .filter(Boolean)
+      .map((b) => (b && typeof b === "object" && b.type === "text" ? b.text : ""))      .filter(Boolean)
       .join("\n");
   }
   return "";
@@ -30,6 +35,9 @@ export function extractAssistantText(message) {
 
 const SELF_CERT_HINTS = {
   "14": { re: /总结|汇报|完成/, reason: "请按规则 14 一次性完整汇报，区分事实与推断" },
+  // "22" 词表（text-detect）：检测**我的回复文本**里的空话（B/D 级语义嫌疑），判定对象 = assistant 输出；
+  // 与 lexicon.js 的 ACTION/QUESTION/STATUS 等词表**不同层**（lexicon 判**用户消息**意图、服务规则 22 时序判定）。
+  // 二者用途不同、无重复：本表 = 输出侧"我说了空话"；lexicon = 输入侧"用户说了什么"。改动需两处各自成对。
   "22": { re: /我记下了|记住了|收到，我记下了|放心，我记住了/i, reason: "检测到「我记下了」类空话；正确动作是落盘执行并汇报" },
   "23": { re: /完成|交付/, reason: "交付/完成声明未附运行时验证证据" },
   "16": { re: /建议|优化|更优方案|推理档位|档位/, reason: "请按规则 16 用绑定检查格式提建议（或给档位建议并说明理由），避免频繁打断" },
@@ -67,8 +75,42 @@ export function isSelfCertified(text, ruleId) {
   return re.test(text);
 }
 
+/**
+ * 规则 2 时间核对的独立判定（F1，2026-08-28 阶段三）：
+ * 原实现嵌在 detectViolations（assistant/message 时调）——但 Get-Date 工具常在本回合后续步骤
+ * 才执行（事故实弹：correct 04:52:23.061 早于 Get-Date 放行 .068）→ 真调了也判"未先核对"。
+ * 修复：判定时机延迟到 turn/end（getDateSeen 已定案），本判定函数只做判定、不依赖调用时机。
+ * @param {object} session 会话状态（turn.getDateSeen 已由 tool/call 置位）
+ * @param {string} text assistant 纯文本
+ * @param {object} timeCfg 规则 2 配置（byId.get("2")）
+ * @returns {Array<{ruleId,title,kind,reason}>}
+ */
+export function detectTimeRule(session, text, timeCfg) {
+  if (!timeCfg || !TIME_WORDS.test(text) || isQuoteOrParaphraseContext(text, TIME_WORDS)) return [];
+  if (!session?.turn?.getDateSeen) {
+    return [{
+      ruleId: "2",
+      title: timeCfg.title,
+      kind: "correct",
+      reason: "回答出现具体时间词/日期，但本回合未先调用 Get-Date 核对"
+    }];
+  }
+  if (!EVIDENCE_MARK_RE.test(text)) {
+    return [{
+      ruleId: "2",
+      title: timeCfg.title,
+      kind: "correct",
+      reason: "回答含具体时间词但未附事件证据标注（日志 ts/文件 mtime/进程启动时间等）——Get-Date 当前时间不算过去事件证据（规则 2②）。正确动作：查该事件证据补（来源：…）或删时间词/标【时间未核实】，勿以当前时间替代"
+    }];
+  }
+  return [];
+}
+
 /**
  * 检测一次 assistant/message 的 B/D 级违规。
+ * 规则 2 时间核对不在本函数内（F1，2026-08-28）：原实现在此判定，但 Get-Date 工具常在本回合
+ * 后续步骤才执行（事故实弹：correct 早于 Get-Date 放行）→ 真调了也判"未先核对"。
+ * 现由 index.js 在 turn/end 时机调用 detectTimeRule（getDateSeen 定案后）。
  * @param {object} options
  * @param {Array} options.configs 理解配置
  * @param {object} options.session 会话状态（getSessionState 返回）
@@ -80,18 +122,32 @@ export function detectViolations({ configs, session, text, reasoningText = "", m
   const byId = new Map(configs.filter((c) => c.confidence !== "low").map((c) => [String(c.ruleId), c]));
 
   const timeCfg = byId.get("2");
-  if (timeCfg && TIME_WORDS.test(text) && !session.turn.getDateSeen) {
-    hits.push({
-      ruleId: "2",
-      title: timeCfg.title,
-      kind: "correct",
-      reason: "回答出现时间词/日期，但本回合未先调用 Get-Date 核对"
-    });
+  // v0.5.11（用户定稿）：① 只命中具体时间词（TIME_WORDS 为具体词表——"之前/当时"等模糊词不命中，不新增）；
+  // ② 具体时间词 + 无事件证据标注（日志 ts/文件 mtime/进程启动时间等）→ 违规，Get-Date 当前时间不算事件证据。
+  // F1（2026-08-28 阶段三）：本检测仅作"判定"，投递时机由调用方在 turn/end 复核（见 detectTimeRule 注释）。
+  // B3（2026-08-29）：引述/转述语境的时间词不触发（"你昨天说…"是转述，不是我的时间表述）；
+  // 第一人称"我说昨天…"仍触发（转述不了自己）。
+  if (timeCfg && TIME_WORDS.test(text) && !isQuoteOrParaphraseContext(text, TIME_WORDS)) {
+    if (!session.turn.getDateSeen) {
+      hits.push({
+        ruleId: "2",
+        title: timeCfg.title,
+        kind: "correct",
+        reason: "回答出现具体时间词/日期，但本回合未先调用 Get-Date 核对"
+      });
+    } else if (TIME_WORDS.test(text) && !EVIDENCE_MARK_RE.test(text)) {
+      hits.push({
+        ruleId: "2",
+        title: timeCfg.title,
+        kind: "correct",
+        reason: "回答含具体时间词但未附事件证据标注（日志 ts/文件 mtime/进程启动时间等）——Get-Date 当前时间不算过去事件证据（规则 2②）"
+      });
+    }
   }
 
   const promiseCfg = byId.get("7");
   // v0.5.7 P0.5-5：承诺词处于引述/改写语境（"把'保证'改成…"）→ 引述不是承诺，不触发
-  if (promiseCfg && PROMISE_WORDS.test(text) && !isPromiseQuoteContext(text)) {
+  if (promiseCfg && PROMISE_WORDS.test(text) && !isQuoteOrParaphraseContext(text, PROMISE_WORDS)) {
     hits.push({
       ruleId: "7",
       title: promiseCfg.title,

package/lib/core/tool-catalog.js

@@ -51,6 +51,9 @@ const ARTIFACT_TOOLS = new Set([
   // 官方 plan-mode 交互工具（参数为 markdown 计划，批准/继续规划，无文件副作用）
   "exit_plan_mode",
   // 开发侧 staging（写 staging 区，dev_* 工具的自然行为）
+  // 0.5.11 修正（手册 v3.39 口径）：dev_stage 四件套（add/call/promote/demote）= 纳入**敏感
+  // 授权检查**（守卫链覆盖），**不是改分类**——统一保持 artifact；授权检查由 guard-core
+  // （12A isSensitiveToolCall / 13A / 24 装配判定）链上覆盖，不再各自归类。
   "dev_stage_add", "dev_stage_call", "dev_stage_promote", "dev_stage_demote",
   // ESR 工程状态写操作（写工作区记忆存储，engram_store 同族）
   "esr_task", "esr_node", "esr_link", "esr_claim", "esr_close", "esr_unclaim", "esr_dep", "esr_gc"

package/lib/core/understander.js

@@ -26,7 +26,7 @@ const HANDLER_BY_RULE = {
   "12C": "rule12c-network",
   "13A": "rule13a-backup",
   // 13B 已于 2026-08-24 外移至手册（规则正文删除，映射一并清理，防死映射）
-  14: "rule14-report",
+  // 14 为纯 D 级自证规则，无对应 handler（0.5.11：删除空转映射 registry）
   18: "rule18-manual-first",
   21: "rule21-meta",
   22: "rule22-7-direct",

package/lib/core/version-guard.js

@@ -129,7 +129,7 @@ function isOrderedLineInsertion(oldString, newString) {
 }
 
 /** 校验 append/删除式编辑：新增需包含 old_string；删除/缩短时 new_string 可为 old_string 的子串；版本行重编号放行；非表格单行修改放行 */
-export function validateEditAppend(oldString, newString) {
+export function validateEditAppend(oldString, newString, uniqueMatch = false) {
   if (typeof oldString !== "string" || typeof newString !== "string") return { ok: true, errors: [] };
   if (oldString.length === 0) return { ok: true, errors: [] };
   if (isVersionRenumber(oldString, newString)) return { ok: true, errors: [] };
@@ -139,6 +139,9 @@ export function validateEditAppend(oldString, newString) {
   if (isSameLineReplacement(oldString, newString)) return { ok: true, errors: [] };
   if (isTableRowReplacement(oldString, newString)) return { ok: true, errors: [] };
   if (isOrderedLineInsertion(oldString, newString)) return { ok: true, errors: [] };
+  // 0.5.11（用户定稿）：单行整句重写放行——**前提 = old 在原文件唯一匹配**（调用方实测传入）；
+  // edit 工具语义已保证唯一才替换、位置正确；唯一下单行重写 = 正常语义编辑，不再是"覆盖"。
+  if (uniqueMatch && isSingleLine(oldString) && isSingleLine(newString)) return { ok: true, errors: [] };
   return {
     ok: false,
     errors: ["new_string 未包含 old_string，疑似覆盖上一行"]
@@ -146,11 +149,11 @@ export function validateEditAppend(oldString, newString) {
 }
 
 /** 综合校验一次编辑后的文件 */
-export function validateEditedFile(originalText, currentText, oldString, newString) {
+export function validateEditedFile(originalText, currentText, oldString, newString, uniqueMatch = false) {
   const errors = [];
   const continuity = validateVersionContinuity(currentText);
   if (!continuity.ok) errors.push(...continuity.errors);
-  const append = validateEditAppend(oldString, newString);
+  const append = validateEditAppend(oldString, newString, uniqueMatch);
   if (!append.ok) errors.push(...append.errors);
   return { ok: errors.length === 0, errors };
 }

package/lib/index.js

@@ -34,7 +34,9 @@ import {
   askQuestionCoreText,
   askQuestionText,
   askResultApproved,
+  askResultRejected,
   askResultSelectedText,
+  classifyAskScopeType,
   inferPathPrefixFromText,
   inferTypeFromText,
   isAuthMessage,
@@ -58,9 +60,9 @@ import {
 import { toolClass } from "./core/tool-catalog.js";
 import { parseWhitelist, mergeWhitelist, serializeWhitelist } from "./core/whitelist.js";
 import { state } from "./core/runtime.js";
-import { detectViolations, extractAssistantText } from "./core/text-detect.js";
+import { DELIVERY_RE, detectViolations, extractAssistantText } from "./core/text-detect.js";
 import { shouldDetectTurn, shouldDeliver } from "./core/semantic.js";
-import { judgeViolation } from "./core/judge.js";
+import { judgeViolation, judgeViolationsBatch } from "./core/judge.js";
 import {
   applyContract,
   contractSummary,
@@ -98,6 +100,18 @@ reloadRules(state);
 
 // ── 工具函数 ────────────────────────────────────────────────────────────────
 
+/** 统计 substring 出现次数（0.5.11 唯一性前提；与 guard-core countOccurrences 同语义） */
+function countOccurrencesStr(text, sub) {
+  if (typeof text !== "string" || typeof sub !== "string" || sub.length === 0) return 0;
+  let count = 0;
+  let idx = text.indexOf(sub);
+  while (idx !== -1) {
+    count++;
+    idx = text.indexOf(sub, idx + sub.length);
+  }
+  return count;
+}
+
 function summarizeArgs(args) {
   try {
     const s = JSON.stringify(args ?? {});
@@ -178,6 +192,21 @@ const pendingInjectTimers = new Set();
 function maybeInject(ctx, sessionId, violation) {
   if (!pluginConfig.correctInject) return;
   const key = `${sessionId}:${violation.ruleId}`;
+  // D1（2026-08-28 阶段三）：注入文案命令词静态检查——[规则引擎] 注入若含"请直接执行/不要再…
+  // 请立即…"类命令式短语，会驱动模型越过用户直接行动（实弹：节流注入后模型跳过用户回复）；
+  // 注入只许陈述事实。命中 = 拒绝投递 + 审计留痕（防本次修复被下次改文案时回潮）。
+  const INJECT_COMMAND_RE = /请直接执行|请立即|不要再|勿再|请马上|现在就做|立刻执行|直接执行/;
+  if (INJECT_COMMAND_RE.test(String(violation?.reason || ""))) {
+    audit({
+      kind: "inject-command-gated",
+      rule: violation.ruleId,
+      name: "注入文案命令词拦截（D1）",
+      event: "inject",
+      reason: `注入文案含命令式短语，已拒绝投递（只许陈述事实）：${String(violation.reason || "").slice(0, 100)}`,
+      session: sessionId
+    });
+    return;
+  }
   // v0.5.7 投递资格闸（用户拍板"提醒一次并记住 + 会话每小时 3 条预算"，2026-08-26）：
   // 同规则同会话仅投递一次（__self-cert 聚合除外），会话每小时至多 3 条。
   // 被拦的违规仍写审计（inject-skip）——只有"弹进对话"被省掉，审计完整性不降级。
@@ -233,7 +262,9 @@ function maybeInject(ctx, sessionId, violation) {
         });
         audit({ kind: "inject", rule: violation.ruleId, name: "纠正注入", event: "inject", reason: `注入已投递（agent=${sessionId}）：${String(violation.reason || "").slice(0, 120)}`, session: sessionId });
       } else {
-        audit({ kind: "inject", rule: violation.ruleId, name: "纠正注入", event: "inject", reason: `注入未投递：agents.get(${sessionId}) 无可用 agent.inject`, session: sessionId });
+        // D2（2026-08-28 阶段三）：不可投递 agent（子代理/已销毁会话）——仅审计降噪留痕，
+        // reason 注明"预期降噪"便于 /guard log 区分真实失败；不再产生可见投递噪音。
+        audit({ kind: "inject", rule: violation.ruleId, name: "纠正注入", event: "inject", reason: `注入未投递（D2 预期降噪）：agents.get(${sessionId}) 无可用 agent.inject——仅审计留痕`, session: sessionId });
       }
     } catch (error) {
       audit({ kind: "inject", rule: violation.ruleId, name: "纠正注入", event: "inject", reason: `注入异常：${error instanceof Error ? error.message : String(error)}`, session: sessionId });
@@ -249,35 +280,67 @@ function maybeInject(ctx, sessionId, violation) {
  * judge-unavailable（失败/超时/预算满→fail-closed 不投）——三类全部留 /guard log 可对质。
  */
 async function deliverSuspects(ctx, sessionId, suspects, text) {
+  // 0.5.11（用户定稿，预算打穿修复）：一次回复的全部嫌疑 = 一次批量裁决（一次 LLM/一条预算）
+  // 此前逐条 judgeViolation（每条一次调用/一条预算）导致 50/日早上耗尽（unavailable 89 条实证）。
   const judgeFn = state.judgeFn || judgeViolation;
-  const results = await Promise.all(suspects.map(async (v) => {
-    try {
-      const verdict = await judgeFn(ctx, state, sessionId, v, text);
-      const kind = verdict.action === "deliver" ? "judge-pass"
-        : verdict.action === "suppress" ? "judge-false"
-        : "judge-unavailable";
-      audit({
-        kind,
-        rule: v.ruleId,
-        name: "违规裁决",
-        event: "assistant/message",
-        reason: `${verdict.action}：${verdict.note || ""}${verdict.model ? `（model=${verdict.model}）` : ""}`,
-        session: sessionId
-      });
-      return verdict.action === "deliver" ? v : null;
-    } catch (error) {
-      audit({
-        kind: "judge-unavailable",
-        rule: v.ruleId,
-        name: "裁决异常",
-        event: "assistant/message",
-        reason: `未投递：${error instanceof Error ? error.message : String(error)}`,
-        session: sessionId
+  // 注入版/单条路径保持兼容：state.judgeFn（测试 stub）或仅 1 条嫌疑 → 单项路径
+  if (suspects.length <= 1 || state.judgeFn) {
+    const results = await Promise.all(suspects.map(async (v) => {
+      try {
+        const verdict = await judgeFn(ctx, state, sessionId, v, text);
+        const kind = verdict.action === "deliver" ? "judge-pass"
+          : verdict.action === "suppress" ? "judge-false"
+          : "judge-unavailable";
+        audit({
+          kind,
+          rule: v.ruleId,
+          name: "违规裁决",
+          event: "assistant/message",
+          reason: `${verdict.action}：${verdict.note || ""}${verdict.model ? `（model=${verdict.model}）` : ""}`,
+          session: sessionId
+        });
+        return verdict.action === "deliver" ? v : null;
+      } catch (error) {
+        audit({
+          kind: "judge-unavailable",
+          rule: v.ruleId,
+          name: "裁决异常",
+          event: "assistant/message",
+          reason: `未投递：${error instanceof Error ? error.message : String(error)}`,
+          session: sessionId
+        });
+        return null;
+      }
+    }));
+    const deliver = results.filter(Boolean);
+    if (deliver.length > 1) {
+      const briefs = deliver.map((v) => `规则 ${v.ruleId}（${String(v.reason || "").slice(0, 60)}）`).join("；");
+      maybeInject(ctx, sessionId, {
+        ruleId: "__self-cert",
+        reason: `裁决通过 ${deliver.length} 项：${briefs}——请按 /guard log 明细应对`
       });
-      return null;
+    } else if (deliver.length === 1) {
+      maybeInject(ctx, sessionId, deliver[0]);
     }
-  }));
-  const deliver = results.filter(Boolean);
+    return;
+  }
+  // 批量路径：一次 judgeViolationsBatch（一次调用/一次预算/逐条判定）
+  const batch = await judgeViolationsBatch(ctx, state, sessionId, suspects, text);
+  const deliver = [];
+  for (const { violation: v, verdict } of batch) {
+    const kind = verdict.action === "deliver" ? "judge-pass"
+      : verdict.action === "suppress" ? "judge-false"
+      : "judge-unavailable";
+    audit({
+      kind,
+      rule: v.ruleId,
+      name: "违规裁决",
+      event: "assistant/message",
+      reason: `${verdict.action}：${verdict.note || ""}${verdict.model ? `（model=${verdict.model}）` : ""}`,
+      session: sessionId
+    });
+    if (verdict.action === "deliver") deliver.push(v);
+  }
   if (deliver.length > 1) {
     const briefs = deliver.map((v) => `规则 ${v.ruleId}（${String(v.reason || "").slice(0, 60)}）`).join("；");
     maybeInject(ctx, sessionId, {
@@ -353,9 +416,35 @@ export function handleSessionEvent(ctx, session, event) {
       });
       maybeInject(ctx, sid, {
         ruleId: "__engram-gap",
-        reason: "规则 19/M8：手册/AGENTS 落盘后必须在同一回合补 engram_store，否则记忆机制断链——请立即补写并说明"
+        reason: "规则 19/M8：手册/AGENTS 落盘后应在同一回合补 engram_store，否则记忆机制断链（已记审计）"
       });
     }
+    // F1（2026-08-28 阶段三）：规则 2 时序竞态修复——assistant/message 检测到时间词违规时
+    // 不立即投递（Get-Date 工具常在本回合后续步骤才执行，事故实弹：correct 早于 Get-Date 放行），
+    // 标记 pendingRule2，turn/end 复核：getDateSeen 已定案——若本回合最终调用过 Get-Date，撤销（不投递）。
+    const p2 = s.turn.pendingRule2;
+    if (p2) {
+      if (s.turn.getDateSeen) {
+        audit({
+          kind: "rule2-resolved",
+          rule: "2",
+          name: "规则2回合末复核（已核对）",
+          event: "turn/end",
+          reason: "回合内最终已调用 Get-Date（getDateSeen=true）——assistant/message 时误报撤销，不投递",
+          session: sid
+        });
+      } else {
+        audit({
+          kind: "correct",
+          rule: "2",
+          name: "时间信息须真实（执行等级：B + D）",
+          event: "turn/end",
+          reason: p2
+        });
+        maybeInject(ctx, sid, { ruleId: "2", reason: p2 });
+      }
+      s.turn.pendingRule2 = null;
+    }
     return;
   }
   if (event.type === "user/message") {
@@ -423,8 +512,10 @@ export function handleSessionEvent(ctx, session, event) {
     // 规则 22 粒度升级（2026-08-24）：本回合授权范围 = 各 execute 子句推导出的 type+path 范围
     s.turn.scopes = scopesFromIntents(s.turn.intents);
     // LLM 意图兜底（方案 A）：低置信/歧义消息异步预取，不阻塞事件流；失败自动降级词表
+    // A2（阶段一）：promise 记录到 turn——pre-execute 拦截点可同步等待，防"预取未回就按词表拦"竞态
     if (pluginConfig.llmIntent?.enabled) {
-      void enrichIntentWithLlm(ctx, state, sid, text, pluginConfig.llmIntent);
+      const p = enrichIntentWithLlm(ctx, state, sid, text, pluginConfig.llmIntent);
+      s.turn.llmIntentPromise = p;
     }
     if (state.taskContract?.taskContractEnabled) {
       const patch = naturalMode(text, s.contract);
@@ -637,17 +728,30 @@ export function handleSessionEvent(ctx, session, event) {
       const auditCmd = pendingCall.args?.command || pendingCall.args?.code || "";
       if (isAuditCommand(auditCmd)) {
         const output = extractToolOutput(d);
-        if (isError || auditOutputFailed(output)) {
+        if (auditOutputFailed(output)) {
           audit({
             kind: "mount-audit-fail",
             rule: "27",
             name: "全量审计未通过",
             event: "tool/result",
-            reason: isError ? "审计脚本执行失败" : "审计脚本发现 DUPLICATES FOUND",
+            reason: "审计脚本发现 DUPLICATES FOUND",
             session: sid,
             tool: pendingCall.name
           });
           maybeInject(ctx, sid, { ruleId: "27", reason: "规则 27：全量审计未通过，先移除多余挂载再重跑审计" });
+        } else if (isError) {
+          // 2026-08-29 A1：审计命令未执行成功（被规则 22 拦截/工具错误，无审计输出）≠ 审计发现 DUPLICATES——
+          // 不注入"先移除多余挂载"（误导：审计根本没执行；历史误报曾引导模型误移除正确挂载）。
+          // 保持 dirty（审计未跑成，不知道结果）；留痕 mount-audit-error 供 /guard log 排查。
+          audit({
+            kind: "mount-audit-error",
+            rule: "27",
+            name: "审计命令未执行成功",
+            event: "tool/result",
+            reason: "审计脚本被拦截或执行失败（无审计输出）；请先处理拦截原因后重跑审计",
+            session: sid,
+            tool: pendingCall.name
+          });
         } else if (auditOutputPassed(output)) {
           s.mountAuditRevision = state.mountRevision;
           s.mountAuditSignature = computeMountSignature(profileNameFromArgs(pendingCall.args));
@@ -669,11 +773,15 @@ export function handleSessionEvent(ctx, session, event) {
     if (!isError && pendingCall && pendingCall.originalContent != null && versionTarget && isVersionedFile(versionTarget)) {
       try {
         const current = readFileSync(versionTarget, "utf8");
+        // 0.5.11：唯一性透传（与 guard-core 同口径——old 唯一匹配才算"单行重写"放行前提）
+        const oldStr = pendingCall.args.old_string || pendingCall.args.old_str || "";
+        const uniqueMatch = oldStr.length > 0 ? countOccurrencesStr(pendingCall.originalContent, oldStr) === 1 : false;
         const check = validateEditedFile(
           pendingCall.originalContent,
           current,
-          pendingCall.args.old_string || "",
-          pendingCall.args.new_string || ""
+          oldStr,
+          pendingCall.args.new_string || pendingCall.args.new_str || "",
+          uniqueMatch
         );
         if (!check.ok) {
           writeFileSync(versionTarget, pendingCall.originalContent, "utf8");
@@ -745,10 +853,10 @@ export function handleSessionEvent(ctx, session, event) {
         // 避免“仅会话内说明/不跨会话保留”等选项说明把一次小授权放大成全局 12h（2026-08-24 修复）
         const scopeText = `${askQuestionCoreText(pending.questions)} ${selectedText}`.trim();
         const pathPrefix = inferPathPrefixFromText(scopeText || qText);
-        // ask 问题文本措辞不可靠，授权记录为宽泛类型 any + 路径前缀，避免类型错位
-        // 无路径的全局 any 授权缩短 TTL，降低安全边界风险
+        // 0.5.10 建议1①：ask 答复结构化——操作类型从答复文本推断（write/command/any），不再一律 any
+        // （修复"弹窗答复接不住真想操作"的粒度问题——V476AL 同族）
         const authRecord = {
-          type: "any",
+          type: classifyAskScopeType(scopeText || qText),
           pathPrefix,
           source: "ask"
         };
@@ -790,8 +898,11 @@ export function handleSessionEvent(ctx, session, event) {
           reason: `记录授权范围：${qText.slice(0, 120)}`,
           session: sid
         });
-      } else {
-        // 弹窗消减（2026-08-24）：本回合 ask 被拒 → 标记 + 全局记录（5 分钟内再 ask 会被 __ask-throttle 拦）
+      } else if (askResultRejected(result)) {
+        // 弹窗消减（2026-08-24）：本回合 ask 被【明确拒绝】（用户点了拒绝/否定词）→ 标记 + 全局记录
+        // C3（2026-08-28 阶段二）：未响应/超时/无选择不再记为拒绝——"用户没时间回复"不是拒绝，
+        // 旧逻辑把任何未批准都入 askRejections 池 → 5 分钟内再 ask 被节流，用户在忙时反而被烧掉
+        // 授权通道（实弹：用户"你也没给我时间回复啊"）。敏感操作仍由 12A 授权证据把关（不降级）。
         s.turn.askRejected = true;
         if (!state.askRejections) state.askRejections = [];
         state.askRejections.push({ sessionId: sid, at: Date.now() });
@@ -801,7 +912,17 @@ export function handleSessionEvent(ctx, session, event) {
           rule: "12D",
           name: "ask_user_question 未授权",
           event: "tool/result",
-          reason: "用户未批准该授权请求",
+          reason: "用户明确拒绝该授权请求（拒绝词命中，计入节流池）",
+          session: sid
+        });
+      } else {
+        // C3：未响应/超时/无明确选择 → 不置 askRejected、不入节流池（仅审计留痕）
+        audit({
+          kind: "auth-noanswer",
+          rule: "12D",
+          name: "ask_user_question 未响应",
+          event: "tool/result",
+          reason: "ask 无结果/未响应（用户可能未及回复）——不计入拒绝节流池；后续可再次询问",
           session: sid
         });
       }
@@ -822,7 +943,9 @@ export function handleSessionEvent(ctx, session, event) {
     // 引擎自己的注入 → 我的回复 → 再检测 的燃料被掐断（实测 2026-08-26 12:37 六圈即此循环）。
     if (!shouldDetectTurn({ realUserSeen: s.turn.realUserSeen })) return;
     // 交付声明机器闸门（机制批 M3，规则 23④）：完成类声明 → 核对同会话 30 分钟内 verify-pass 记录，缺失注入纠正
-    if (/完成|已通过|已修复|搞定|验证通过|全部通过|修复完成|落盘完成/.test(text)) {
+    // F2（2026-08-28 阶段三）：词面收紧——"完成"裸词太宽（"完成社区检索/尚未完成/正在完成"均误触），
+    // 改为强完成声明模式且排除否定/进行态；仍由 LLM 裁决层兜底（deliverSuspects）。
+    if (DELIVERY_RE.test(text)) {
       const windowStart = Date.now() - 30 * 60 * 1000;
       const hasPass = (state.verifyPass || []).some((v) => v.sessionId === sid && v.at > windowStart);
       if (!hasPass) {
@@ -875,7 +998,13 @@ export function handleSessionEvent(ctx, session, event) {
         });
       }
     }
-    const violations = detectViolations({ configs: state.configs, session: s, text, reasoningText: s.turn.reasoningText, mountRevision: state.mountRevision });
+    // F1（2026-08-28 阶段三）：规则 2 违规不在此时投递——标记 pendingRule2，turn/end 复核（Get-Date 定案）①
+    let violations = detectViolations({ configs: state.configs, session: s, text, reasoningText: s.turn.reasoningText, mountRevision: state.mountRevision });
+    const rule2s = violations.filter((v) => v.ruleId === "2");
+    for (const v of rule2s) {
+      if (!s.turn.pendingRule2) s.turn.pendingRule2 = v.reason;
+      violations = violations.filter((x) => x !== v);
+    }
     for (const v of violations) {
       audit({
         kind: v.kind,
@@ -1074,7 +1203,7 @@ async function executeGuard(ctx, invocation) {
           continue;
         }
         const t = (e.ts || "").replace("T", " ").slice(0, 19);
-        parts.push(`  [${t}] ${e.kind || "?"}｜规则 ${e.rule || "?"}｜${e.name || ""}${e.eventId ? `（${e.eventId}）` : ""}`);
+        parts.push(`  [${t}] ${e.kind || "?"}｜规则 ${e.rule || "?"}｜${e.name || ""}${e.errId ? `（ERR-${e.errId}）` : ""}${e.eventId ? `（${e.eventId}）` : ""}`);
         if (e.reason) parts.push(`      原因：${e.reason}`);
         if (e.tool) parts.push(`      工具：${e.tool}｜参数：${e.args || ""}`);
       }
@@ -1153,11 +1282,17 @@ async function executeGuard(ctx, invocation) {
     }
     case "label": {
       const entries = readAuditLog(500);
-      const found = entries.find((e) => e.eventId === command.eventId);
-      if (!found) return { kind: "error", text: `未找到审计事件：${command.eventId}` };
-      state.labels.set(command.eventId, command.label);
-      audit({ kind: "task-label", rule: "__task-contract", name: "审计人工标注", event: "command", reason: `${command.eventId} = ${command.label}`, session: invocation?.session?.id || "global" });
-      return { kind: "success", text: `已标注 ${command.eventId} = ${command.label}` };
+      // E1（2026-08-28 阶段一）：支持 ERR-xxxxxx 短码定位（此前只认 eventId UUID——
+      // 用户拿拦截提示里的 ERR 码无法打标，链路断在"两套标识符无映射"）
+      const want = String(command.eventId || "").trim();
+      const normalized = want.toUpperCase().startsWith("ERR-") ? want.slice(4).toUpperCase() : want;
+      const found = entries.find(
+        (e) => e.eventId === want || e.errId === normalized || e.errId === want || `ERR-${e.errId}` === want.toUpperCase()
+      );
+      if (!found) return { kind: "error", text: `未找到审计事件：${command.eventId}（提示：/guard log 可查最近记录；若为旧日志则拦截时未记录 ERR 码）` };
+      state.labels.set(found.eventId, command.label);
+      audit({ kind: "task-label", rule: "__task-contract", name: "审计人工标注", event: "command", reason: `${found.eventId} = ${command.label}（来源 ERR-${found.errId || "?"}）`, session: invocation?.session?.id || "global" });
+      return { kind: "success", text: `已标注 ${found.eventId} = ${command.label}` };
     }
     default:
       return { kind: "error", text: USAGE };
@@ -1309,6 +1444,7 @@ export function apply(ctx) {
             tool: exec?.name,
             args: summarizeArgs(exec?.arguments),
             reason: hit.reason,
+            errId: hit.errId,
             session: sessionIdOfExec(exec) // P0-4：deny 审计补 session（2026-08-24 事故复盘：归属会话靠猜）
           });
           state.lastActive = [{ ruleId: hit.ruleId, title: hit.title, reason: hit.reason }];
@@ -1321,10 +1457,12 @@ export function apply(ctx) {
             if (oldest !== undefined) state.deniedKeys.delete(oldest);
           }
           // 弹窗消减（2026-08-24）：E3/ask 节流命中后注入纠正，提示改用普通文本，勿连环弹窗
+          // D1（2026-08-28 阶段三）：改**陈述式**——旧文案"请直接执行"是命令，模型照做会越过
+          // 用户（实弹：注入后模型跳过用户回复直接执行）；只陈述事实，决策权留给用户。
           if (hit.ruleId === "__already-authorized" || hit.ruleId === "__ask-rejected" || hit.ruleId === "__ask-throttle") {
             maybeInject(ctx, sessionIdOfExec(exec), {
               ruleId: hit.ruleId,
-              reason: `${hit.title}：已有授权或询问被拒时请直接执行、或用普通文本说明，不要再弹窗 ask。`
+              reason: `${hit.title}（规则 ${hit.ruleId}）：本会话已存在相近授权记录或被拒记录；再次弹窗询问可能无法送达用户。可用普通文本说明。`
             });
           }
           return hit.reason;
@@ -1336,6 +1474,25 @@ export function apply(ctx) {
   );
 
   // 1.0 规则 12C B 级留痕：命令文本含回环/内网地址时记录审计，不拦截
+  // A2（阶段一，2026-08-28）：LLM 意图兜底同步等待——词表判"拦"（denyMutation）时，若 LLM
+  // 预取仍在进行（llm-pending），在工具执行前同步等待结果（上限 300ms，超时按词表保守裁决）。
+  // 根因：enrichIntentWithLlm 是异步预取，模型先发工具调用往往先于 LLM 返回 → 词表盲区
+  // （转化/读取/展示 等未收录词）在拦截点直接判拦，LLM 兜底形同虚设（2026-08-28 实弹）。
+  ctx.on("tools/pre-execute", async (exec, next) => {
+    try {
+      const sid2 = sessionIdOfExec(exec);
+      const s2 = getSessionState(state, sid2);
+      if (s2?.turn?.intentState === "llm-pending" && typeof s2.turn?.llmIntentPromise?.then === "function") {
+        await Promise.race([
+          s2.turn.llmIntentPromise,
+          new Promise((resolve) => setTimeout(resolve, 300))
+        ]);
+      }
+    } catch {
+      // 等待失败不阻断：词表裁决兜底
+    }
+    return next();
+  });
   ctx.on("tools/pre-execute", async (exec, next) => {
     try {
       const cmd = exec?.arguments?.command || exec?.arguments?.code || "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-rule-engine",
-  "version": "0.5.10",
+  "version": "0.5.11",
   "description": "DSH 规则执行引擎 v3：容器解析 AGENTS.md + 理解器 + 匹配机 + 执行框架",
   "type": "module",
   "main": "lib/index.js",

package/scripts/probe-home.mjs

@@ -0,0 +1,3 @@
+// probe-home.mjs - 实测 resolveDshHome 解析结果（同 host 用的 @deepseek-ai/dsh-home-paths）
+import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+console.log("resolveDshHome():", resolveDshHome());

package/scripts/probe-intent.mjs

@@ -0,0 +1,14 @@
+// probe-intent.mjs - 测"落"字为何被判问句（用户明确执行却拦）
+import { parseUserIntents, shouldDenyMutation } from "../lib/core/intent.js";
+const texts = [
+  "2、连同上面这条一起落",
+  "连上面这条一起落",
+  "落",
+  "全部一起落",
+  "认可全部link不装npm形态",
+  "1、认可形态 2、连上面这条一起落"
+];
+for (const t of texts) {
+  const r = parseUserIntents(t);
+  console.log(`"${t}" → hasExecute=${r.hasExecute} hasQuestion=${r.hasQuestion} types=${r.clauses.map((c) => c.type).join(",")}`);
+}