dsh-rule-engine 0.6.2 → 0.6.4

package/scripts/dualtrack-check.mjs

@@ -0,0 +1,481 @@
+// 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 里显示，供参考。
+//
+// 扫描判据 D（2026-09-10 分层架构 v3 · P0 追加）：规则号字面量
+//   依据：reports/2026-09-10-引擎分层架构-通用层零规则内容-v1.md §七。
+//   模式：rule\d+[A-Za-z]?-  /  byId\.get\("\d+"\)  /  \[guardian:rule\d+\]  /  rule-hint\.\d+
+//         /  ruleId\s*[=!]==?\s*"<N>"（2026-09-10 用户拍板纳入；§七 原列四条，此条据 §二 现状证据补入）
+//   为何单列一判据：「机制以规则号为骨架」比「文案含编号」更根本，且与判据 A 不同维度
+//   （A 抓本机私有词/映射键；D 抓通用层住着规则体系），故各自独立棘轮。
+//   口径：去注释后扫描（注释属开发溯源，非机制骨架）；不设白名单——代码层零规则号。
+//
+// 棘轮（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   # 只打印各文件计数
+//   node scripts/dualtrack-check.mjs --root <dir>  # 改扫描根（仅测试隔离用；非默认根会显著提示）
+//
+// 白名单（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";
+
+// ── 命令行参数（提前解析：--root 必须在下面的路径常量之前生效）──
+const ARGV = process.argv.slice(2);
+const args = new Set(ARGV);
+const rootIdx = ARGV.indexOf("--root");
+const IS_CUSTOM_ROOT = rootIdx >= 0;
+const ROOT = IS_CUSTOM_ROOT && ARGV[rootIdx + 1]
+  ? path.resolve(ARGV[rootIdx + 1])
+  : 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]?$/;
+
+// ── 判据 D：规则号字面量（§七；口径=去注释后扫描，无白名单）──
+const RULE_LITERAL_PATTERNS = [
+  ["executor-name", /rule\d+[A-Za-z]?-/g, "内部执行器名 rule<N>[x]-"],
+  ["byid-get", /byId\.get\(\s*["'`]\d+["'`]\s*\)/g, '按规则号取规则 byId.get("<N>")'],
+  ["guardian-tag", /\[guardian:rule\d+\]/g, "对外文案 [guardian:rule<N>]"],
+  ["rule-hint", /rule-hint\.\d+/g, "rule-hint.<N>"],
+  ["ruleid-eq", /ruleId\s*[=!]==?\s*["'`]\d+[A-Za-z]?["'`]/g, '硬编码规则号比较 ruleId === "<N>"']
+];
+
+// ── 白名单 ──
+/** 白名单两层（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;
+}
+
+// ── 去注释（判据 D 用）：保留字符串/模板/正则原文，注释替换为空白（保持行结构） ──
+function stripComments(src) {
+  let out = "";
+  let i = 0;
+  const n = src.length;
+  let prevSig = "";
+  const push = (s) => { out += s; };
+  while (i < n) {
+    const c = src[i];
+    const c2 = src[i + 1];
+    if (c === "/" && c2 === "/") {
+      while (i < n && src[i] !== "\n") { push(" "); i++; }
+      continue;
+    }
+    if (c === "/" && c2 === "*") {
+      push("  "); i += 2;
+      while (i < n && !(src[i] === "*" && src[i + 1] === "/")) {
+        push(src[i] === "\n" ? "\n" : " ");
+        i++;
+      }
+      if (i < n) { push("  "); i += 2; }
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      const q = c;
+      push(c); i++;
+      while (i < n) {
+        if (src[i] === "\\") { push(src[i] + (src[i + 1] || "")); i += 2; continue; }
+        push(src[i]);
+        if (src[i] === q) { i++; break; }
+        i++;
+      }
+      prevSig = "str";
+      continue;
+    }
+    // 正则字面量：仅在可能的正则位置整体复制（否则 / 是除号）
+    if (c === "/" && prevSig !== "ident" && prevSig !== ")" && prevSig !== "]" && prevSig !== "str") {
+      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) {
+        push(src.slice(i, j + 1));
+        i = j + 1;
+        while (i < n && /[a-z]/i.test(src[i])) { push(src[i]); i++; }
+        prevSig = "regex";
+        continue;
+      }
+    }
+    push(c);
+    if (/[A-Za-z0-9_$]/.test(c)) prevSig = "ident";
+    else if (c === ")") prevSig = ")";
+    else if (c === "]") prevSig = "]";
+    else if (!/\s/.test(c)) prevSig = "other";
+    i++;
+  }
+  return out;
+}
+
+// ── 词法扫描：剔除注释，收集字符串字面量与对象键 ──
+/**
+ * @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);
+  // 判据 D：去注释后扫规则号字面量
+  const code = stripComments(src);
+  let ruleLiterals = 0;
+  const ruleLiteralHits = [];
+  for (const [id, re, desc] of RULE_LITERAL_PATTERNS) {
+    const m = code.match(re);
+    if (!m) continue;
+    ruleLiterals += m.length;
+    if (ruleLiteralHits.length < 3) ruleLiteralHits.push(`${id}×${m.length}（${desc}）如 ${m[0]}`);
+  }
+  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,
+    ruleLiterals,
+    // 判据 A：total 只计「本机性」两类；通用中文文案（runtime）不计入闸
+    total: mapHits.length + local,
+    runtimeHits,
+    mapHits: mapHits.slice(0, 5),
+    localHits,
+    ruleLiteralHits
+  };
+}
+
+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;
+}
+
+// ── 主流程 ──
+if (IS_CUSTOM_ROOT) console.log(`SCAN ROOT（非默认，仅测试隔离用）：${ROOT}\n`);
+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 = {};
+const ruleCounts = {};
+for (const r of results) {
+  counts[`lib/${r.relPath}`] = r.total;
+  ruleCounts[`lib/${r.relPath}`] = r.ruleLiterals;
+}
+const grandTotal = results.reduce((a, r) => a + r.total, 0);
+const ruleGrandTotal = results.reduce((a, r) => a + r.ruleLiterals, 0);
+
+if (args.has("--report")) {
+  for (const r of results.sort((a, b) => (b.total + b.ruleLiterals) - (a.total + a.ruleLiterals))) {
+    if (r.total === 0 && r.ruleLiterals === 0) continue;
+    console.log(`  ${String(r.total).padStart(4)}  lib/${r.relPath}  [映射键 ${r.mapKeys} / 本机标识 ${r.local} / 通用中文文案 ${r.runtime}（不计入闸）] [规则号字面量 ${r.ruleLiterals}]`);
+    if (r.mapHits.length) console.log(`        命中键：${r.mapHits.join(" / ")}`);
+    if (r.ruleLiteralHits.length) console.log(`        规则号字面量：${r.ruleLiteralHits.join("；")}`);
+  }
+  console.log(`\nDUALTRACK REPORT：${results.length} 文件，判据 A（分层残留）合计 ${grandTotal}，判据 D（规则号字面量）合计 ${ruleGrandTotal}`);
+  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 棘轮基线：各文件计数，只许降不许升。files/total=判据 A（分层残留）；ruleLiteralFiles/ruleLiteralsTotal=判据 D（规则号字面量）。--init 首次生成，--update 手动更新（须在提交说明里写清改了什么）。",
+    total: grandTotal,
+    files: counts,
+    ruleLiteralsTotal: ruleGrandTotal,
+    ruleLiteralFiles: ruleCounts
+  };
+  fs.writeFileSync(BASELINE_FILE, JSON.stringify(payload, null, 2) + "\n", "utf8");
+  console.log(`${isUpdate ? "UPDATED" : "INITIALIZED"} ${BASELINE_FILE}`);
+  console.log(`基线：判据 A 合计 ${grandTotal}（${Object.keys(counts).length} 文件）／判据 D 合计 ${ruleGrandTotal}`);
+  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}）`);
+}
+
+// 判据 D 比对（独立棘轮；基线缺该维度 → fail-closed，提示 --update）
+const ruleBase = baseline.ruleLiteralFiles;
+const ruleRegressions = [];
+const ruleImprovements = [];
+if (!ruleBase || typeof ruleBase !== "object") {
+  ruleRegressions.push("基线缺「规则号字面量」维度（ruleLiteralFiles）——判据 D 于 2026-09-10 新增，请运行 --update 记录基线");
+} else {
+  for (const [file, count] of Object.entries(ruleCounts)) {
+    const b = ruleBase[file];
+    if (b === undefined) {
+      if (count > 0) ruleRegressions.push(`${file}: 新增文件含规则号字面量 ${count} 处（基线无此文件）`);
+      continue;
+    }
+    if (count > b) {
+      const r = results.find((x) => `lib/${x.relPath}` === file);
+      const detail = r ? r.ruleLiteralHits.slice(0, 2).join("；") : "";
+      ruleRegressions.push(`${file}: ${count} > 基线 ${b}${detail ? `（如：${detail}）` : ""}`);
+    } else if (count < b) {
+      ruleImprovements.push(`${file}: ${count} < 基线 ${b}`);
+    }
+  }
+  for (const [file, b] of Object.entries(ruleBase)) {
+    if (ruleCounts[file] === undefined && b > 0) ruleImprovements.push(`${file}: 文件已删除（基线 ${b}）`);
+  }
+}
+
+if (regressions.length > 0 || ruleRegressions.length > 0) {
+  if (regressions.length > 0) {
+    console.error(`DUALTRACK FAIL（判据 A 分层残留）：${regressions.length} 项超出基线（只许降不许升）`);
+    for (const r of regressions) console.error(`  ✗ ${r}`);
+  }
+  if (ruleRegressions.length > 0) {
+    console.error(`DUALTRACK FAIL（判据 D 规则号字面量）：${ruleRegressions.length} 项超出基线（只许降不许升）`);
+    for (const r of ruleRegressions) console.error(`  ✗ ${r}`);
+  }
+  console.error("\n  处置：分层残留 → 迁个人层/配置层，或（确属通用功能词）登记 scripts/dualtrack-whitelist.json");
+  console.error("        规则号字面量 → 改为通用 kind 名（架构 v3 §三 L1）；判据 D 不设白名单。");
+  process.exit(1);
+}
+const downCount = improvements.length + ruleImprovements.length;
+console.log(`DUALTRACK OK：判据 A 合计 ${grandTotal}（基线 ${baseline.total ?? "?"}）／判据 D 合计 ${ruleGrandTotal}（基线 ${baseline.ruleLiteralsTotal ?? "?"}）${downCount ? `，${downCount} 个文件下降可 --update` : ""}`);
+for (const im of [...improvements, ...ruleImprovements].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/publish-aptitude-check.mjs

@@ -64,8 +64,11 @@ process.env.DSH_WORKSPACE = root;
   const plain = understandRule(arbitrary);
   check(plain.handler === "", "③ 任意编号 + 无声明：handler 为空（纯自证分流，不误绑定本机执行器）");
   check(plain.actions.includes("deny") && plain.actions.includes("self-certify"), "③ 任意编号：A+D 动作解析正确（deny+self-certify）");
-  const declared = understandRule({ ...arbitrary, body: arbitrary.body + "\n<!-- handler: rule12a-approval -->" });
-  check(declared.handler === "rule12a-approval", "③ 任意编号 + 声明：绑定指定执行器");
+  // 架构 v3 P1：声明值统一归一为 kind 名——kind 名（陌生用户视角）与历史内部名（兼容）都须绑定
+  const declaredKind = understandRule({ ...arbitrary, body: arbitrary.body + "\n<!-- handler: approval -->" });
+  check(declaredKind.handler === "approval", "③ 任意编号 + 声明（kind 名）：绑定指定执行器");
+  const declaredLegacy = understandRule({ ...arbitrary, body: arbitrary.body + "\n<!-- handler: rule12a-approval -->" });
+  check(declaredLegacy.handler === "approval", "③ 任意编号 + 声明（历史内部名）：归一为同一 kind");
   const covered = analyzeCoverage(understandAll([arbitrary]));
   check(covered.uncovered.some((u) => u.ruleId === "X-77"), "③ 任意编号 A 级无 handler：被标记未覆盖（提示正确）");
   // 通用化闭环：defaultMap 清空 → 陌生规则无兜底绑定（纯声明式世界，不借道本机偏好表）；

package/scripts/release-plugin.mjs

@@ -163,6 +163,11 @@ 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 四点同步: 徽章 / 正文当前版本 / 历史表新行 / 固定源自动维护`);
+  console.log(`[DRY-RUN] 固定源将更新为: **${nextVer}（当前）** 锚点 ${quiet(`cd /d "${dir}" && git rev-parse HEAD`).trim().slice(0, 7)}（发布后自动回填 release 提交号）`);
   process.exit(0);
 }
 writeFileSync(pkgPath, readFileSync(pkgPath, "utf8").replace(`"version": "${oldVer}"`, `"version": "${nextVer}"`));
@@ -182,7 +187,32 @@ 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 正文"当前版本"行同步
+// 方案 A（2026-09-09，踩坑 140 根治）：固定源行**自动维护**——bump 时插入「（当前）」行（锚点=改号前 HEAD），
+//   发布提交后由 §5.5 回填真实 release 提交号；旧「（当前）」标记与遗留占位注释一并清理。
+//   旧做法只插占位注释，而 B1 门禁要求「固定源=package 版本」→ 每次发布必撞（0.6.3 首发实证）。
+const headBeforeShort = quiet(`cd /d "${dir}" && git rev-parse HEAD`).trim().slice(0, 7);
+let fixedSourceBumpLine = "";
+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 = rtxt.replace(/\*\*(\d+\.\d+\.\d+)（当前）\*\*/g, "**$1**");
+    // ② 清理遗留占位注释（方案 A 起不再产生）
+    rtxt = rtxt.replace(/\n<!-- fixed-source: [^>]*-->\n/g, "\n");
+    // ③ 插入新版本行（幂等：已存在则跳过）
+    if (!rtxt.includes(`- **${nextVer}（当前）**`)) {
+      fixedSourceBumpLine = `- **${nextVer}（当前）** 固定于 main Commit \`${headBeforeShort}\`（\`git checkout ${headBeforeShort}\` + 发布 bump 可复现 npm \`${name}@${nextVer}\` 与 GitHub Release v${nextVer} 同源代码）。**注：release 提交号由发布脚本自动回填。**`;
+      rtxt = rtxt.replace("## 发行固定源\n", `## 发行固定源\n\n${fixedSourceBumpLine}\n`);
+    }
+  }
+  if (rtxt !== before) writeFileSync(rp, rtxt);
+}
+console.log(`版本已 bump（package.json + README 徽章 + 正文当前版本 + 固定源 ${nextVer}（锚点 ${headBeforeShort}））`);
 
 // B1（2026-09-03）：README 版本表行自动插入（阶段 C 人脑核对已失效的自动化；幂等：已存在 nextVer 行则跳过）
 // 位置：版本表（| 版本 | 日期 | 要点 |）表头后第一数据行之前（最新在上）；内容用调用方 notes 参数或 git log 最近提交信息
@@ -273,16 +303,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;
@@ -326,6 +358,23 @@ run(`cd /d "${repoRoot}" && ${proxyPrefix()}git add -A -- ${stageSpec}`);
 run(`cd /d "${repoRoot}" && git -c core.autocrlf=false commit -m "release: ${name} v${nextVer}" || exit 0`);
 run(`cd /d "${repoRoot}" && ${proxyPrefix()}git push "${pushUrl}" HEAD`);
 
+// ── 5.5 固定源回填（方案 A，2026-09-09）：用 release 提交号替换 bump 时的锚点 ──
+if (fixedSourceBumpLine) {
+  const relShort = quiet(`cd /d "${repoRoot}" && git rev-parse HEAD`).trim().slice(0, 7);
+  const rd = join(dir, "README.md");
+  const rtxt = existsSync(rd) ? readFileSync(rd, "utf8") : "";
+  const finalLine = `- **${nextVer}（当前）** 固定于 main Commit \`${relShort}\`（\`git checkout ${relShort}\` 可复现 npm \`${name}@${nextVer}\` 与 GitHub Release v${nextVer} 同源代码）。`;
+  if (rtxt.includes(fixedSourceBumpLine)) {
+    writeFileSync(rd, rtxt.replace(fixedSourceBumpLine, finalLine), "utf8");
+    console.log(`\n=== 固定源回填 ===\n${nextVer}：锚点 ${headBeforeShort} → release 提交 ${relShort}`);
+    run(`cd /d "${repoRoot}" && ${proxyPrefix()}git add -A -- ${stageSpec}`);
+    run(`cd /d "${repoRoot}" && git -c core.autocrlf=false commit -m "docs(readme): ${nextVer} 固定源回填 ${relShort}（发布后自动同步）" || exit 0`);
+    run(`cd /d "${repoRoot}" && ${proxyPrefix()}git push "${pushUrl}" HEAD`);
+  } else {
+    console.log("（固定源回填跳过：未匹配到 bump 行——可能已手工回填）");
+  }
+}
+
 // ── 6. GitHub Release（带正式 tgz asset，规则 26；清单标记 skipRelease 的包不建）─────
 if (entry?.skipRelease) {
   console.log("（清单标记 skipRelease，跳过 GitHub Release）");

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（本机增强门禁，通用环境无此工具）──
 {