dsh-rule-engine 0.6.2 → 0.6.3

package/scripts/dualtrack-check.mjs

@@ -0,0 +1,335 @@
+// dualtrack-check.mjs - 分层残留扫描闸（dualtrack-check）
+//
+// 依据：本机使用手册 SKILL.md:113「修改双轨制（2026-08-31 用户定稿）——
+//   铁律=代码层零本机内容（发布门禁扫描红）；机器校验（dualtrack-check）为验收兜底」。
+// 本脚本是那句承诺的落地实现。
+//
+// 扫描范围（lib/**/*.js）——判据 A（2026-09-09 用户拍板，与方案 §一 一致）：
+//   闸只扫「**会随发布者/规则集/环境变化**」的内容，不扫通用中文文案。
+//   ① 本机标识：发布者私有词表（rule-engine.json 的 dualtrack.markers）命中的字符串
+//   ② 映射表键：对象字面量键名匹配 ^\d+[A-Z]?$ 或含 CJK（规则号索引=某人的规则体系）
+//   —— 通用中文文案（字符串字面量内的 CJK）**不计入**：第三方判据明示「中文≠个人化，
+//      通用功能词/提示语是产品能力」。runtime 计数仍在 --report 里显示，供参考。
+//
+// 棘轮（ratchet）：基线记录各文件计数，只许降不许升。
+//   node scripts/dualtrack-check.mjs            # 比对基线（CI/发布门禁用）
+//   node scripts/dualtrack-check.mjs --init     # 首次生成基线
+//   node scripts/dualtrack-check.mjs --update   # 手动更新基线（须在提交说明里写清改了什么）
+//   node scripts/dualtrack-check.mjs --report   # 只打印各文件计数
+//
+// 白名单（scripts/dualtrack-whitelist.json）：
+//   files   —— 整文件豁免（如 lib/lang/**，第 3 批语言包）
+//   strings —— 通用功能词精确豁免（第三方 §一：中文≠个人化，许可词/时间词是产品能力）
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadMarkers } from "../lib/core/dualtrack-markers.js";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const LIB = path.join(ROOT, "lib");
+const BASELINE_FILE = path.join(ROOT, "scripts", "dualtrack-baseline.json");
+const WHITELIST_FILE = path.join(ROOT, "scripts", "dualtrack-whitelist.json");
+const RESIDUE_FILE = path.join(ROOT, "scripts", "local-residue-markers.txt");
+
+const CJK = /[\u4e00-\u9fff]/;
+const MAP_KEY_RE = /^\d+[A-Z]?$/;
+
+// ── 白名单 ──
+/** 白名单两层（2026-09-09）：包内通用白名单 + 本机 rule-engine.json 的 dualtrack.whitelist 合并。
+ *  包内那份随包发布（如 lib/lang/**）；本机那份记录「我豁免我自己的某条」，不进包。 */
+function loadWhitelist() {
+  const files = [];
+  const strings = new Set();
+  // ① 包内通用白名单
+  if (fs.existsSync(WHITELIST_FILE)) {
+    try {
+      const w = JSON.parse(fs.readFileSync(WHITELIST_FILE, "utf8"));
+      for (const f of w.files || []) files.push(f);
+      for (const s of w.strings || []) strings.add(s);
+    } catch (e) {
+      throw new Error(`白名单解析失败：${WHITELIST_FILE} — ${e.message}`);
+    }
+  }
+  // ② 本机白名单（rule-engine.json 的 dualtrack.whitelist）
+  try {
+    const p = path.join(process.env.DSH_HOME || path.join(os.homedir(), ".dsh"), "rule-engine.json");
+    if (fs.existsSync(p)) {
+      const cfg = JSON.parse(fs.readFileSync(p, "utf8"));
+      const w = cfg?.dualtrack?.whitelist;
+      if (w && typeof w === "object") {
+        for (const f of w.files || []) files.push(f);
+        for (const s of w.strings || []) strings.add(s);
+      }
+    }
+  } catch {
+    // 本机配置不可读 → 只用包内白名单（不阻断）
+  }
+  return { files, strings };
+}
+
+/** 整文件豁免匹配（支持 ** 与 * 通配，路径用 / 分隔，相对仓库根） */
+function fileExempt(relPath, patterns) {
+  for (const p of patterns) {
+    const re = new RegExp("^" + p.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\u0000").replace(/\*/g, "[^/]*").replace(/\u0000/g, ".*") + "$");
+    if (re.test(relPath)) return true;
+  }
+  return false;
+}
+
+// ── 词法扫描：剔除注释，收集字符串字面量与对象键 ──
+/**
+ * @returns {{strings: string[], mapKeys: string[]}}
+ *    strings = 字符串字面量的**内容**（模板串按整段处理）
+ *    mapKeys = 形如 "14": / '12E': / 14: 的对象键
+ */
+function tokenize(src) {
+  const strings = [];
+  const mapKeys = [];
+  let i = 0;
+  const n = src.length;
+  // 上一个有意义的 token 类型：用于判断 `/` 是正则还是除号（简化：只看是否可能在正则位置）
+  let prevSig = "";
+  while (i < n) {
+    const c = src[i];
+    // 行注释
+    if (c === "/" && src[i + 1] === "/") {
+      while (i < n && src[i] !== "\n") i++;
+      continue;
+    }
+    // 块注释（含 JSDoc）
+    if (c === "/" && src[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(src[i] === "*" && src[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    // 字符串 / 模板串
+    if (c === '"' || c === "'" || c === "`") {
+      const q = c;
+      const start = i;
+      i++;
+      let buf = "";
+      if (q === "`") {
+        // 模板串：整段作为一个字符串，但 `${...}` 内的表达式跳过（不计入内容，也不当键）
+        while (i < n) {
+          const ch = src[i];
+          if (ch === "\\") { buf += ch + (src[i + 1] || ""); i += 2; continue; }
+          if (ch === "$" && src[i + 1] === "{") {
+            let depth = 1;
+            i += 2;
+            while (i < n && depth > 0) {
+              const d = src[i];
+              if (d === "\\") { i += 2; continue; }
+              if (d === "{") depth++;
+              else if (d === "}") depth--;
+              else if (d === '"' || d === "'" || d === "`") {
+                const qq = d; i++;
+                while (i < n && src[i] !== qq) { if (src[i] === "\\") i++; i++; }
+              }
+              i++;
+            }
+            buf += "\u0000"; // 表达式占位（不含 CJK）
+            continue;
+          }
+          if (ch === "`") break;
+          buf += ch;
+          i++;
+        }
+      } else {
+        while (i < n && src[i] !== q) {
+          if (src[i] === "\\") { buf += src[i] + (src[i + 1] || ""); i += 2; continue; }
+          buf += src[i];
+          i++;
+        }
+      }
+      i++; // 收尾引号
+      strings.push(buf);
+      // 对象键判定（2026-09-09 修正）：必须「前面是 { 或 ,」且「后面（跳空白）是 :」
+      // —— 否则模板串分段与三元表达式会被误判成键（20 处误报的根因）。
+      let j = i;
+      while (j < n && /\s/.test(src[j])) j++;
+      if (src[j] === ":") {
+        let p = start - 1;
+        while (p >= 0 && /\s/.test(src[p])) p--;
+        if (src[p] === "{" || src[p] === ",") {
+          const plain = buf.replace(/\\(.)/g, "$1");
+          if (MAP_KEY_RE.test(plain) || CJK.test(plain)) mapKeys.push(plain);
+        }
+      }
+      prevSig = "str";
+      continue;
+    }
+    // 正则字面量（跳过，不计入）
+    if (c === "/" && prevSig !== "ident" && prevSig !== ")" && prevSig !== "]") {
+      let j = i + 1;
+      let inClass = false;
+      let closed = false;
+      while (j < n) {
+        const ch = src[j];
+        if (ch === "\\") { j += 2; continue; }
+        if (ch === "\n") break;
+        if (ch === "[") inClass = true;
+        else if (ch === "]") inClass = false;
+        else if (ch === "/" && !inClass) { closed = true; break; }
+        j++;
+      }
+      if (closed) {
+        i = j + 1;
+        while (i < n && /[a-z]/i.test(src[i])) i++;
+        prevSig = "regex";
+        continue;
+      }
+      i++;
+      prevSig = "op";
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(c)) {
+      let j = i;
+      while (j < n && /[A-Za-z0-9_$]/.test(src[j])) j++;
+      i = j;
+      prevSig = "ident";
+      continue;
+    }
+    if (c === ")") { prevSig = ")"; i++; continue; }
+    if (c === "]") { prevSig = "]"; i++; continue; }
+    if (!/\s/.test(c)) prevSig = "op";
+    i++;
+  }
+  return { strings, mapKeys };
+}
+
+// ── 单文件扫描 ──
+function scanFile(absPath, relPath, whitelist, residueMarks) {
+  const src = fs.readFileSync(absPath, "utf8");
+  const { strings, mapKeys } = tokenize(src);
+  let runtime = 0;
+  const runtimeHits = [];
+  for (const s of strings) {
+    if (!CJK.test(s)) continue;
+    const plain = s.replace(/\\(.)/g, "$1").trim();
+    if (whitelist.strings.has(plain)) continue; // 通用功能词豁免
+    runtime++;
+    if (runtimeHits.length < 3) runtimeHits.push(plain.slice(0, 40));
+  }
+  const mapHits = mapKeys.filter((k) => MAP_KEY_RE.test(k) || CJK.test(k));
+  let local = 0;
+  const localHits = [];
+  for (const s of strings) {
+    for (const mark of residueMarks) {
+      if (mark && s.includes(mark)) {
+        local++;
+        if (localHits.length < 3) localHits.push(`${mark} ← ${s.slice(0, 40)}`);
+      }
+    }
+  }
+  return {
+    relPath,
+    runtime,
+    mapKeys: mapHits.length,
+    local,
+    // 判据 A：total 只计「本机性」两类；通用中文文案（runtime）不计入闸
+    total: mapHits.length + local,
+    runtimeHits,
+    mapHits: mapHits.slice(0, 5),
+    localHits
+  };
+}
+
+function walk(dir, base = dir, out = []) {
+  for (const e of fs.readdirSync(dir)) {
+    const p = path.join(dir, e);
+    const st = fs.statSync(p);
+    if (st.isDirectory()) walk(p, base, out);
+    else if (/\.js$/.test(e)) out.push(path.relative(base, p).replace(/\\/g, "/"));
+  }
+  return out;
+}
+
+// ── 主流程 ──
+const args = new Set(process.argv.slice(2));
+const whitelist = loadWhitelist();
+// 本机标识词表：与 B2 扫描器共用唯一加载器（本机配置优先 → 环境变量 → 包内示例）
+const { markers: residueMarks, source: markersSource } = loadMarkers({ root: ROOT });
+if (residueMarks.length === 0) {
+  console.error("REFUSED: 本机标识词表为空——请在 rule-engine.json 配置 dualtrack.markers，或设置 DUALTRACK_MARKERS 环境变量");
+  process.exit(1);
+}
+
+const files = walk(LIB).filter((rel) => !fileExempt(rel, whitelist.files));
+const results = files.map((rel) => scanFile(path.join(LIB, rel), rel, whitelist, residueMarks));
+const counts = {};
+for (const r of results) counts[`lib/${r.relPath}`] = r.total;
+const grandTotal = results.reduce((a, r) => a + r.total, 0);
+
+if (args.has("--report")) {
+  for (const r of results.sort((a, b) => b.total - a.total)) {
+    if (r.total === 0) continue;
+    console.log(`  ${String(r.total).padStart(4)}  lib/${r.relPath}  [映射键 ${r.mapKeys} / 本机标识 ${r.local} / 通用中文文案 ${r.runtime}（不计入闸）]`);
+    if (r.mapHits.length) console.log(`        命中键：${r.mapHits.join(" / ")}`);
+  }
+  console.log(`\nDUALTRACK REPORT：${results.length} 文件，合计 ${grandTotal}`);
+  process.exit(0);
+}
+
+if (args.has("--init") || args.has("--update")) {
+  const isUpdate = args.has("--update");
+  if (isUpdate && !fs.existsSync(BASELINE_FILE)) {
+    console.error("REFUSED: --update 需要已存在的基线；首次请用 --init");
+    process.exit(1);
+  }
+  if (!isUpdate && fs.existsSync(BASELINE_FILE)) {
+    console.error(
+      `REFUSED: 基线已存在（${BASELINE_FILE}）——--init 仅用于首次生成。\n` +
+      "      --init 会把当前计数覆盖为基线（棘轮失效）；确需更新请用 --update（须在提交说明里写清改了什么）"
+    );
+    process.exit(1);
+  }
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    note: "dualtrack 棘轮基线：各文件「分层残留」计数，只许降不许升。--init 首次生成，--update 手动更新（须在提交说明里写清改了什么）。",
+    total: grandTotal,
+    files: counts
+  };
+  fs.writeFileSync(BASELINE_FILE, JSON.stringify(payload, null, 2) + "\n", "utf8");
+  console.log(`${isUpdate ? "UPDATED" : "INITIALIZED"} ${BASELINE_FILE}`);
+  console.log(`基线合计：${grandTotal}（${Object.keys(counts).length} 个文件）`);
+  process.exit(0);
+}
+
+// 默认：比对基线
+if (!fs.existsSync(BASELINE_FILE)) {
+  console.error(`FAIL  基线不存在：${BASELINE_FILE}\n      首次请运行：node scripts/dualtrack-check.mjs --init`);
+  process.exit(1);
+}
+const baseline = JSON.parse(fs.readFileSync(BASELINE_FILE, "utf8"));
+const base = baseline.files || {};
+const regressions = [];
+const improvements = [];
+for (const [file, count] of Object.entries(counts)) {
+  const b = base[file];
+  if (b === undefined) {
+    if (count > 0) regressions.push(`${file}: 新增文件含残留 ${count} 处（基线无此文件）`);
+    continue;
+  }
+  if (count > b) {
+    const r = results.find((x) => `lib/${x.relPath}` === file);
+    const detail = r ? [...r.runtimeHits, ...r.localHits].slice(0, 2).join("；") : "";
+    regressions.push(`${file}: ${count} > 基线 ${b}${detail ? `（如：${detail}）` : ""}`);
+  } else if (count < b) {
+    improvements.push(`${file}: ${count} < 基线 ${b}`);
+  }
+}
+for (const [file, b] of Object.entries(base)) {
+  if (counts[file] === undefined && b > 0) improvements.push(`${file}: 文件已删除（基线 ${b}）`);
+}
+
+if (regressions.length > 0) {
+  console.error(`DUALTRACK FAIL：${regressions.length} 项超出基线（只许降不许升）`);
+  for (const r of regressions) console.error(`  ✗ ${r}`);
+  console.error("\n  处置：把新增内容迁个人层/配置层，或（确属通用功能词）登记 scripts/dualtrack-whitelist.json");
+  process.exit(1);
+}
+console.log(`DUALTRACK OK：合计 ${grandTotal}（基线 ${baseline.total ?? "?"}）${improvements.length ? `，${improvements.length} 个文件下降可 --update` : ""}`);
+for (const im of improvements.slice(0, 5)) console.log(`  ↓ ${im}`);
+process.exit(0);

package/scripts/dualtrack-whitelist.json

@@ -0,0 +1,7 @@
+{
+  "note": "dualtrack-check 白名单。登记即豁免——但登记是一次「分类决策」，请写清理由。",
+  "files": [
+    "lib/lang/**"
+  ],
+  "strings": []
+}

package/scripts/local-residue-scan.mjs

@@ -2,16 +2,22 @@
 // local-residue-scan.mjs — 发布物本机痕迹扫描（仅扫 lib/；无 --pack 模式）
 // 用法：node scripts/local-residue-scan.mjs   （在包根目录运行；exit 0 = 干净，exit 1 = 有命中）
 
-import { readFileSync, readdirSync, statSync } from "node:fs";
+import { readdirSync, statSync, readFileSync } from "node:fs";
 import { join, extname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { dirname } from "node:path";
 
 const root = join(dirname(fileURLToPath(import.meta.url)), "..");
 
-// 词表唯一源（v1.2）：scripts/local-residue-markers.txt，与阶段 A 的 A6 验收共用同一文件。
-const MARKERS = readFileSync(join(root, "scripts", "local-residue-markers.txt"), "utf8")
-  .split("\n").map((s) => s.trim()).filter((s) => s && !s.startsWith("#"));
+// 词表唯一源（2026-09-09 起配置化）：本机 rule-engine.json 的 dualtrack.markers 优先，
+// 其次 DUALTRACK_MARKERS 环境变量，最后回退包内示例文件——见 lib/core/dualtrack-markers.js。
+// 理由：词表是**发布者私有数据**，不应随公开仓库/包分发。
+import { loadMarkers } from "../lib/core/dualtrack-markers.js";
+const { markers: MARKERS, source: MARKERS_SOURCE } = loadMarkers({ root });
+if (MARKERS.length === 0) {
+  console.error("REFUSED: 本机标识词表为空——请在 rule-engine.json 配置 dualtrack.markers，或设置 DUALTRACK_MARKERS 环境变量");
+  process.exit(1);
+}
 // 注意：不扫 package.json（作者署名/仓库地址为合法项，A6 口径见其节）；tool-catalog.js 的
 // dev_/esr_/engram_ 前缀规则按阶段 A「关键裁决 3」保留，静态枚举列 0.6.x 跟进。
 

package/scripts/plugins.json

@@ -0,0 +1,10 @@
+{
+  "profile": "web",
+  "plugins": [
+    {
+      "name": "dsh-rule-engine",
+      "dir": ".",
+      "repo": "jilian-dsh/dsh-rule-engine"
+    }
+  ]
+}

package/scripts/release-plugin.mjs

@@ -163,6 +163,10 @@ if (dryRun) {
     const replaced = t.replaceAll(oldBadgeVer, nextUrl).replaceAll(oldBadgeUrl, nextUrl);
     console.log(`[DRY-RUN] README 徽章将变为: ${replaced.match(/version-[^\s]+/)?.[0] || "(未命中，检查徽章形态)"}`);
   }
+  // §1.2（2026-09-08）dry-run 可观测项（单测锚点）
+  console.log(`[DRY-RUN] plugins.json 条目: ${entry ? `${entry.name} (dir=${entry.dir})` : "(未命中——将回退目录路径参数)"}`);
+  console.log(`[DRY-RUN] dist-tags 轮询: ${Math.max(30, Number(process.env.RELEASE_DIST_TAG_POLL_SEC) || 180)}s（RELEASE_DIST_TAG_POLL_SEC 可配）`);
+  console.log(`[DRY-RUN] README 四点同步: 徽章 / 正文当前版本 / 历史表新行 / 固定源占位注释`);
   process.exit(0);
 }
 writeFileSync(pkgPath, readFileSync(pkgPath, "utf8").replace(`"version": "${oldVer}"`, `"version": "${nextVer}"`));
@@ -182,7 +186,19 @@ for (const readme of ["README.md", "README.en.md"]) {
     if (replaced !== text) writeFileSync(rp, replaced);
   }
 }
-console.log("版本已 bump（package.json + README 徽章）");
+// §1.2-②（2026-09-08 第二批）：README 正文"当前版本"行同步 + 固定源占位注释（发布后回填锚点，可 grep）
+for (const readme of ["README.md", "README.en.md"]) {
+  const rp = join(dir, readme);
+  if (!existsSync(rp)) continue;
+  let rtxt = readFileSync(rp, "utf8");
+  const before = rtxt;
+  rtxt = rtxt.replace(/(> 当前版本 \*\*)\d+\.\d+\.\d+(\*\*)/, `$1${nextVer}$2`);
+  if (readme === "README.md" && rtxt.includes("## 发行固定源") && !rtxt.includes("<!-- fixed-source:")) {
+    rtxt = rtxt.replace("## 发行固定源", "## 发行固定源\n\n<!-- fixed-source: 待发布回填 -->");
+  }
+  if (rtxt !== before) writeFileSync(rp, rtxt);
+}
+console.log("版本已 bump（package.json + README 徽章 + 正文当前版本 + 固定源占位）");
 
 // B1（2026-09-03）：README 版本表行自动插入（阶段 C 人脑核对已失效的自动化；幂等：已存在 nextVer 行则跳过）
 // 位置：版本表（| 版本 | 日期 | 要点 |）表头后第一数据行之前（最新在上）；内容用调用方 notes 参数或 git log 最近提交信息
@@ -273,16 +289,18 @@ run(`cd /d "${dir}" && ${proxyPrefix()}npm publish ${tgz}`);
 // B1（2026-09-03）：publish 后校验 registry dist-tags（0.5.16 事故：publish 自报成功但 latest 未切；
 // 脚本此前只跑 publish 不校验发布态——三通道验证铁律：npm 通道以 dist-tags 为准，self-report 不算数）
 // B1 v2（2026-09-03 同日晚）：registry 传播以分钟计，publish 后立即校验曾误报中止（0.5.17 实弹）→
-// 轮询重试 60s（6×10s）；仍不符才中止，并按"版本是否已落盘"给出人工修正路径
-console.log("\n=== npm 发布态校验（dist-tags，轮询最多 60s）===");
+// §1.2-③（2026-09-08 第二批）：轮询 60s→180s（本机首次传播实测 >60s）；RELEASE_DIST_TAG_POLL_SEC 可配（下限 30）
+const pollSec = Math.max(30, Number(process.env.RELEASE_DIST_TAG_POLL_SEC) || 180);
+const attempts = Math.ceil(pollSec / 10);
+console.log(`\n=== npm 发布态校验（dist-tags，轮询最多 ${pollSec}s / ${attempts} 次）===`);
 function sleepMs(ms) { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); }
 const queryTags = () => quiet(`cd /d "${dir}" && ${proxyPrefix()}npm view ${name} dist-tags.latest`);
 const queryVer = () => quiet(`cd /d "${dir}" && ${proxyPrefix()}npm view ${name}@${nextVer} version`);
 let latestActual = "";
-for (let i = 0; i < 6; i++) {
+for (let i = 0; i < attempts; i++) {
   latestActual = queryTags();
   if (latestActual === nextVer) break;
-  if (i < 5) { console.log(`  [B1] 等待 registry 传播（${i + 1}/5，latest=${latestActual || "(空)"}）…`); sleepMs(10000); }
+  if (i < attempts - 1) { console.log(`  [B1] 等待 registry 传播（${i + 1}/${attempts - 1}，latest=${latestActual || "(空)"}）…`); sleepMs(10000); }
 }
 if (latestActual !== nextVer) {
   const verExists = queryVer() === nextVer;

package/scripts/verify-all.mjs

@@ -131,6 +131,10 @@ step("发布门禁 B1（README 版本四性一致性：package.json/徽章/正
 // ── ⑩ 发布门禁 B2（阶段 B，2026-09-04：lib/ 本机痕迹扫描，词表唯一源）──
 step("发布门禁 B2（lib/ 本机痕迹扫描——词表唯一源，命中即红）", process.execPath, [join(root, "scripts", "local-residue-scan.mjs")]);
 
+// ── ⑩′ 发布门禁 B3：dualtrack-check（2026-09-09 第三批第 1 波：分层残留棘轮闸——
+//    手册 SKILL.md:113「机器校验（dualtrack-check）为验收兜底」的落地；只许降不许升）──
+step("发布门禁 B3（dualtrack 分层残留棘轮——超出基线即红）", process.execPath, [join(root, "scripts", "dualtrack-check.mjs")]);
+
 // ── ⑪ 存在性扫描（泄露预防，2026-09-05：真实路径判据——REAL_PATHS_SCAN 指向扫描器，0 命中才算过；
 //    未设置=WARN（本机增强门禁，通用环境无此工具）──
 {

package/scripts/verify-v474.mjs

@@ -1,14 +1,14 @@
 // verify-v474.mjs - v4.74 记录项引擎在位抽查（分点切分/规则2双检/词表跑）
 import { parseUserIntents } from "../lib/core/intent.js";
-import { ACTION_WORDS_RE } from "../lib/core/lexicon.js";
-import { EVIDENCE_MARK_RE, TIME_WORDS } from "../lib/core/patterns.js";
+import { actionWordsRe } from "../lib/core/lexicon.js";
+import { evidenceMarkRe, timeWordsRe } from "../lib/core/patterns.js";
 
 // ① 分点切分（标点后编号——用户"1、问2、问3、跑"同行）
 const mixed = parseUserIntents("1、为什么预算会满？2、检查时间规则？3、跑");
 console.log("分点(同行标点):", mixed.hasExecute && mixed.clauses[2].type === "execute" ? "✅" : "❌");
-// ② 词表补跑
-console.log("词表含跑:", ACTION_WORDS_RE.test("跑") ? "✅" : "❌");
-// ③ 规则2双检：EVIDENCE_MARK_RE 存在、TIME_WORDS 具体词
-console.log("规则2证据词表:", EVIDENCE_MARK_RE.test("日志 ts=2026-08-27T15:21:05Z") ? "✅" : "❌");
-console.log("规则2具体词(昨天):", TIME_WORDS.test("昨天") ? "✅" : "❌");
-console.log("规则2模糊词(之前):", TIME_WORDS.test("之前") ? "❌(应不命中)" : "✅(不命中)");
+// ② 词表补跑（P8 小批 A 起词表经函数取；本机需 lexicons 配置注入中文词表）
+console.log("词表含跑:", actionWordsRe().test("跑") ? "✅" : "❌");
+// ③ 规则2双检：证据锚、具体时间词（P8 小批 B 起经访问器取；本机需 patterns 配置注入中文表）
+console.log("规则2证据词表:", evidenceMarkRe().test("日志 ts=2026-08-27T15:21:05Z") ? "✅" : "❌");
+console.log("规则2具体词(昨天):", timeWordsRe().test("昨天") ? "✅" : "❌");
+console.log("规则2模糊词(之前):", timeWordsRe().test("之前") ? "❌(应不命中)" : "✅(不命中)");