dsh-rule-engine 0.5.2 → 0.5.4

package/lib/core/guard-core.js

@@ -9,6 +9,7 @@ import {
   DSH_KEYWORDS_RE,
   INLINE_CMD,
   MANUAL_PATH_RE,
+  PROTECTED_FILENAME_RE,
   SKILL_EXEMPT,
   commandText,
   isAssemblyMutationTool,
@@ -40,12 +41,11 @@ const RULE_HINTS = {
   "1": "先分析根因，确认问题后再继续",
   "9": "改用脚本文件或显式 UTF-8 BOM 流程",
   "12A": "先 ask_user_question 获取匹配授权",
-  "12D": "先 ask_user_question 获取匹配授权",
   "13A": "先对目标路径执行备份（复制到 .bak/.backups/trash-）",
   "18": "先读取 ~/.dsh/skills/dsh-usage-manual/SKILL.md",
   "21": "按规则 21 分级确认后再落盘",
+  "22": "先回答/展示方案，待用户明确授权（非疑问句+动作词，或 ask 授权答复）后再执行",
   "24": "确认插件 dsh.bundle 类型或改用正确挂载",
-  "25": "将该工具纳入统一守卫覆盖",
   "27": "先运行 node scripts/audit-mount-consistency.mjs --profile web"
 };
 
@@ -80,6 +80,11 @@ export function isProfilePackageJson(p) {
   return typeof p === "string" && /profiles[\\/][^\\/]+[\\/]package\.json$/i.test(p);
 }
 
+/** 判定命令是否"整条命令仅调用统一入口 dsh-manual-write.mjs"（无 ; | & 链式/换行） */
+function isEntryChannelCommand(cmd) {
+  return typeof cmd === "string" && /^[^\n;|&]*dsh-manual-write\.mjs[^\n;|&]*$/i.test(cmd);
+}
+
 /** 计算 edit/write/str_replace 后的目标文件内容；无法可靠计算时返回 null */
 function resultingFileContent(name, args) {
   const p = pathTarget(args);
@@ -226,6 +231,20 @@ export function guardDecision(state, exec, now = Date.now()) {
     );
   }
 
+  // 阶段 C：硬拦 pwsh/bash 绕过统一入口直接写受保护文件（规则 19⑧/21⑨ 的机器执行层）
+  // 合法通道 = 整条命令仅调用 dsh-manual-write.mjs（无 ; | & 链式/换行，防注释文本伪造放行）
+  if (!unlock && (name === "pwsh" || name === "bash")) {
+    const cmd = commandText(args) || "";
+    if (cmd && /(?:set-content|out-file|add-content|write|copy-item|move-item|rename-item|writefilesync|fs\.writefilesync)/i.test(cmd) && PROTECTED_FILENAME_RE.test(cmd)) {
+      if (!isEntryChannelCommand(cmd)) {
+        return makeHit(
+          { ruleId: "__self-protect", title: "受保护文件禁止绕过统一入口直写", action: "deny" },
+          `【硬拦截】受保护文件禁止通过 pwsh/bash 绕过统一入口直写；请使用 scripts/dsh-manual-write.mjs（整个命令只能调用该脚本，不得链式拼接其他写命令；或 /guard unlock 临时放行）。`
+        );
+      }
+    }
+  }
+
   // 写前版本校验（建议③）：版本化文件（SKILL.md/AGENTS.md/CHANGELOG/README 等）在写入前
   // 用 old/new 模拟结果做校验，不合规直接拒绝——避免"先写后回滚"的副作用与假成功
   // 位置在自护之后：受保护文件需先 unlock（用户明确授权）再接受版本校验
@@ -262,6 +281,17 @@ function matchRule(cfg, ctx) {
   const { name, args, p, cmd, session, unlock, state, now } = ctx;
   const id = String(cfg.ruleId);
 
+  // 规则 22⑦ 机器化：用户消息是疑问句 → 本回合禁止变更类工具调用
+  //（"你的执行方案难道没问题吗？"虽含"执行"仍是疑问句——同形词不构成指令，不豁免）
+  if (cfg.handler === "rule22-7-direct") {
+    if (session.turn.questionOnly) {
+      if (isReadOnlyTool(name, args)) return null; // 只读 → 豁免③
+      if (SAFE_UNCOVERED_TOOLS.has(name)) return null; // 展示/授权/查询类（含 ask_user_question）→ 豁免③
+      return makeHit(cfg, `【硬拦截】用户消息是疑问句而非授权（规则 22⑦）：请先回答/展示方案，待用户明确授权后再执行（放行：非疑问句+动作词，或 ask_user_question 授权答复）`);
+    }
+    return null;
+  }
+
   // 规则 1：同工具同参数连续失败 ≥2 次后拦第 3 次（失败计数由 tool/result 更新）
   if (cfg.handler === "rule1-retry") {
     const key = `${name}:${JSON.stringify(args || {})}`;
@@ -301,6 +331,9 @@ function matchRule(cfg, ctx) {
 
   // 规则 13A：删除/覆盖/高风险写前需有“目标路径对应备份”证据
   if (cfg.handler === "rule13a-backup") {
+    // 统一入口命令豁免：dsh-manual-write.mjs 每次写入前自身执行备份（backup() 保留 5 份），
+    // 引擎静态扫描看不到脚本内部动作（已知盲区）；入口命令也已被 __self-protect 限定为唯一写通道。
+    if ((name === "pwsh" || name === "bash") && isEntryChannelCommand(cmd)) return null;
     const destructive = (name === "pwsh" || name === "bash") && cmd && (DESTRUCTIVE_CMD.test(cmd) || (isSensitiveToolCall(name, args) && !/git\s+(push|commit)/i.test(cmd)));
     const highRiskWrite = (name === "edit" || name === "write" || (name === "str_replace_editor" && args?.command !== "view")) && isProtectedConfigPath(p);
     if (highRiskWrite && unlock && !isHighRiskEntryFile(p)) return null;
@@ -351,8 +384,8 @@ function matchRule(cfg, ctx) {
     return null;
   }
 
-  // 规则 12A/12D：敏感操作需要匹配授权证据
-  if (cfg.handler === "rule12a-approval" || cfg.handler === "rule12d-sensitive") {
+  // 规则 12A：敏感操作需要匹配授权证据
+  if (cfg.handler === "rule12a-approval") {
     if (isSensitiveToolCall(name, args)) {
       // 规则 19：dsh-usage-manual/SKILL.md 正文更新免逐次确认（仅手册本身）
       if (p && MANUAL_PATH_RE.test(p)) return null;
@@ -379,7 +412,7 @@ function matchRule(cfg, ctx) {
     return null;
   }
 
-  // 规则 24：插件装配类型确认（A 硬拦）
+  // 规则 24：插件装配类型确认（A 硬拦）+ 变更类工具统一覆盖（原规则 25 语义，检查④）
   if (cfg.handler === "rule24-assembly-type") {
     if (name === "dev_install_package") {
       const dir = args?.dir;
@@ -399,16 +432,13 @@ function matchRule(cfg, ctx) {
     if (badBundles && badBundles.length) {
       return makeHit(cfg, `【硬拦截】${p} 的 dsh.profile.bundles 包含非 bundle/无法确认类型：${badBundles.join("；")}（规则 24）`);
     }
-    return null;
-  }
-
-  // 规则 25：插件变更类工具统一守卫覆盖（A 硬拦；未覆盖的变更工具拒绝）
-  if (cfg.handler === "rule25-tool-coverage") {
+    // 规则 24④：所有能产生文件写入/删除/移动效果的工具都必须纳入统一守卫——
+    // 未覆盖的变更类工具运行时直接拒绝（防"改个新工具就绕过守卫"）
     if (isReadOnlyTool(name, args)) return null;
     if (COVERED_MUTATION_TOOLS.has(name)) return null;
     if (SAFE_UNCOVERED_TOOLS.has(name)) return null;
     if (looksLikeFileMutation(name, args)) {
-      return makeHit(cfg, `【硬拦截】未覆盖的变更类工具 ${name}，违反规则 25：请先纳入统一守卫覆盖`);
+      return makeHit(cfg, `【硬拦截】未覆盖的变更类工具 ${name}，违反规则 24④：请先纳入统一守卫覆盖`);
     }
     return null;
   }

package/lib/core/llm-understander.js

@@ -69,10 +69,24 @@ async function callLlm(ctx, route, rule) {
 }
 
 /**
- * 对非 high 置信规则做一次 LLM 增量理解。
- * @param {object} ctx Cordis context
- * @param {object} state 插件状态（configs 会被原地更新）
+ * LLM 结果消毒（防软化/误强化，2026-08-23）：
+ *  - confidence：只允许提高（low→medium/high、medium→high）；不允许降低（防"模型把规则软化到不硬拦"）
+ *  - hints：只允许追加（辅助检测面，不缩小）
+ *  - actions / handler：一律不受 LLM 影响——执行语义只由模式库（HANDLER_BY_RULE/等级）决定，
+ *    既是防软化也是防"LLM 把规则误指派到无关 handler 造成误拦"。
  */
+const CONFIDENCE_RANK = { low: 0, medium: 1, high: 2 };
+
+export function sanitizeLlmResult(result, cfg) {
+  const out = {};
+  if (typeof result?.confidence === "string" && CONFIDENCE_RANK[result.confidence] > CONFIDENCE_RANK[cfg?.confidence || "low"]) {
+    out.confidence = result.confidence;
+  }
+  if (Array.isArray(result?.hints) && result.hints.length > 0) {
+    out.hints = [...new Set([...(cfg?.hints || []), ...result.hints])];
+  }
+  return out;
+}
 export async function enrichRulesWithLlm(ctx, state) {
   if (!ctx?.llm || !Array.isArray(state.configs)) return;
   const route = await resolveRoute(ctx);
@@ -91,11 +105,10 @@ export async function enrichRulesWithLlm(ctx, state) {
     try {
       const result = await callLlm(ctx, route, cfg);
       if (result && result.confidence) {
-        if (Array.isArray(result.actions)) cfg.actions = result.actions;
-        if (typeof result.confidence === "string") cfg.confidence = result.confidence;
-        if (typeof result.handler === "string") cfg.handler = result.handler;
-        if (Array.isArray(result.hints)) cfg.hints = result.hints;
-        cfg.llmEnriched = true;
+        const patch = sanitizeLlmResult(result, cfg);
+        if (patch.confidence) cfg.confidence = patch.confidence;
+        if (patch.hints) cfg.hints = patch.hints;
+        if (patch.confidence || patch.hints) cfg.llmEnriched = true;
       }
     } catch {
       // 单条失败不影响其他规则，保留模式库结果

package/lib/core/parser.js

@@ -74,7 +74,8 @@ export function loadRules() {
 
 function finalize(rule, lines) {
   const body = lines.slice(rule.startLine + 1, rule.endLine).join("\n").trim();
-  const levelMatch = rule.title.match(/执行等级[：:]\s*([A-DM+]+(?:\s*[强弱])?)/);
+  // 等级正则：支持空格/顿号连接的组合等级（如 "B + D"、"A 弱 + D"），解析结果去空白
+  const levelMatch = rule.title.match(/执行等级[：:]\s*([A-DM+](?:\s*[强弱])?(?:\s*[+＋、]\s*[A-DM+](?:\s*[强弱])?)*)/);
   return {
     index: rule.index,
     title: rule.title,

package/lib/core/patterns.js

@@ -33,6 +33,10 @@ export const PROMISE_WORDS =
 
 export const URL_RE = /https?:\/\/[^\s]+/i;
 
+/** 回环/内网地址模式（规则 12C B 级留痕用） */
+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 CJK_RE = /[\u4e00-\u9fff]/;

package/lib/core/text-detect.js

@@ -28,15 +28,17 @@ const SELF_CERT_HINTS = {
   "22": { re: /我记下了|记住了|收到，我记下了|放心，我记住了/i, reason: "检测到「我记下了」类空话；正确动作是落盘执行并汇报" },
   "23": { re: /完成|交付/, reason: "交付/完成声明未附运行时验证证据" },
   "6": { re: /(?:API|JSON|正则|异步|依赖注入|回调|schema|DI)/i, reason: "请按规则 6 用零基础用户能懂的语言解释" },
-  "16": { re: /建议|优化|更优方案/, reason: "请按规则 16 用五要素格式提建议，避免频繁打断" },
-  "20": { re: /推理档位|off|high|max/, reason: "请按规则 20 给出档位建议并说明理由" },
+  "16": { re: /建议|优化|更优方案|推理档位|档位/, reason: "请按规则 16 用绑定检查格式提建议（或给档位建议并说明理由），避免频繁打断" },
   "12E": { re: /重启|GUI|登录|界面|窗口/, reason: "请按规则 12E 先确认界面真实存在并声明能力边界" },
   "26": { re: /(?=发布|Release|附件)(?!(?:Attach binaries|正式 Asset|release\.assets))/i, reason: "请按规则 26 确认正式 Release Asset（release.assets）并附 tgz/zip" },
   "10": { re: /新会话|旧会话|旧项目|上下文恢复/, reason: "请按规则 10 自证：如实说明默认不自动继承，按优先级恢复并标注来源" },
   "12C": { re: /下载|网络|curl|Clash|被墙/, reason: "请按规则 12C 自证：需代理先告知、失败即停、下载后校验、排查先测连通性" },
   "13B": { re: /会话文件|会话修复|fromRestore|Inbox 回放|孤儿扫描/, reason: "请按规则 13B 自证：会话替换前用户完全退出、三层验证一次跑完、mtime 判断" },
   "15": { re: /文件版本|文件用途|新旧|版本.*处置|保留文件/, reason: "请按规则 15 自证：不凭 mtime/文件名判断新旧，无法确定版本/用途时保留并询问" },
-  "19": { re: /学到新.*DSH|踩到新坑|踩坑.*沉淀|手册有误|知识必沉淀/, reason: "请按规则 19 自证：按①-⑦沉淀并当次汇报正文同步位置" }
+  "19": { re: /学到新.*DSH|踩到新坑|踩坑.*沉淀|手册有误|知识必沉淀/, reason: "请按规则 19 自证：按①-⑧沉淀并当次汇报正文同步位置" },
+  "28": { re: /新建.*文件|放入.*目录|工作区.*归类/, reason: "请按规则 28 自证：新文件按工作区目录索引归类，不确定则查 README 或放 _inbox" },
+  "29": { re: /依赖闭包|node_modules.*验证|动过.*node_modules/, reason: "请按规则 29 自证：重启前验证依赖闭包（关键包非空/顶层 junction 完整/无 dangling）" },
+  "30": { re: /变更验证|验证证据|不破坏.*依赖/, reason: "请按规则 30 自证：执行前证明不破坏依赖+已授权，完成后附验证证据" }
 };
 
 /** 简单判断一段文本是否以英文为主 */

package/lib/core/understander.js

@@ -21,28 +21,51 @@ const HANDLER_BY_RULE = {
   7: "rule7-promise",
   9: "rule9-inline-bom",
   11: "rule11-language",
-  12: "rule12-approval",
   "12A": "rule12a-approval",
   "12B": "rule12b-skill",
   "12C": "rule12c-network",
-  "12D": "rule12d-sensitive",
-  13: "rule13-backup",
   "13A": "rule13a-backup",
   "13B": "rule13b-session",
   14: "rule14-report",
   18: "rule18-manual-first",
   21: "rule21-meta",
-  22: "rule22-direct",
+  22: "rule22-7-direct",
   23: "rule23-runtime-verify",
   24: "rule24-assembly-type",
-  25: "rule25-tool-coverage",
   26: "rule26-release-asset",
   27: "rule27-mount-audit"
 };
 
-/** 根据执行等级推导动作 */
+/**
+ * 覆盖自省（一致性预防机制）：
+ *  - dead：HANDLER_BY_RULE 映射了但 AGENTS.md 无此规则 ID（死映射，应清理）
+ *  - uncovered：A/C/M（deny/ask/meta）级但无 handler 的规则（规则声称会被机器执行，实际不会）
+ * 在 /guard status 与一致性测试/脚本中使用；规则 21④/19⑦ 的体检触发条件之一。
+ */
+export function analyzeCoverage(configs) {
+  const dead = new Map(); // ruleId -> handler（映射存在但规则不存在）
+  const uncovered = []; // A/C/M 级规则但引擎无执行 handler
+  const present = new Set();
+  for (const cfg of configs || []) {
+    if (cfg && cfg.ruleId !== undefined && cfg.ruleId !== null) present.add(String(cfg.ruleId));
+  }
+  for (const [id, handler] of Object.entries(HANDLER_BY_RULE)) {
+    if (!present.has(String(id))) dead.set(String(id), handler);
+  }
+  for (const cfg of configs || []) {
+    if (cfg.disabled) continue;
+    const acts = cfg.actions || [];
+    const hard = acts.some((a) => a === "deny" || a === "ask" || a === "meta");
+    if (hard && !cfg.handler) {
+      uncovered.push({ ruleId: String(cfg.ruleId), title: cfg.title, actions: acts });
+    }
+  }
+  return { dead, uncovered };
+}
+
+/** 根据执行等级推导动作（容忍空白/强弱/连接符：如 "B + D"、"A 弱 + D"、"D 强"） */
 export function actionsForLevel(level) {
-  const s = String(level || "").toUpperCase();
+  const s = String(level || "").toUpperCase().replace(/\s+/g, "");
   const actions = [];
   if (s.includes("A")) actions.push("deny");
   if (s.includes("B")) actions.push("correct");

package/lib/index.js

@@ -20,6 +20,7 @@ import {
   isBackupTool,
   isGetDateCommand,
   isManualReadTool,
+  PRIVATE_NETWORK_RE,
   setWorkspaceRoot
 } from "./core/patterns.js";
 import {
@@ -65,6 +66,7 @@ import { isVersionedFile, validateEditedFile } from "./core/version-guard.js";
 import { computeMountSignature, profileNameFromArgs } from "./core/mount-signature.js";
 import { detectSilentError, extractToolOutput } from "./core/silent-error.js";
 import { enrichRulesWithLlm } from "./core/llm-understander.js";
+import { analyzeCoverage } from "./core/understander.js";
 
 export const name = "dsh-rule-engine";
 export const inject = ["tools", "commands", "agents", "workspaceRegistry", "skills", "llm"];
@@ -548,12 +550,15 @@ async function executeGuard(ctx, invocation) {
       const high = state.configs.filter((c) => c.confidence === "high").length;
       const medium = state.configs.filter((c) => c.confidence === "medium").length;
       const low = state.configs.filter((c) => c.confidence === "low").length;
+      // 覆盖自省（一致性预防）：dead = 映射有但规则无；uncovered = 硬等级规则但无 handler
+      const { dead, uncovered } = analyzeCoverage(state.configs);
       const parts = [
         "【规则引擎状态】",
         `  总开关：${state.enabled ? "开启" : "已关闭"}`,
         `  任务契约：${state.taskContract?.taskContractEnabled ? `开启（模式 ${state.taskContract.taskContractMode}｜ask ${state.taskContract.askEnabled ? "开" : "关"}）` : "关闭"}`,
         `  规则容器：${state.configOk ? `正常（${state.configs.length} 条规则）` : "⚠ " + state.configError}`,
         `  理解置信度：high ${high} / medium ${medium} / low ${low}`,
+        `  覆盖自省：${dead.size === 0 && uncovered.length === 0 ? "无缺口" : (dead.size > 0 ? `死映射 ${[...dead.keys()].join("、")}（引擎映射存在但规则已删除，建议清理）` : "") + (uncovered.length > 0 ? `；未覆盖 ${uncovered.map((u) => u.ruleId).join("、")}（${uncovered.map((u) => u.actions.join("+")).join("；")} 但无 handler，规则声明强制但引擎不执行，建议降 D 级或补实现）` : "")}`,
         `  配置加载：${conf.ok ? "正常" : "⚠ " + conf.error}`,
         `  解锁剩余：${fmtRemain(remainMs(state.unlockUntil))}（配置写保护豁免）`,
         `  放行剩余：${fmtRemain(remainMs(state.bypassUntil))}（全部守卫暂停）`,
@@ -571,7 +576,7 @@ async function executeGuard(ctx, invocation) {
         const flag = c.disabled ? "（已禁用）" : "";
         const actions = (c.actions || []).join("/");
         parts.push(`  [${c.ruleId}] ${c.title} ${flag}`);
-        parts.push(`      等级 ${c.level || "?"}｜动作 ${actions}｜置信 ${c.confidence}｜handler ${c.handler || "generic"}`);
+        parts.push(`      等级 ${c.level || "?"}｜动作 ${actions}｜置信 ${c.confidence}｜handler ${c.handler || "（无——规则声明强制但引擎不执行，建议降 D 级或补实现）"}`);
       }
       return { kind: "success", text: parts.join("\n") };
     }
@@ -749,6 +754,27 @@ export function apply(ctx) {
     "dsh-rule-engine guard"
   );
 
+  // 1.0 规则 12C B 级留痕：命令文本含回环/内网地址时记录审计，不拦截
+  ctx.on("tools/pre-execute", async (exec, next) => {
+    try {
+      const cmd = exec?.arguments?.command || exec?.arguments?.code || "";
+      if (typeof cmd === "string" && cmd.length > 0 && (exec?.name === "pwsh" || exec?.name === "bash") && PRIVATE_NETWORK_RE.test(cmd)) {
+        audit({
+          kind: "network-flag",
+          rule: "12C",
+          name: "内网/回环地址访问留痕",
+          event: "tools/pre-execute",
+          tool: exec?.name,
+          reason: `命令文本含回环/内网地址模式：${cmd.slice(0, 160)}`,
+          session: sessionIdOfExec(exec)
+        });
+      }
+    } catch {
+      // 留痕失败不阻断
+    }
+    return next();
+  });
+
   // 1.1 任务契约 ask 通道：仅在总开关 + askEnabled 时对“应询问”动作返回 ask
   ctx.on("tools/pre-execute", async (exec, next) => {
     try {

package/package.json

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