dsh-rule-engine 0.6.2 → 0.6.3

package/lib/core/patterns.js

@@ -3,6 +3,7 @@
 
 import { existsSync } from "node:fs";
 import { isAbsolute } from "node:path";
+import { getMessage } from "../messages.js";
 
 export const INLINE_CMD =
   /\b(?:node|pwsh|powershell)\s+(?:-[ep]|--eval|--print|-Command|-c)\b/i;
@@ -28,21 +29,18 @@ export const PROTECTED_FILENAME_RE =
 export const DATA_DIR_RE =
   /(?:^|[\\/])\.dsh[\\/](?:sessions|storages|\.backups)[\\/]/i;
 
-/** 当下时间词（规则 2①：写当下相对时间前必须先 Get-Date 核对——A1 拆组，2026-09-03） */
-export const TIME_WORDS =
-  /今天|昨天|前天|上周|本周|刚才|\d+\s*分钟前/;
+/** 当下时间词（规则 2①：写当下相对时间前必须先 Get-Date 核对——A1 拆组，2026-09-03）
+ *  P8 小批 B（2026-09-08）：词表下沉配置，经 patRe("time_words") 取（见文件末尾配置层） */
+export const timeWordsRe = () => patRe("time_words");
 
 /** 历史日期/绝对日期（规则 2②：只要求事件证据锚，不要求 Get-Date——A1 拆组；含 ISO 格式，本机高频表述） */
-export const HISTORIC_DATE_RE =
-  /\d{1,2}\s*月\s*\d{1,2}\s*日|\d{4}\s*年\s*\d{1,2}\s*月\s*\d{1,2}\s*日|20\d{2}[-/.]\d{1,2}[-/.]\d{1,2}/;
+export const historicDateRe = () => patRe("historic_date");
 
 /** 事件时间证据标注（规则 2②：过去事件时间必须绑定事件自身证据；"之前/当时"等模糊词不触发检测、不采信）
  *  A1 增补证据锚（2026-09-03）：commit hash / 版本号 / 踩坑 N / 版本记录 vX —— 历史日期带锚即视为已标注来源，免 Get-Date */
-export const EVIDENCE_MARK_RE =
-  /日志\s*(?:ts|时间戳)|mtime|启动时间|进程\s*StartTime|文件\s*修改时间|来源[:：]|ts\s*[:＝]|Get-Date\s*输出|事件时间已核实|【时间未核实】|\b[0-9a-f]{7,40}\b|\bv\d+(?:\.\d+){1,2}\b|踩坑\s*\d+|版本(?:记录)?\s*v\d+(?:\.\d+){1,2}/i;
+export const evidenceMarkRe = () => patRe("evidence_mark");
 
-export const PROMISE_WORDS =
-  /包在我身上|肯定能|绝对没问题|保证(?!不|无法)|一定可以|放心(?:，|,)?肯定|万无一失/;
+export const promiseWordsRe = () => patRe("promise_words");
 
 export const URL_RE = /https?:\/\/[^\s]+/i;
 
@@ -50,12 +48,11 @@ export const URL_RE = /https?:\/\/[^\s]+/i;
 export const PRIVATE_NETWORK_RE =
   /(?:127\.0\.0\.1|localhost|169\.254\.169\.254|10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3})/i;
 
-export const SOURCE_MARK = /来源|出处|via|source|reference|引自|参考/i;
+export const sourceMarkRe = () => patRe("source_mark");
 
 export const CJK_RE = /[\u4e00-\u9fff]/;
 
