dsh-rule-engine 0.5.17 → 0.6.1

package/lib/core/authorization.js

@@ -51,12 +51,63 @@ const TYPE_HINTS = [
   // 只读/审查类（置末位，2026-08-25 RB-05）：不覆盖在前类别的变更语义（“修改并审查”仍按 write/delete），
   // 仅当无其它类型命中时给只读类型——配合 ACTION_RE 只读词（审查/阅读/验证等），使“审查文件”类执行分点
   // 授权类型为 analysis（只读），不再落入 any 宽泛授权。
-  { re: /审查|阅读|查看|核对|检查|审阅|复核|查阅|验证|对照|评估|分析|研究|排查|核实|梳理|调查|诊断|读取|读(?:出|一下|一遍|完)?|展示|打开|提取/i, type: "analysis" }
+  { re: /审查|阅读|查看|核对|检查|审阅|复核|查阅|验证|对照|评估|分析|研究|排查|核实|梳理|调查|诊断|读取|读(?:出|一下|一遍|完)?|展示|打开|提取/i, type: "analysis" },
+  // C4（2026-09-04）：archive 独立类型（解压/归档高频用例；物理确认最小范围）
+  { re: /解压|解包|解压缩|归档|unzip|expand-archive|extract-archive|tar\s+-x|7z\s+x/i, type: "archive" }
 ];
 
