dsh-rule-engine 0.6.2 → 0.6.4

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） */
@@ -291,6 +303,12 @@ const ALLOW_SEG_RE =
 // 0.5.12（F4）：纯字符串/纯输出段（整段是引号包裹字符串或 $() 子表达式）——不是命令，放行。
 // 保守边界：只匹配"整段即字符串"（^...$ 锚定），不让 node -e "..." / curl -o "..." 借道。
 const PURE_STRING_SEG_RE = /^(?:"[^"\r\n]*"|'[^'\r\n]*'|`[^`\r\n]*`|\$\(\s*[^()\r\n]*\s*\))+$/;
+// F5（2026-09-10 修复，第三方实测）：`Remove-Item Env:NAME` 的**操作对象是进程环境变量，不是文件**，
+// 此前被 MUTATING_CMD_RE 的 Remove-Item 命中判写（ERR-JCSE3O 的类判定来源）。
+// 边界（保守）：仅当整段目标都是 Env:/$env: 形式时豁免；`Remove-Item <路径>`、混合目标、
+// 选项在目标之前（如 `Remove-Item -Force Env:X`）一律不豁免——宁可误拦不可放行真删除。
+const ENV_SCOPE_REMOVE_SEG_RE =
+  /^\s*Remove-Item\s+(?:\$env:|Env:)[\w()]+\s*(?:-[\w]+\s+(?:"[^"]*"|'[^']*'|[^\s;|]+)\s*)*$/i;
 // 剥离 try/catch/finally 控制块：块内语句与主语句同样接受只读判定（Try-* 不是 cmdlet）。
 // 注意：不做全量 [{}] 替换——if/else 子表达式（$(if(...){...}else{...})）会被切碎误判。
 function stripControlBlocks(command) {
@@ -307,12 +325,38 @@ export function isMutationCommand(command) {
   return typeof command === "string" && MUTATING_CMD_RE.test(command);
 }
 
-/** 只读命令链按分隔符折段（机制 B，2026-08-24）：`; 换行 && || |`（管道前后是命令链；`2>&1`/`2>$null` 的 stderr 重定向不拆分） */
+/** 只读命令链按分隔符折段（机制 B，2026-08-24）：`; 换行 && || |`（管道前后是命令链；`2>&1`/`2>$null` 的 stderr 重定向不拆分）
+ *  F5（2026-09-10 修复，第三方实测）：**引号感知**——此前裸拆 `|` 会把**引号内的 `|`** 当分隔符
+ *  （正则 alternation `-Pattern 'a|b'`、格式串 `"{0} | x"`、`-notmatch 'x|y'`）→ 切出无法识别的残段
+ *  → L354 保守判非只读 → 整条只读命令被规则 22 按 write 拦（ERR-4WOAKG / 9T886X / Z8M7YC / IKXLU8）。
+ *  现：`'…'` / `"…"` / `` `…` `` 内的分隔符不拆。转义语义按 PS：`'` 内不转义（`''` 表一个单引号）；
+ *  `"` 与 `` ` `` 内 `\` / `` ` `` 转义下一字符（兼容跨语言写法）。 */
 function splitCommandSegments(command) {
-  return String(command)
-    .split(/\r?\n|;|&&|\|\||(?<!\d)\|/)
-    .map((s) => s.trim())
-    .filter(Boolean);
+  const s = String(command);
+  const out = [];
+  let buf = "";
+  let quote = null;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (quote) {
+      buf += c;
+      if (quote !== "'" && (c === "\\" || c === "`")) { buf += s[i + 1] ?? ""; i++; continue; }
+      if (c === quote) quote = null;
+      continue;
+    }
+    if (c === "'" || c === '"' || c === "`") { quote = c; buf += c; continue; }
+    if (c === "\r") continue;
+    if (c === "\n" || c === ";") { out.push(buf); buf = ""; continue; }
+    if (c === "&" && s[i + 1] === "&") { out.push(buf); buf = ""; i++; continue; }
+    if (c === "|") {
+      if (s[i + 1] === "|") { out.push(buf); buf = ""; i++; continue; }
+      if (i > 0 && /\d/.test(s[i - 1])) { buf += c; continue; } // 保留原 (?<!\d) 语义
+      out.push(buf); buf = ""; continue;
+    }
+    buf += c;
+  }
+  out.push(buf);
+  return out.map((x) => x.trim()).filter(Boolean);
 }
 
 /** 判断命令文本是否只读（读文件/查询类，无写入/删除/提交副作用）。
@@ -333,6 +377,7 @@ export function isReadOnlyCommand(command) {
     const s = String(seg).trim();
     if (!s) return true; // 剥离残留的空段放行
     if (s.startsWith("#")) return true;
+    if (ENV_SCOPE_REMOVE_SEG_RE.test(s)) return true; // F5：环境变量操作非文件删除（须在 MUTATING 之前）
     if (MUTATING_CMD_RE.test(s)) return false;
     if (MUTATING_METHOD_RE.test(s)) return false;
     if (COM_CONTENT_ASSIGN_RE.test(s)) return false; // $doc.Text=... 是写文档
@@ -423,17 +468,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 +506,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 +732,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 +776,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 +788,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 +803,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;
 }