-export const DSH_KEYWORDS_RE =
-  /DSH|dsh|插件|技能|规则|配置|迁移|手册|会话|装配|profile|bundle/i;
+export const dshKeywordsRe = () => patRe("domain_words");
 
 export const SELF_PROTECT_PATHS = [
   "**/rule-engine.json",
@@ -63,21 +60,36 @@ export const SELF_PROTECT_PATHS = [
   "**/rule-guard.json"
 ];
 
+/** 路径规范化（纯字符串，不触盘）：去包裹引号 → 统一分隔符 → 折叠重复分隔符 → 解析 . / .. → 小写。
+ *  用于本机受保护路径的「包含比较」：防 `\\`、`.`、`..` 等写法变体绕过守卫（2026-09-08 实测缺口）。 */
+export function canonicalPath(p) {
+  if (typeof p !== "string") return "";
+  const s = p.replace(/^["']+|["']+$/g, "").replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+  const out = [];
+  for (const seg of s.split("/")) {
+    if (seg === ".") continue;
+    if (seg === "..") { if (out.length > 1) out.pop(); continue; }
+    out.push(seg);
+  }
+  return out.join("/").toLowerCase();
+}
+
 /** 判断一条命令文本是否是「读取手册」类命令（manualPaths = 本机配置的手册路径列表；无配置 = 无对象，恒 false） */
 export function isManualReadCommand(command, manualPaths = []) {
   if (typeof command !== "string") return false;
   if (!Array.isArray(manualPaths)) return false;
-  const hit = manualPaths.some((pp) => command.toLowerCase().includes(String(pp).toLowerCase()));
+  const n = canonicalPath(command);
+  const hit = manualPaths.some((pp) => n.includes(canonicalPath(String(pp))));
   return hit && /get-content|cat|type|read|grep|findstr|str_replace_editor/i.test(command);
 }
 
-/** 本机追加文件路径匹配（A2-2 算法）：相对 DSH_HOME 归一化 + 大小写不敏感 + 包含比较。
- *  manualPaths 为空 = 无本机配置 = 恒 false（守卫无对象，自然静默）。 */
+/** 本机追加文件路径匹配（A2-2 算法）：规范化 + 大小写不敏感 + 包含比较。
+ *  manualPaths 为空 = 无本机配置 = 恒 false（守卫无对象，自然静默）。
+ *  2026-09-08：改用 canonicalPath——原实现只做斜杠替换，`\\` / `.` / `..` 写法变体可绕过守卫。 */
 export function matchManualPath(p, manualPaths = []) {
   if (typeof p !== "string" || !Array.isArray(manualPaths)) return false;
-  const norm = (s) => s.replace(/\\/g, "/").replace(/^["']+|["']+$/g, "").toLowerCase();
-  const n = norm(p);
-  return manualPaths.some((pp) => n.includes(norm(String(pp))));
+  const n = canonicalPath(p);
+  return manualPaths.some((pp) => n.includes(canonicalPath(String(pp))));
 }
 
 /** 判断一次工具调用是否算作「已读手册」（manualPaths = 本机配置的手册路径列表；无配置 = 无对象，恒 false） */
@@ -423,17 +435,20 @@ export function isAnalysisOp(toolName, args) {
 
 // ═══════════ 0.5.10 已知环境坑特征表（建议5——错误码自动召回，K-01/K-05 依据）═══════════
 // 工具/命令错误文本命中特征 → 审计 error-hint + 注入指向知识库的提示（低频：仅命中才提示；语义=指路不打扰）。
+// hint 文案经 messages 层取（第 1 批 1b：去本机标识——原 hint 引用本机手册踩坑编号/代理端口/发布变量）
 const KNOWN_PITFALLS = [
-  { key: "SEC_E_NO_CREDENTIALS", re: /SEC_E_NO_CREDENTIALS/i, hint: "TLS 凭据失败（常见于沙箱/受限会话）——先查手册踩坑 60/89；Node fetch 配 NODE_USE_ENV_PROXY 可绕" },
-  { key: "proxy-7890-refused", re: /ECONNREFUSED[^\n]*7890/i, hint: "代理端口 7890 无监听——确认代理软件已启动；git/gh 可直连，npm registry 直连本机不可用（发布脚本默认直连，DSH_RELEASE_PROXY 可指定）" },
-  { key: "sandbox-pipe-EPERM", re: /EPERM/i, hint: "受限沙箱下子进程管道受限（踩坑 22⑤）——需 danger-full-access 运行" },
-  { key: "ERR_MODULE_NOT_FOUND", re: /ERR_MODULE_NOT_FOUND/i, hint: "模块缺失——检查依赖闭包/空壳目录（踩坑 54）" }
+  { key: "SEC_E_NO_CREDENTIALS", re: /SEC_E_NO_CREDENTIALS/i, hintKey: "pitfall.tls" },
+  { key: "proxy-7890-refused", re: /ECONNREFUSED[^\n]*7890/i, hintKey: "pitfall.proxy" },
+  { key: "sandbox-pipe-EPERM", re: /EPERM/i, hintKey: "pitfall.sandbox-pipe" },
+  { key: "ERR_MODULE_NOT_FOUND", re: /ERR_MODULE_NOT_FOUND/i, hintKey: "pitfall.module-missing" }
 ];
 
 /** 已知坑特征匹配（纯函数）：错误文本命中特征表 → 返回条目；未命中 → null */
 export function matchKnownPitfall(text) {
   const t = String(text || "");
-  for (const p of KNOWN_PITFALLS) if (p.re.test(t)) return p;
+  for (const p of KNOWN_PITFALLS) {
+    if (p.re.test(t)) return { key: p.key, hint: getMessage(p.hintKey) };
+  }
   return null;
 }
 
@@ -458,17 +473,17 @@ export function isDangerousInlineNode(code) {
  * 2026-09-06 M7 修复：opts.askApproved（本回合已获 ask 授权答复）→ 豁免——ask 答复后同一任务落盘
  * 不再被保守误报 approval-gap（12A 授权链已由 ask 建立，M7 不重复提醒）。
  */
-const PLAN_INSTRUCTION_RE = /方案|调整|补充|建议|评估|草案|完善|优化|改进|提炼|重构|梳理/;
-const WRITE_INSTRUCTION_RE = /落盘|写入|发布|正式写入|正式落盘|改为|改成|保存到手册|写进手册|确定为|确认后(?:落盘|写入|发布)/;
+const planInstructionRe = () => patRe("plan_instruction");
+const writeInstructionRe = () => patRe("write_instruction");
 // 2026-09-06 0.6.x：建议+执行并存（"按第三方的建议按顺序执行修改"）=执行分点——执行词豁免（M7 误报修复）
-const EXECUTE_ACTION_RE = /执行|推进|实施|开始|落实|继续|启动|办理|开展|落地|操作|运行/;
+const executeActionRe = () => patRe("execute_action");
 export function needsApprovalReminder(userText, opts = {}) {
   const t = String(userText || "");
   if (!t) return false;
   if (opts.askApproved) return false; // M7 修复：ask 授权答复豁免 approval-gap
-  if (!PLAN_INSTRUCTION_RE.test(t)) return false;
-  if (EXECUTE_ACTION_RE.test(t)) return false; // 0.6.x：方案词+执行词并存=执行指令（"按建议执行"含执行语）
-  return !WRITE_INSTRUCTION_RE.test(t);
+  if (!planInstructionRe().test(t)) return false;
+  if (executeActionRe().test(t)) return false; // 0.6.x：方案词+执行词并存=执行指令（"按建议执行"含执行语）
+  return !writeInstructionRe().test(t);
 }
 
 let workspaceRoots = []; // 全局注册的工作区根（兜底层）
@@ -684,16 +699,42 @@ export function isSensitiveToolCall(toolName, args, sessionId) {
 
 // ── 批次 5 文本健康检测词表（2026-08-24） ──────────────────────────────
 /** 技术术语（规则 11③ 零基础表达：中文提问 + 术语 + 无解释 → 自证）。英文词带 \b，中文词组按字面。 */
-export const TECH_TERM_RE =
-  /\b(?:API|JSON|REST|WebSocket|OAuth|JWT|ORM|Schema|SSR|CSR|DI|Docker|Kubernetes|K8s|npm|pnpm|Node\.js|TypeScript|Git)\b|正则(?:表达|表达式)?|异步|回调|闭包|哈希|令牌|中间件|依赖注入|虚拟DOM|虚拟 DOM|数据库|SQL|序列化|反序列化|面向对象|函数式|类型推断|泛型/i;
+export const techTermRe = () => patRe("tech_term");
 
 /** 术语解释伴随词（出现任一 → 视为已解释，不触发密度自证） */
-export const TERM_EXPLANATION_RE =
-  /例如|比如|即\b|就是|简单说|换言之|类比|也就是说|通俗|直白|理解为|打个比方|举个例子/;
+export const termExplanationRe = () => patRe("term_explanation");
 
 /** 建议类表述（规则 16 重复推销：会话内同类建议 ≥2 → 自证） */
-export const SUGGEST_RE =
-  /我建议|建议用|推荐|更优方案|建议(?:是|考虑|换成|用|来)|档位建议|不如换|优化建议/;
+export const suggestRe = () => patRe("suggest_words");
+
+// A″ 批评检测形态（P8 小批 C）：强形态（连续问号/叹号）+ 弱形态（反问/责问）
+export const criticismShapeRe = () => patRe("criticism_shape");
+export const criticismWeakRe = () => patRe("criticism_weak");
+// A″ 反向检查（第三批）：明确执行指令词
+export const execDirectiveRe = () => patRe("exec_directive");
+// 规则激活词（小批 B 第一小域）：matcher.js 的情境匹配机词表
+export const activateSkillRe = () => patRe("activate_skill");
+export const activateApprovalRe = () => patRe("activate_approval");
+export const activateNetworkRe = () => patRe("activate_network");
+export const activateBackupRe = () => patRe("activate_backup");
+export const activateTimeRe = () => patRe("activate_time");
+export const activatePromiseRe = () => patRe("activate_promise");
+export const activateSourceRe = () => patRe("activate_source");
+export const deliveryClaimRe = () => patRe("delivery_claim");
+export const internalRefRe = () => patRe("internal_ref");
+export const verifyIntentRe = () => patRe("verify_intent");
+export const emptyTalkRe = () => patRe("empty_talk");
+export const deliveryNoVerifyRe = () => patRe("delivery_no_verify");
+export const verifyEvidenceRe = () => patRe("verify_evidence");
+export const mountMentionRe = () => patRe("mount_mention");
+export const mountAuditOkRe = () => patRe("mount_audit_ok");
+export const scopeOverreachRe = () => patRe("scope_overreach");
+export const scopeBoundedRe = () => patRe("scope_bounded");
+export const apologyOnlyRe = () => patRe("apology_only");
+export const apologyWithCauseRe = () => patRe("apology_with_cause");
+export const versionRecordMentionRe = () => patRe("version_record_mention");
+export const versionRecordOnlyRe = () => patRe("version_record_only");
+export const versionSyncOkRe = () => patRe("version_sync_ok");
 
 /**
  * v0.5.7 P0.5-6（用户拍板）：否定/合规声明语境（"不再/避免/停止/无 XX"）——那不是重复推销。
@@ -702,7 +743,7 @@ export const SUGGEST_RE =
  */
 export function isNegatingSuggestion(text) {
   if (typeof text !== "string") return false;
-  return /(?:不再|不重复|避免|停止|取消|暂不|未再|不要(?:再)?|以后(?:不|别)|今后(?:不|别)|已呼应|已回应|无(?:新)?(?:建议|重复)|没有(?:新)?(?:建议|重复)|只等待)/.test(text);
+  return patRe("negating_suggestion").test(text);
 }
 
 /**
@@ -714,10 +755,11 @@ export function isNegatingSuggestion(text) {
  * 修复背景：B3 规则 7 仅认引号+白名单标记词，无引号转述（"用户之前说万无一失"）误报；
  * 规则 2 原本无引述豁免（引述用户原话"昨天"也报未核对）。
  */
-const PARAPHRASE_BEFORE_RE =
-  /(?:用户|你|他|她|它|对方|作者|维护者|客户|大家|网友|某人|群友|别人).{0,6}?(?:说|说过|表示|提到|提到过|称|强调|认为|写道|原话)/;
-const PARAPHRASE_MARK_BEFORE_RE = /引述|引用|原文|转述|转发|据\S{0,5}说|写过|改成|改为|换成/;
-const PARAPHRASE_MARK_AFTER_RE = /改成|改为|换成|转述|引用/;
+const paraphraseBeforeRe = () => patRe("paraphrase_before");
+const paraphraseMarkBeforeRe = () => patRe("paraphrase_mark_before");
+const paraphraseMarkAfterRe = () => patRe("paraphrase_mark_after");
+// 引号字符集（语言无关：ASCII + 中文弯引号）——不是行为词表，留在机制层
+const QUOTE_CHARS_RE = /[“"「『‘'””」』’]/;
 
 export function isQuoteOrParaphraseContext(text, wordRe) {
   if (typeof text !== "string" || !(wordRe instanceof RegExp)) return false;
@@ -728,17 +770,273 @@ export function isQuoteOrParaphraseContext(text, wordRe) {
     const after = text.slice(m.index + m[0].length);
     // 引述包装 = 承诺词两侧 8 字符内都有引号（ASCII/中文弯引号均算；不区分左右——
     // ASCII 单引号左右同形，分区判定会自相矛盾；双侧近邻引号即视为被引述包裹）。
-    const openNear = /[“"「『‘'””」』’]/.test(before.slice(-8));
-    const closeNear = /[“"「『‘'””」』’]/.test(after.slice(0, 8));
+    const openNear = QUOTE_CHARS_RE.test(before.slice(-8));
+    const closeNear = QUOTE_CHARS_RE.test(after.slice(0, 8));
     if (openNear && closeNear) return true;
-    if (PARAPHRASE_BEFORE_RE.test(before.slice(-14))) return true;
-    if (PARAPHRASE_MARK_BEFORE_RE.test(before.slice(-12))) return true;
-    if (PARAPHRASE_MARK_AFTER_RE.test(after.slice(0, 12))) return true;
+    if (paraphraseBeforeRe().test(before.slice(-14))) return true;
+    if (paraphraseMarkBeforeRe().test(before.slice(-12))) return true;
+    if (paraphraseMarkAfterRe().test(after.slice(0, 12))) return true;
   }
   return false;
 }
 
 /** v0.5.7 P0.5-5（用户拍板）+ B3 扩展：承诺词处于引述/改写/转述语境 → 是引述不是承诺 */
 export function isPromiseQuoteContext(text) {
-  return isQuoteOrParaphraseContext(text, PROMISE_WORDS);
+  return isQuoteOrParaphraseContext(text, promiseWordsRe());
+}
+
+// ═══════════ P8 小批 B（2026-09-08）：检测正则配置层 ═══════════
+// 双层模型（同 lexicon.js）：
+//   ① 通用层 BUILTIN_PATTERNS —— 语言无关最小集，随 npm 包发布，不含中文；
+//   ② 个人层 rule-engine.json 的 patterns 键 —— undefined/null = 不干预（保持当前）；
+//      对象 = 按键完全替换（Override），未提供的键回退内置默认。
+// 取词一律走 patRe(key)（带缓存）；禁止在调用方缓存正则对象（配置注入后旧引用不更新）。
+//
+// 安全边界：本层只承载「文本健康检测」类正则（规则 2/5/7/11/16 的检测词表）；
+// 命令判定/路径守卫类正则（MUTATING_CMD_RE / READONLY_CMD_RE / CONFIG_FILE_RE 等）
+// 一律留在机制层且不含中文——配置缺失不会削弱硬守卫。
+
+/** 可配置检测正则键名（键 → 语义） */
+export const PATTERN_KEYS = [
+  "time_words",             // 规则 2① 当下时间词
+  "historic_date",          // 规则 2② 历史/绝对日期
+  "evidence_mark",          // 规则 2② 事件时间证据锚
+  "promise_words",          // 规则 7 承诺/大话术词
+  "source_mark",            // 规则 5 来源引用标记
+  "domain_words",           // 规则 18 DSH 领域词
+  "plan_instruction",       // M7 方案性指令词
+  "write_instruction",      // M7 落盘性词（豁免提醒）
+  "execute_action",         // M7 执行动作词（豁免提醒）
+  "tech_term",              // 规则 11③ 技术术语
+  "term_explanation",       // 规则 11③ 术语解释伴随词
+  "suggest_words",          // 规则 16 建议类表述
+  "negating_suggestion",    // 规则 16 否定/合规声明语境
+  "paraphrase_before",      // 转述语境（第三人称 + 说/表示…）
+  "paraphrase_mark_before", // 引述标记（前）
+  "paraphrase_mark_after",  // 引述标记（后）
+  "criticism_shape",        // 规则 22② A″ 批评强形态（连续问号/叹号）
+  "criticism_weak",         // 规则 22② A″ 批评弱形态（反问/责问）
+  "exec_directive",         // A″ 反向检查：消息含明确执行指令词（弱信号仅留痕不提示）
+  "activate_skill",         // 规则 12B 激活词
+  "activate_approval",      // 规则 12A 激活词
+  "activate_network",       // 规则 12C 激活词
+  "activate_backup",        // 规则 13A 激活词
+  "activate_time",          // 规则 2 激活词
+  "activate_promise",       // 规则 7 激活词
+  "activate_source",        // 规则 5 激活词
+  "delivery_claim",          // 检测正则（小批 B 第一小域）
+  "internal_ref",            // 检测正则（小批 B 第一小域）
+  "verify_intent",           // 检测正则（小批 B 第一小域）
+  "empty_talk",              // 检测正则（小批 B 第一小域）
+  "delivery_no_verify",      // 检测正则（小批 B 第一小域）
+  "verify_evidence",         // 检测正则（小批 B 第一小域）
+  "mount_mention",           // 检测正则（小批 B 第一小域）
+  "mount_audit_ok",          // 检测正则（小批 B 第一小域）
+  "scope_overreach",         // 检测正则（小批 B 第一小域）
+  "scope_bounded",           // 检测正则（小批 B 第一小域）
+  "apology_only",            // 检测正则（小批 B 第一小域）
+  "apology_with_cause",      // 检测正则（小批 B 第一小域）
+  "version_record_mention",  // 检测正则（小批 B 第一小域）
+  "version_record_only",     // 检测正则（小批 B 第一小域）
+  "version_sync_ok",         // 检测正则（小批 B 第一小域）
+];
+
+/**
+ * 映射型配置键（键 → { 子键: source }）：一张表多条正则的场景（如条款自证触发词）。
+ * 子键语义由消费方定义；与扁平正则键共用同一配置层与回退语义。
+ */
+export const PATTERN_MAP_KEYS = {
+  // 内置默认**空表**（判据 A，2026-09-09）：键=规则号，属发布者私有的规则体系，
+  // 一律从 rule-engine.json 的 patterns.self_cert_hints 注入；空表时该机制静默不触发。
+  self_cert_hints: {}
+};
+
+/** 数值型配置键（键 → 内置默认；与正则键共用同一配置层与校验/回退语义） */
+export const PATTERN_NUM_KEYS = {
+  criticism_caps_ratio: 0.6 // 英文全大写比率阈值（≥ 该值且字母数 ≥6 视为"喊叫"强形态）
+};
+
+// 内置默认：语言无关最小集（无中文）
+const BUILTIN_PATTERNS = {
+  time_words: "(?:today|yesterday|just now|a moment ago|\\d+\\s*minutes? ago)",
+  historic_date: "20\\d{2}[-/.]\\d{1,2}[-/.]\\d{1,2}",
+  evidence_mark: "mtime|ts\\s*[:=]|\\b[0-9a-f]{7,40}\\b|\\bv\\d+(?:\\.\\d+){1,2}\\b",
+  promise_words: "(?:i promise|guaranteed|absolutely (?:fine|no problem)|100% sure|no way it fails)",
+  source_mark: "via|source|reference|quoted from",
+  domain_words: "DSH|dsh|profile|bundle|plugin|skill|config|migrat|manual|session|assembly",
+  plan_instruction: "plan|proposal|adjust|supplement|suggest|evaluat|draft|refine|optimi[sz]e|improve|restructure|review",
+  write_instruction: "persist|write|publish|save to manual|confirm(?:ed)?",
+  execute_action: "execute|run|implement|start|apply|continue|proceed|operate",
+  tech_term:
+    "\\b(?:API|JSON|REST|WebSocket|OAuth|JWT|ORM|Schema|SSR|CSR|DI|Docker|Kubernetes|K8s|npm|pnpm|Node\\.js|TypeScript|Git)\\b|regex|async|callback|closure|hash|token|middleware|dependency injection|virtual DOM|database|SQL|serializ|deserializ|object-oriented|functional|type inference|generic",
+  term_explanation: "e\\.g\\.|for example|i\\.e\\.|in other words|analogy|plainly|understand (?:it )?as|for instance",
+  suggest_words: "i suggest|recommend|better option|optimi[sz]ation suggestion|how about",
+  negating_suggestion:
+    "(?:no longer|not repeat|avoid|stop|cancel|not yet|never again|already (?:echoed|responded)|no new (?:suggestion|repetition)|just waiting)",
+  paraphrase_before:
+    "(?:user|you|he|she|it|they|author|maintainer|client|customer|everyone|someone|netizen|colleague).{0,6}?(?:said|mentioned|stated|noted|claimed|emphasi[sz]ed|wrote|verbatim)",
+  paraphrase_mark_before: "quote|quoted|original text|paraphras|forward|according to|wrote|changed to|reword",
+  paraphrase_mark_after: "changed to|reword|paraphras|quote",
+  // A″ 强形态：连续问号/叹号（全角半角均计；标点非 CJK 汉字，故属语言无关形态）
+  criticism_shape: "(?:[？?]{3,}|[!！]{4,})",
+  // A″ 弱形态：英文最小集（中文反问形态由本机 patterns 注入）
+  criticism_weak:
+    "(?:why (?:are you |do you )?(?:still|again|always)|you (?:again|always|never)|this is (?:wrong|not right|unacceptable)|what (?:are you|the hell))",
+  // A″ 反向检查（2026-09-09 第三批）：消息含明确执行指令词 → 弱信号只留痕不注入提示
+  exec_directive:
+    "(?:write|update|execute|submit|persist|apply|implement|fix|modify|create|delete|publish|download|commit|push|run|refactor|rewrite)",
+  // 规则激活词（P8 小批 B 第一小域，2026-09-09）：matcher.js 用
+  activate_skill: "(?:skill|plugin)",
+  activate_approval: "(?:execute|create|delete|overwrite|move|download|commit|config)",
+  activate_network: "(?:download|network|curl|proxy|blocked)",
+  activate_backup: "(?:delete|overwrite|migrate|backup)",
+  activate_time: "(?:time|today|yesterday|date)",
+  activate_promise: "(?:promise|guarantee|certainly)",
+  activate_source: "(?:quote|source|url|link)",
+  delivery_claim: "(?:done|completed|all (?:done|passed)|fixed|verified|finished)(?![^.]*(?:not yet|pending|incomplete|todo))",
+  internal_ref: "(?:manual|pitfall\\s*\\d+|clause\\s*\\d+|chapter\\s*\\d+|SKILL\\.md|AGENTS\\.md|source code|README|docs?\\s+\\w*(?:written|recorded|documented))",
+  verify_intent: "(?:verify|validate|cross-check|target|compare|confirm)",
+  empty_talk: "(?:got it|noted|i'?ll remember|sure, i'?ve noted)",
+  delivery_no_verify: "(?:done|delivered|completed)",
+  verify_evidence: "(?:runtime verif|mock|startup|actual test|test|verif)",
+  mount_mention: "(?:restart|assembly|mount)",
+  mount_audit_ok: "(?:audit passed|full audit|MOUNT CONSISTENT|DUPLICATES FOUND|audit-mount-consistency)",
+  scope_overreach: "(?:i (?:also |additionally )?(?:added|supplemented|included)|extra add)",
+  scope_bounded: "(?:only (?:the )?selected|not implemented|separately confirm)",
+  apology_only: "(?:sorry|my mistake|my fault|i was wrong)",
+  apology_with_cause: "(?:cause|reason|correction|prevent|avoid|mechanism|fix)",
+  version_record_mention: "(?:changelog|version record|v\\d+\\.\\d+)",
+  version_record_only: "(?:logged (?:to )?changelog|changelog updated)",
+  version_sync_ok: "(?:body|sync|no sync needed)"
+};
+
+let patternsOverride = null;
+let patCache = new Map();
+
+function compilePattern(source, flags) {
+  if (typeof source !== "string" || source.length === 0) return null;
+  try {
+    return new RegExp(source, flags);
+  } catch {
+    return null;
+  }
+}
+
+function resolvePatternSource(key) {
+  const ov = patternsOverride?.[key];
+  if (typeof ov === "string" && ov.length > 0) return ov;
+  return BUILTIN_PATTERNS[key] ?? "";
+}
+
+/** 数值型键的生效值（个人层优先 → 内置默认） */
+/** 取当前生效的映射型配置（个人层优先 → 内置默认）；无对象 = 空表 */
+export function patMap(key) {
+  const ov = patternsOverride?.[key];
+  if (ov && typeof ov === "object" && !Array.isArray(ov)) return ov;
+  return PATTERN_MAP_KEYS[key] ?? {};
+}
+
+/** 数值型键的生效值（个人层优先 → 内置默认） */
+export function patNum(key) {
+  const ov = patternsOverride?.[key];
+  if (typeof ov === "number" && Number.isFinite(ov)) return ov;
+  return PATTERN_NUM_KEYS[key] ?? 0;
+}
+
+/**
+ * 注入个人层检测正则（rule-engine.json 的 patterns 键）。
+ * 语义同 setLexicons：undefined/null = 不干预；对象 = 配置即真相；`{}` = 回退内置默认。
+ * @returns {{applied: string[], rejected: Array<{key: string, reason: string}>, noop?: boolean}}
+ */
+export function setPatterns(cfg) {
+  const applied = [];
+  const rejected = [];
+  if (cfg === undefined || cfg === null) return { applied, rejected, noop: true };
+  if (typeof cfg !== "object" || Array.isArray(cfg)) {
+    patternsOverride = null;
+    patCache = new Map();
+    return { applied, rejected };
+  }
+  const next = {};
+  for (const [k, v] of Object.entries(cfg)) {
+    // 映射型键（值 = 对象）
+    if (PATTERN_MAP_KEYS[k] !== undefined) {
+      if (!v || typeof v !== "object" || Array.isArray(v)) {
+        rejected.push({ key: k, reason: "not-object" });
+        continue;
+      }
+      const sub = {};
+      for (const [sk, sv] of Object.entries(v)) {
+        if (typeof sv !== "string" || !compilePattern(sv, "i")) {
+          rejected.push({ key: `${k}.${sk}`, reason: "invalid-regex" });
+          continue;
+        }
+        sub[sk] = sv;
+      }
+      if (Object.keys(sub).length > 0) {
+        next[k] = sub;
+        applied.push(k);
+      }
+      continue;
+    }
+    // 数值型键（阈值）：0..1 的有限数；字符串数字也接受（JSON 手写容错）
+    if (PATTERN_NUM_KEYS[k] !== undefined) {
+      const num = typeof v === "number" ? v : Number(v);
+      if (!Number.isFinite(num) || num < 0 || num > 1) {
+        rejected.push({ key: k, reason: "invalid-number" });
+        continue;
+      }
+      next[k] = num;
+      applied.push(k);
+      continue;
+    }
+    if (!PATTERN_KEYS.includes(k)) {
+      rejected.push({ key: k, reason: "unknown-key" });
+      continue;
+    }
+    if (typeof v !== "string" || v.length === 0) {
+      rejected.push({ key: k, reason: "empty-or-not-string" });
+      continue;
+    }
+    if (!compilePattern(v, "i")) {
+      rejected.push({ key: k, reason: "invalid-regex" });
+      continue;
+    }
+    next[k] = v;
+    applied.push(k);
+  }
+  patternsOverride = Object.keys(next).length > 0 ? next : null;
+  patCache = new Map();
+  return { applied, rejected };
+}
+
+/** 显式回退内置默认（测试用；生产环境改配置后由插件重载生效） */
+export function resetPatterns() {
+  patternsOverride = null;
+  patCache = new Map();
+}
+
+/** 当前生效的正则 source 快照（键 → source；数值键 → 数值；只读，供测试/诊断） */
+export function effectivePatterns() {
+  const out = {};
+  for (const k of PATTERN_KEYS) out[k] = resolvePatternSource(k);
+  for (const k of Object.keys(PATTERN_NUM_KEYS)) out[k] = patNum(k);
+  return out;
+}
+
+/** 当前是否处于个人层覆盖状态 */
+export function hasPatternOverride() {
+  return patternsOverride !== null;
+}
+
+/** 取当前生效正则（唯一取词入口；调用方禁止缓存返回对象）。非法/空 source → 永不命中占位。 */
+export function patRe(key) {
+  const source = resolvePatternSource(key);
+  const ck = `${key}\u0000${source}`;
+  let hit = patCache.get(ck);
+  if (!hit) {
+    hit = compilePattern(source, "i") || /(?!)/;
+    patCache.set(ck, hit);
+  }
+  return hit;
 }

package/lib/core/quality-ledger.js

@@ -0,0 +1,124 @@
+// quality-ledger.js - 质量账本（机制进发布面，数据留本机，签名不外泄）
+//
+// 设计原则（第三批方案 §一）：
+//   · 机制层（本文件，随包发布）：taskSignature / recordQuality / qualityTrend —— 每个安装者可用；
+//   · 数据层（~/.dsh/quality-ledger.jsonl，**永不发布**）：每单一条记录；
+//   · 配置层（rule-engine.json 的 qualityLedger 键，默认 enabled:false）：不开不产生任何文件；
+//   · 隐私：落盘的是 sha256 归一化指纹（12 位），**单向不可逆**——看到 jsonl 也只知道
+//     "有个指纹的任务做过"，不知道任务内容。
+//
+// 不做的事：不拦截、不评分、不上传（纯旁路统计）。
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/** 默认配置（可被 rule-engine.json 的 qualityLedger 覆盖） */
+export const DEFAULT_LEDGER_CONFIG = {
+  enabled: false,   // 默认关——不开不产生任何文件
+  window: 5,        // 趋势窗口（最近 N 单 vs 之前 N 单）
+  z: 1.96          // 预留：二期 Wilson 区间用
+};
+
+/** 账本文件路径（本机数据，永不发布） */
+export function ledgerPath(home) {
+  const base = home || process.env.DSH_HOME || path.join(os.homedir(), ".dsh");
+  return path.join(base, "quality-ledger.jsonl");
+}
+
+/**
+ * 任务签名：对 purpose + 验收断言做**归一化**后取 sha256 前 12 位。
+ * 归一化规则（公开可审计）：去引号 → 绝对路径替换为 <path> → 数字替换为 <n> → 折叠空白 → 小写。
+ * 目的：同一类任务（措辞/数字/路径不同）得到同一签名，从而能统计"同类任务返工率"。
+ */
+export function taskSignature(purpose, assertions = []) {
+  const parts = [String(purpose || ""), ...(Array.isArray(assertions) ? assertions : [assertions])];
+  const norm = parts
+    .join("\n")
+    .replace(/["'`「」『』]/g, "")
+    .replace(/[A-Za-z]:[\\/][^\s,;)]*/g, "<path>")
+    .replace(/\d+(?:\.\d+)?/g, "<n>")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+  return createHash("sha256").update(norm, "utf8").digest("hex").slice(0, 12);
+}
+
+/**
+ * 记录一单的质量指标（旁路统计；失败静默——账本不能影响主流程）。
+ * @param {object} entry - { purpose, assertions, rework, interventions, frictions, tokens, ts }
+ * @param {object} opts  - { config, home, now }
+ * @returns {{ok: boolean, skipped?: string, path?: string}}
+ */
+export function recordQuality(entry = {}, opts = {}) {
+  try {
+    const cfg = { ...DEFAULT_LEDGER_CONFIG, ...(opts.config || {}) };
+    if (!cfg.enabled) return { ok: false, skipped: "disabled" }; // 默认关：不落盘
+    const purpose = entry.purpose ?? entry.task ?? "";
+    if (!purpose) return { ok: false, skipped: "no-purpose" };
+    const rec = {
+      sig: taskSignature(purpose, entry.assertions || []),
+      ts: typeof entry.ts === "number" ? entry.ts : (opts.now ?? Date.now()),
+      rework: Number(entry.rework) || 0,
+      interventions: Number(entry.interventions) || 0,
+      frictions: Number(entry.frictions) || 0,
+      tokens: Number(entry.tokens) || 0
+    };
+    const file = ledgerPath(opts.home);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, JSON.stringify(rec) + "\n", "utf8");
+    return { ok: true, path: file };
+  } catch (error) {
+    return { ok: false, skipped: `error:${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+
+/** 读取账本（坏行跳过；返回按时间升序的记录数组） */
+export function loadLedger(opts = {}) {
+  const file = ledgerPath(opts.home);
+  if (!fs.existsSync(file)) return [];
+  const out = [];
+  for (const line of fs.readFileSync(file, "utf8").split(/\r?\n/)) {
+    const s = line.trim();
+    if (!s) continue;
+    try {
+      const rec = JSON.parse(s);
+      if (rec && typeof rec.sig === "string") out.push(rec);
+    } catch {
+      // 坏行跳过（账本是旁路数据，不能因一行损坏而失效）
+    }
+  }
+  return out.sort((a, b) => (a.ts || 0) - (b.ts || 0));
+}
+
+/** 指标方向：后窗 vs 前窗的均值比较（值越小越好） */
+function direction(before, after) {
+  if (before === after) return "持平";
+  return after < before ? "改善" : "恶化";
+}
+
+/**
+ * 质量趋势：按签名取最近 window 单 vs 之前 window 单，输出各指标方向 + 明细。
+ * @returns {{sig, count, window, recent, previous, metrics, summary}}
+ */
+export function qualityTrend(signature, opts = {}) {
+  const cfg = { ...DEFAULT_LEDGER_CONFIG, ...(opts.config || {}) };
+  const w = Math.max(1, Number(opts.window ?? cfg.window) || 5);
+  const rows = loadLedger(opts).filter((r) => r.sig === signature);
+  const recent = rows.slice(-w);
+  const previous = rows.slice(-2 * w, -w);
+  const avg = (list, key) => (list.length === 0 ? 0 : list.reduce((a, r) => a + (Number(r[key]) || 0), 0) / list.length);
+  const metrics = {};
+  for (const key of ["rework", "interventions", "frictions", "tokens"]) {
+    const b = avg(previous, key);
+    const a = avg(recent, key);
+    metrics[key] = { before: Number(b.toFixed(2)), after: Number(a.toFixed(2)), direction: direction(b, a) };
+  }
+  const worst = Object.entries(metrics).filter(([, m]) => m.direction === "恶化").map(([k]) => k);
+  const summary = rows.length < 2
+    ? `样本不足（${rows.length} 单）——至少 2 单才能比较`
+    : worst.length === 0
+      ? `方向：持平或改善（近 ${recent.length} 单 vs 前 ${previous.length} 单）`
+      : `方向：${worst.join("、")} 恶化（近 ${recent.length} 单 vs 前 ${previous.length} 单）`;
+  return { sig: signature, count: rows.length, window: w, recent, previous, metrics, summary };
+}