+// ── C4（2026-09-04）：类型提示配置化 + 物理确认类型枚举 ──
+// typeHintsOverride = null → 内置表；非空 → 完全替换（clear 语义）；空 → 还原内置。
+let typeHintsOverride = null;
+
+function isValidHint(h) {
+  if (!h || typeof h.type !== "string" || h.type.length === 0 || h.type === "any") return false;
+  if (typeof h.re !== "string") return false;
+  try {
+    new RegExp(h.re, "i");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeHints(list) {
+  const out = [];
+  for (const h of list) {
+    if (!isValidHint(h)) continue;
+    if (!out.some((x) => x.type === h.type)) out.push({ type: h.type, re: new RegExp(h.re, "i") });
+  }
+  return out;
+}
+
+/** C4：配置层扩展/替换授权类型提示；空列表 = 还原内置；{ clear: true } = 完全替换（不含内置） */
+export function setTypeHints(hints, opts = {}) {
+  const list = Array.isArray(hints) ? hints : [];
+  if (list.length === 0) {
+    typeHintsOverride = null;
+    return;
+  }
+  const normalized = normalizeHints(list);
+  typeHintsOverride = opts?.clear ? normalized : [...TYPE_HINTS, ...normalized];
+}
+
+/** C4：当前生效的类型枚举（内置 9 类 + 配置扩展；any=全局通配被禁止，不枚举） */
+export function APPROVE_TYPES() {
+  const hints = typeHintsOverride ?? TYPE_HINTS;
+  const types = [];
+  for (const h of hints) {
+    if (h && typeof h.type === "string" && h.type !== "any" && !types.includes(h.type)) types.push(h.type);
+  }
+  return types;
+}
+
+function currentHints() {
+  return typeHintsOverride ?? TYPE_HINTS;
+}
+
 // C2（2026-08-28 阶段二）：`、`（中文顿号）从非路径字符黑名单移除——Windows 中文目录名
-// 常见顿号（"D:\1、工作\..."——用户工作目录），原正则在此截断 → 授权记录成 "d:/1"，
-// 真实操作路径匹配失败（ERR-LU50QQ：已授权范围 [write d:/1] 拦 d:/1、工作/...）。
+// 常见顿号（"D:\1、示例\..."——用户工作目录），原正则在此截断 → 授权记录成 "d:/1"，
+// 真实操作路径匹配失败（ERR-LU50QQ：已授权范围 [write d:/1] 拦 d:/1、示例/练习/...）。
 // 保守边界：顿号后跟空格+新词时可能合并（fail-closed——提取过长 → 授权匹配失败 → 拦而非放），
 // 不放大授权；引号包裹分支本就不受此影响。
 const PATH_TOKEN_RE = /["'][A-Za-z]:[\\/](?!\/)[^"']+["']|[A-Za-z]:[\\/](?!\/)[^\s'"`，。；：！？（）【】《》]+|(?:^|[\s"'`])\/(?:[^\s"'`，。；：！？（）【】《》、]+)/g;
@@ -69,7 +120,7 @@ export function normalizePath(p) {
 /** 从文本推断操作类型（取第一个命中） */
 export function inferTypeFromText(text) {
   const s = String(text || "");
-  for (const hint of TYPE_HINTS) {
+  for (const hint of currentHints()) {
     if (hint.re.test(s)) return hint.type;
   }
   return "any";
@@ -78,21 +129,25 @@ export function inferTypeFromText(text) {
 /** 0.5.10 建议1①（用户审查采纳）：ask 答复文本 → 结构化操作类型（修复"弹窗授权宽泛 any 接不住真操作"）。
  *  返回 write | command | any（analysis/artifact 类本就不需授权，不落入授权记录）。
  *  明确操作词 → 具体类型；含糊/纯查看 → any（保守：TTL 短兜底）。 */
+/** ask 授权类型推导（E3/簇 A 配置化）：接入 TYPE_HINTS（内置表含 git 类）+ 配置层 typeHints 扩展共同生效。
+ *  多类型命中按具体类优先序取（delete/backup/git/network/archive/skill > write > command > analysis）；无命中 → any（保守）。
+ *  原硬编码 write/command 两正则废弃——与 hints 表漂移（"提交/覆盖"等中文词误映射）的风险源。 */
+const ASK_SCOPE_PRIORITY = ["delete", "backup", "git", "archive", "skill", "write", "command", "network", "analysis"];
 export function classifyAskScopeType(text) {
   const s = String(text || "");
-  const hasWrite = /(?:修改|编辑|写入|覆盖|保存|删除|丢弃|移除|移动|改名|创建|新建|上传|复制|下载到|发布|推送|提交|写文件)/i.test(s);
-  const hasCommand = /(?:pwsh|powershell|命令|脚本|执行|运行|诊断|排查|体检)/i.test(s);
-  if (hasWrite && !hasCommand) return "write";
-  if (hasCommand && !hasWrite) return "command";
-  // 同时含/都不含 → any（保守；不含时 TTL 短）
-  return "any";
+  const hints = currentHints();
+  const hits = [];
+  for (const h of hints) if (h.re.test(s)) hits.push(h.type);
+  if (hits.length === 0) return "any";
+  for (const t of ASK_SCOPE_PRIORITY) if (hits.includes(t)) return t;
+  return hits[0];
 }
 
 /** 从文本推断全部命中的操作类型（用于一条子句含多个操作，如“修改 A 并删除 B”） */
 export function inferTypesFromText(text) {
   const s = String(text || "");
   const types = [];
-  for (const hint of TYPE_HINTS) {
+  for (const hint of currentHints()) {
     if (hint.re.test(s)) types.push(hint.type);
   }
   return types.length ? [...new Set(types)] : ["any"];
@@ -101,8 +156,8 @@ export function inferTypesFromText(text) {
 /**
  * 从文本提取路径候选（批次 4 统一入口：pairActionScopes 与 inferPathPrefixesFromText 共用）。
  * 处理两类噪声：
- *  1. 前缀冗余：引号路径同时命中两分支 → 截断前缀（如 "d:/deepseek"）被更长匹配覆盖 → 丢弃；
- *  2. 截断可疑：裸含空格路径（无引号）只能提取到空格前的半截（"D:\workspace\docs\..." → "d:/workspace"）
+ *  1. 前缀冗余：引号路径同时命中两分支 → 截断前缀（如 "d:/example"）被更长匹配覆盖 → 丢弃；
+ *  2. 截断可疑：裸含空格路径（无引号）只能提取到空格前的半截（"D:\\workspace\docs\..." → "d:/workspace"）
  *     ——匹配后紧跟空白且后随 token 是路径字符开头且非盘符/引号 → 判定为截断 → 丢弃（fail-closed：
  *     宁缺授权，拦截后请用户给完整/引号路径，也不把半截前缀当成授权）。
  * @returns {Array<{index:number,path:string}>} 去噪后的候选（保留原文索引供就近配对）

package/lib/core/contract.js

@@ -38,7 +38,7 @@ export function categoryOfCommand(command) {
   if (/remove-item|\brm(?:dir)?\b|del(?:ete)?\b|move-item|\bmv\b|rename-item|\bren\b|clear-content|clean|purge|rm\s+-/.test(s)) return "delete";
   if (/install|add\s+--save|pnpm\s+add|npm\s+install|yarn\s+add/.test(s)) return "install";
   if (/build|tsc|tsdown|vite\s+build|webpack|rollup|compile|bundle/.test(s)) return "build";
-  if (/test|jest|vitest|playwright|npm\s+test|pnpm\s+test|check-plugin-load|verify/.test(s)) return "test";
+  if (/test|jest|vitest|playwright|npm\s+test|pnpm\s+test|verify/.test(s)) return "test";
   if (/audit|mount|consistency|dump-config|inspect/.test(s)) return "audit";
   if (/analyze|analysis|review|read|grep|search/.test(s)) return "analyze";
   return null;

package/lib/core/guard-core.js

@@ -8,9 +8,7 @@ import {
   DESTRUCTIVE_CMD,
   DSH_KEYWORDS_RE,
   INLINE_CMD,
-  MANUAL_PATH_RE,
   PROTECTED_FILENAME_RE,
-  SKILL_EXEMPT,
   commandText,
   isAssemblyMutationTool,
   isBackupTool,
@@ -27,6 +25,7 @@ import {
   isAnalysisOp,
   isAnalysisScratchPath,
   extractAnalysisScratchPaths,
+  matchManualPath,
   pathTarget
 } from "./patterns.js";
 import { authMatches, describeAuth, describeOp, describeScopes, findMatchingAuth, operationOf, askQuestionText, inferPathPrefixFromText, inferTypeFromText, scopesFromIntents } from "./authorization.js";
@@ -75,11 +74,11 @@ const RULE_HINTS = {
   "9": "改用脚本文件或显式 UTF-8 BOM 流程",
   "12A": "先 ask_user_question 获取匹配授权",
   "13A": "先对目标路径执行备份（复制到 .bak/.backups/trash-）",
-  "18": "先读取 ~/.dsh/skills/dsh-usage-manual/SKILL.md",
+  "18": "先读取本机配置的手册（路径经 localIntegrations 配置；未配置则该规则无对象）",
   "21": "按规则 21 分级确认后再落盘",
   "22": "先回答/展示方案，或补充明确执行分点（工具类别+路径范围）；已授权变更必须落在本回合执行分点/ask 授权范围内",
   "24": "确认插件 dsh.bundle 类型或改用正确挂载",
-  "27": "先运行 node scripts/audit-mount-consistency.mjs --profile web"
+  "27": "先运行 node scripts/audit-mount-consistency.mjs --profile <p>"
 };
 
 // 0.5.12（F3）：拒绝来源前缀——机器可解析 token 化（/guard log 可按来源 grep 过滤）
@@ -128,9 +127,30 @@ 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);
+/** 判定命令是否"整条命令仅调用统一入口脚本"（无 ; | & 链式/换行/重定向）
+ *  N1（2026-09-04 P2）：排除向文件的重定向（> / >> / &> / fd>file）——`入口 status x > AGENTS.md` 不再被豁免；
+ *    仅保留 fd→fd 复制（2>&1 / 1>&2）。
+ *  G1（2026-09-04 P2）：引号感知——引号内的换行/;|& 视为合法参数内容（上会话曾误拦合法多行参数）。
+ *  entryMarker：统一入口脚本名（来自 localIntegrations.entryScript；无配置 = 不存在"统一入口"概念）。 */
+function isEntryChannelCommand(cmd, entryMarker) {
+  if (typeof cmd !== "string") return false;
+  if (!entryMarker) return false; // 无配置 = 无对象，自然静默
+  const c = cmd.trim();
+  if (!c.includes(entryMarker)) return false;
+  // ① 链式分隔（引号感知）：引号外的 ; | & 换行 → 非法
+  let inQ = null;
+  for (let i = 0; i < c.length; i++) {
+    const ch = c[i];
+    if (inQ) { if (ch === inQ) inQ = null; continue; }
+    if (ch === '"' || ch === "'") { inQ = ch; continue; }
+    if (ch === ";" || ch === "|" || ch === "&" || ch === "\n") return false;
+  }
+  // ② 重定向：摘除 fd 复制（N>&M / N<&M）后，任何 > / >> / &> 均非法（N1——含数字前置 2>/1> 盲区）
+  //  2026-09-06 0.6.x 修复：引号感知——参数值内的 >（如 markdown 引用符/⟨⟩ 占位）不再误判重定向
+  const noFd = c.replace(/\d*\s*[<>]&\s*\d+/g, "");
+  const noQuoted = noFd.replace(/"[^"]*"|'[^']*'/g, "");
+  if (/>>|&>|(?:^|[^<])>/.test(noQuoted)) return false;
+  return true;
 }
 
 /** 计算 edit/write/str_replace 后的目标文件内容；无法可靠计算时返回 null */
@@ -312,17 +332,21 @@ export function guardDecision(state, exec, now = Date.now(), opts = {}) {
   }
 
   // 阶段 C：硬拦 pwsh/bash 绕过统一入口直接写受保护文件（规则 19⑧/21⑨ 的机器执行层）
-  // 合法通道 = 整条命令仅调用 dsh-manual-write.mjs（无 ; | & 链式/换行，防注释文本伪造放行）
-  // 0.5.10：写类判定改 isMutationCommand（单真源）——修复 `Write-Output` 被 `write` 子串误杀（WGO654/ES3VCD 同类）
+  // 合法通道 = 整条命令仅调用统一入口脚本（无 ; | & 链式/换行，防注释文本伪造放行）
+  // A2-2（0.6.0）：无 localIntegrations.entryScript 配置 = 守卫无对象（不激活）；protectedFiles 为通用基线之上的本机追加清单
   if (!unlock && (name === "pwsh" || name === "bash")) {
     const cmd = commandText(args) || "";
-    if (cmd && isMutationCommand(cmd) && PROTECTED_FILENAME_RE.test(cmd)) {
-      if (!isEntryChannelCommand(cmd)) {
+    const entryMarker = state.localIntegrations?.entryScript;
+    if (entryMarker && cmd && isMutationCommand(cmd) && (PROTECTED_FILENAME_RE.test(cmd) || matchManualPath(cmd, state.localIntegrations?.protectedFiles || []))) {
+      if (!isEntryChannelCommand(cmd, entryMarker)) {
         return makeHit(
           { ruleId: "__self-protect", title: "受保护文件禁止绕过统一入口直写", action: "deny" },
-          `【硬拦截】受保护文件禁止通过 pwsh/bash 绕过统一入口直写；请使用 scripts/dsh-manual-write.mjs（整个命令只能调用该脚本，不得链式拼接其他写命令；或 /guard unlock 临时放行）。`
+          `【硬拦截】受保护文件禁止通过 pwsh/bash 绕过统一入口直写；请使用 ${entryMarker}（整个命令只能调用该脚本，不得链式拼接其他写命令/重定向；或 /guard unlock 临时放行）。`
         );
       }
+    } else if (!entryMarker && cmd && isMutationCommand(cmd) && (PROTECTED_FILENAME_RE.test(cmd) || matchManualPath(cmd, state.localIntegrations?.protectedFiles || []))) {
+      // A2-2（0.6.0）：无 entryScript 配置 = 守卫无对象——登记 skipped 审计（验证"默认无"的留痕；不拦截）
+      opts?.audit?.({ kind: "li-skipped", rule: "19", name: "本地集成未配置（守卫无对象）", event: "tool/guard", reason: "skipped: no localIntegrations.entryScript——该守卫在此环境不存在（0.6.0 默认无）", session: sessionIdOf(exec) });
     }
   }
 
@@ -514,17 +538,17 @@ function matchRule(cfg, ctx) {
   if (cfg.handler === "rule18-manual-first") {
     const userText = session.turn.userText || session.lastUserText || "";
     const firstTool = session.turn.toolCount === 0;
-    if (firstTool && !session.manualReadSeen && DSH_KEYWORDS_RE.test(userText) && !isManualReadTool(name, args)) {
-      return makeHit(cfg, "【硬拦截】任务涉及 DSH，首次工具调用前需先 grep/read 手册（~/.dsh/skills/dsh-usage-manual/SKILL.md）");
+    if (firstTool && !session.manualReadSeen && DSH_KEYWORDS_RE.test(userText) && !isManualReadTool(name, args, state.localIntegrations?.manualExempt?.paths || [])) {
+      return makeHit(cfg, "【硬拦截】任务涉及 DSH，首次工具调用前需先 grep/read 本机手册（路径经 localIntegrations 配置）");
     }
     return null;
   }
 
   // 规则 13A：删除/覆盖/高风险写前需有“目标路径对应备份”证据
   if (cfg.handler === "rule13a-backup") {
-    // 统一入口命令豁免：dsh-manual-write.mjs 每次写入前自身执行备份（backup() 保留 5 份），
+    // 统一入口命令豁免：入口脚本每次写入前自身执行备份（backup() 保留 5 份），
     // 引擎静态扫描看不到脚本内部动作（已知盲区）；入口命令也已被 __self-protect 限定为唯一写通道。
-    if ((name === "pwsh" || name === "bash") && isEntryChannelCommand(cmd)) return null;
+    if ((name === "pwsh" || name === "bash") && isEntryChannelCommand(cmd, state.localIntegrations?.entryScript)) return null;
     const destructive = (name === "pwsh" || name === "bash") && cmd && (DESTRUCTIVE_CMD.test(cmd) || (isSensitiveToolCall(name, args, sessionIdOf(exec)) && !/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;
@@ -567,7 +591,7 @@ function matchRule(cfg, ctx) {
   if (cfg.handler === "rule12b-skill") {
     if (name === "skill") {
       const skillName = typeof args?.name === "string" ? args.name : "";
-      if (SKILL_EXEMPT.has(skillName)) return null;
+      if ((state.localIntegrations?.manualExempt?.skills || []).includes(skillName)) return null;
       // 技能目录实时联动：已加载目录且该技能不存在/被禁用时，规则不激活
       if (state.skillNames && state.skillNames.size > 0 && !state.skillNames.has(skillName)) return null;
       if (denyMutation) {
@@ -587,7 +611,7 @@ function matchRule(cfg, ctx) {
   if ((cfg.hints || []).includes("skill") && name === "skill") {
     // hints 兜底：理解器未分配 handler 但 hints 含 skill 的 cfg——仅 skill 工具时参与，不截胡其它规则
     const skillName = typeof args?.name === "string" ? args.name : "";
-    if (SKILL_EXEMPT.has(skillName)) return null;
+    if ((state.localIntegrations?.manualExempt?.skills || []).includes(skillName)) return null;
     if (state.skillNames && state.skillNames.size > 0 && !state.skillNames.has(skillName)) return null;
     const op = { type: "skill", pathPrefix: "" };
     const auth = findMatchingAuth([...(session.authorizations || []), ...(state.globalAuthorizations || [])], op);
@@ -616,8 +640,8 @@ function matchRule(cfg, ctx) {
         audit?.({ kind: "allow", rule: cfg.ruleId, name: "低风险新建豁免（12A 判据同源）", tool: name, reason: `工作区内低风险新建（12A 判据同源）：${describeOp(operationOf(name, args))}`, session: sessionIdOf(exec) });
         return null;
       }
-      // 规则 19：dsh-usage-manual/SKILL.md 正文更新免逐次确认（仅手册本身）
-      if (p && MANUAL_PATH_RE.test(p)) return null;
+      // 规则 19：本机手册正文更新免逐次确认（仅手册本身；路径经配置）
+      if (p && (matchManualPath(p, state.localIntegrations?.manualExempt?.paths))) return null;
       // /guard unlock 本身即用户对受保护配置的授权
       if (unlock && isProtectedConfigPath(p)) return null;
       const op = operationOf(name, args);
@@ -704,11 +728,11 @@ function matchRule(cfg, ctx) {
   if (hints.includes("bom-write") && (name === "pwsh" || name === "bash") && cmd && BOM_WRITE.test(cmd)) {
     return makeHit(cfg, `【硬拦截】${cfg.title}`);
   }
-  if (hints.includes("manual") && session.turn.toolCount === 0 && !session.manualReadSeen && !isManualReadTool(name, args)) {
+  if (hints.includes("manual") && session.turn.toolCount === 0 && !session.manualReadSeen && !isManualReadTool(name, args, state.localIntegrations?.manualExempt?.paths || [])) {
     return makeHit(cfg, `【硬拦截】${cfg.title}`);
   }
   if (hints.includes("sensitive") && isSensitiveToolCall(name, args, sessionIdOf(exec))) {
-    if (p && MANUAL_PATH_RE.test(p)) return null;
+    if (p && (matchManualPath(p, state.localIntegrations?.manualExempt?.paths))) return null;
     if (unlock && isProtectedConfigPath(p)) return null;
     const op = operationOf(name, args);
     if (denyMutation) {