dsh-rule-engine 0.5.17 → 0.6.0

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";
@@ -92,7 +143,7 @@ export function classifyAskScopeType(text) {
 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 +152,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,28 @@ 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> 盲区）
+  const noFd = c.replace(/\d*\s*[<>]&\s*\d+/g, "");
+  if (/>>|&>|(?:^|[^<])>/.test(noFd)) return false;
+  return true;
 }
 
 /** 计算 edit/write/str_replace 后的目标文件内容；无法可靠计算时返回 null */
@@ -312,17 +330,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 +536,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 +589,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 +609,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 +638,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 +726,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) {

package/lib/core/patterns.js

@@ -54,34 +54,41 @@ export const SOURCE_MARK = /来源|出处|via|source|reference|引自|参考/i;
 
 export const CJK_RE = /[\u4e00-\u9fff]/;
 
-export const MANUAL_PATH_RE = /dsh-usage-manual[\\/]SKILL\.md/i;
-
 export const DSH_KEYWORDS_RE =
   /DSH|dsh|插件|技能|规则|配置|迁移|手册|会话|装配|profile|bundle/i;
 
-export const SKILL_EXEMPT = new Set(["dsh-usage-manual", "task-planner"]);
-
 export const SELF_PROTECT_PATHS = [
   "**/rule-engine.json",
   "**/rule-understanding.json",
   "**/rule-guard.json"
 ];
 
-/** 判断一条命令文本是否是「读取手册」类命令 */
-export function isManualReadCommand(command) {
+/** 判断一条命令文本是否是「读取手册」类命令（manualPaths = 本机配置的手册路径列表；无配置 = 无对象，恒 false） */
+export function isManualReadCommand(command, manualPaths = []) {
   if (typeof command !== "string") return false;
-  return MANUAL_PATH_RE.test(command) && /get-content|cat|type|read|grep|findstr|str_replace_editor/i.test(command);
+  if (!Array.isArray(manualPaths)) return false;
+  const hit = manualPaths.some((pp) => command.toLowerCase().includes(String(pp).toLowerCase()));
+  return hit && /get-content|cat|type|read|grep|findstr|str_replace_editor/i.test(command);
+}
+
+/** 本机追加文件路径匹配（A2-2 算法）：相对 DSH_HOME 归一化 + 大小写不敏感 + 包含比较。
+ *  manualPaths 为空 = 无本机配置 = 恒 false（守卫无对象，自然静默）。 */
+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))));
 }
 
-/** 判断一次工具调用是否算作「已读手册」 */
-export function isManualReadTool(toolName, args) {
+/** 判断一次工具调用是否算作「已读手册」（manualPaths = 本机配置的手册路径列表；无配置 = 无对象，恒 false） */
+export function isManualReadTool(toolName, args, manualPaths = []) {
   const name = String(toolName || "");
   if (name === "read" || name === "grep" || name === "str_replace_editor") {
     const p = String(args?.file_path || args?.path || args?.pattern || "");
-    if (MANUAL_PATH_RE.test(p)) return true;
+    if (isManualReadCommand(p, manualPaths)) return true;
   }
   if (name === "pwsh" || name === "bash") {
-    return isManualReadCommand(args?.command || args?.code || "");
+    return isManualReadCommand(args?.command || args?.code || "", manualPaths);
   }
   return false;
 }
@@ -252,7 +259,7 @@ const READ_ONLY_TOOLS = new Set(["read", "grep", "glob", "read_image"]);
 const READONLY_CMD_RE =
   /(?:\b(?:Get-Content|Get-ChildItem|Get-Item|Get-Command|Get-Date|Select-String|Find-String|Test-Path|Get-Process|Get-Service|Get-ItemProperty|Get-Variable|Get-FileHash|cat|type|dir|ls|grep|findstr|more|netstat|where|echo|Write-Output|Write-Host|Get-Location|pwd|cwd|Get-Help|help|Select-Object|Out-String|Format-Table|Format-List|Format-Wide|Measure-Object|Sort-Object|Where-Object|Group-Object|ForEach-Object|Out-Null|ConvertTo-Json|ConvertFrom-Json|Join-Path|Split-Path|Resolve-Path|New-Object|Add-Type|Get-Member|Get-ChildItemProperty|Get-CimInstance|Get-WmiObject)\b)|(?:\bgit\s+(?:-[^\s]+\s+[^\s]+\s+|--[^\s]+\s+)*\b(?:status|log|diff|show|branch|tag|remote|rev-parse|diff-tree|ls-files)(?:\s|$))|(?:\bdsh\s+(?:--version|--help|--dump-config|plugin\s+(?:list|show|status))(?:\s|$))|(?:\bdsh\s+--profile\s+[^\s]+\s+(?:--dump-config|plugin\s+(?:list|show|status))(?:\s|$))|(?:\bnode\s+(?:--check|--test|--version)(?:\s|$))|(?:\bnpm\s+(?:test|run\s+test)(?:\s|$))|(?:\bpnpm\s+(?:test|run\s+test)(?:\s|$))|(?:\bgh\s+(?:auth\s+status|repo\s+view)(?:\s|$))|(?:\bnpm\s+(?:ls|view)(?:\s|$))/i;
 const MUTATING_CMD_RE =
-  /(?:Set-Content|Add-Content|Out-File|Tee-Object|Remove-Item|Move-Item|Copy-Item|Rename-Item|New-Item|Clear-Content|Start-Process|Invoke-Expression|Invoke-Item|Export-Csv|Export-Clixml|Export-ModuleMember|Compress-Archive|Expand-Archive|Add-Type\s+-Output(?:Assembly|Type)|git\s+(?:push|commit)|rm\s+-r|rmdir\s+\/s|del\s+\/s|(?:^|[^0-9])>>|(?:^|[^0-9])>|(?:curl|wget|iwr|Invoke-WebRequest|Invoke-RestMethod)\s+(?=[^\n;|]*\s(?:-o|--output|-OutFile|OutFile)\s))/i;
+  /(?:Set-Content|Add-Content|Out-File|Tee-Object|Remove-Item|Move-Item|Copy-Item|Rename-Item|New-Item|Clear-Content|Start-Process|Invoke-Expression|Invoke-Item|Export-Csv|Export-Clixml|Export-ModuleMember|Compress-Archive|Expand-Archive|Add-Type\s+-Output(?:Assembly|Type)|git\s+(?:push|commit)|rm\s+-r|rmdir\s+\/s|del\s+\/s|(?:^|[^0-9])(?:\d*>|\d*>>|>|>>)(?!\s*&\s*\d|\s*\$?(?:null|nul)\b)|(?:curl|wget|iwr|Invoke-WebRequest|Invoke-RestMethod)\s+(?=[^\n;|]*\s(?:-o|--output|-OutFile|OutFile)\s))/i;
 // 0.5.12（F4）：PowerShell 别名展开表——写/删除/移动/执行别名 → 标准 cmdlet 名
 // 供 normalizeAliases 做命令规范化（MUTATING_CMD_RE 覆盖完整 cmdlet；别名先展开再判）
 const PS_ALIAS_MAP = [
@@ -593,7 +600,7 @@ export function isAuditCommand(command) {
  */
 export function isVerificationCommand(command) {
   if (typeof command !== "string") return false;
-  if (/\b(?:node|npm|npx)\s+[^\n]*(?:run-all\.mjs|check-plugin-load\.mjs|audit-mount-consistency\.mjs|loader-smoke\.e2e\.mjs|verify-all\.mjs|health-audit\.mjs|check-tool-coverage\.mjs|publish-aptitude-check\.mjs|\.test\.mjs\b|--check|--test|--dry-run)\b/i.test(command)) return true;
+  if (/\b(?:node|npm|npx)\s+[^\n]*(?:run-all\.mjs|audit-mount-consistency\.mjs|loader-smoke\.e2e\.mjs|verify-all\.mjs|health-audit\.mjs|check-tool-coverage\.mjs|publish-aptitude-check\.mjs|\.test\.mjs\b|--check|--test|--dry-run)\b/i.test(command)) return true;
   if (/\b(?:npm|pnpm)\s+(?:test|run\s+test)\b/i.test(command)) return true;
   if (/\bgh\s+api\b/i.test(command)) {
     // 只读 GET 形态；写形态（--method/-X 显式方法、-F/--field 表单）不豁免（gg api 写=执行类）

package/lib/core/state.js

@@ -265,7 +265,7 @@ export function freshTurn() {
     reasoningText: "",
     // 规则 22 粒度升级（2026-08-24）：本回合已获授权范围（execute 子句 + ask 授权）
     scopes: [],
-    // M8 双通道机制（2026-08-24）：dsh-manual-write 落盘后同轮 engram_store 校验
+    // M8 双通道机制（2026-08-24）：统一入口落盘后同轮 engram_store 校验（entryMarker 经配置）
     manualWriteSeen: false,
     engramStoreSeen: false
   };

package/lib/core/text-detect.js

@@ -144,7 +144,7 @@ export function detectTimeRule(session, text, timeCfg) {
  * @param {string} options.text assistant 纯文本
  * @returns {Array<{ruleId:string,title:string,kind:string,reason:string}>}
  */
-export function detectViolations({ configs, session, text, reasoningText = "", mountRevision = 0 }) {
+export function detectViolations({ configs, session, text, reasoningText = "", mountRevision = 0, rule5Window = 3 }) {
   const hits = [];
   const byId = new Map(configs.filter((c) => c.confidence !== "low").map((c) => [String(c.ruleId), c]));
 
@@ -195,15 +195,16 @@ export function detectViolations({ configs, session, text, reasoningText = "", m
       });
     } else if (INTERNAL_REF_RE.test(text) && !isQuoteOrParaphraseContext(text, INTERNAL_REF_RE)) {
       // 规则 5 扩展（2026-09-01 用户拍板）：内部文档引用（手册/踩坑/条款/源码…）须有依据——
-      // 近 3 回合无对应 read/grep 时提示（B 级：留痕+注入，不拦截）。
+      // 近 rule5Window 回合（默认 3；配置层 rule-engine.json `rule5SourceWindow` 可覆盖，2026-09-03
+      // 通用化修正：本机偏好走配置、通用默认保持 3）无对应 read/grep 时提示（B 级：留痕+注入，不拦截）。
       const curTurn = session.turn.number || 0;
       const lastQuery = session.lastQueryTurn ?? -1;
-      if (lastQuery < 0 || curTurn - lastQuery > 3) {
+      if (lastQuery < 0 || curTurn - lastQuery > rule5Window) {
         hits.push({
           ruleId: "5",
           title: sourceCfg.title,
           kind: "correct",
-          reason: "回答引用内部文档（手册/踩坑/条款/源码等）但近 3 回合无对应 read/grep——请标注手册位置或删去断言"
+          reason: `回答引用内部文档（手册/踩坑/条款/源码等）但近 ${rule5Window} 回合无对应 read/grep——请标注手册位置或删去断言`
         });
       }
     }

package/lib/index.js

@@ -1,7 +1,7 @@
 // dsh-rule-engine —— DSH 规则执行引擎 v3（host 插件，纯 Node）
 // 容器：解析 AGENTS.md → 理解器 → 匹配机 → 执行框架。
 // 执行框架：ctx.tools.guard() 硬拦 + session/event 文本纠察 + 审计台账 + /guard 命令。
-import { readFileSync, watch, writeFileSync } from "node:fs";
+import { readFileSync, watch, writeFileSync, existsSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { audit, readAuditLog } from "./core/audit.js";
 import { loadPluginConfig } from "./core/config.js";
@@ -61,6 +61,7 @@ import {
 import { toolClass } from "./core/tool-catalog.js";
 import { parseWhitelist, mergeWhitelist, serializeWhitelist } from "./core/whitelist.js";
 import { state } from "./core/runtime.js";
+import { APPROVE_TYPES, normalizePath, setTypeHints } from "./core/authorization.js";
 import { DELIVERY_RE, detectViolations, extractAssistantText } from "./core/text-detect.js";
 import { buildTurnCard } from "./core/turn-card.js";
 import { shouldDetectTurn, shouldDeliver } from "./core/semantic.js";
@@ -101,6 +102,8 @@ export const name = "dsh-rule-engine";
 export const inject = ["tools", "commands", "agents", "workspaceRegistry", "skills", "llm"];
 
 const pluginConfig = loadPluginConfig();
+// C4：启动时合并配置层 typeHints（本机扩展授权类型；默认空=仅内置 8+archive 类）
+setTypeHints(pluginConfig.typeHints);
 state.enabled = pluginConfig.enabled;
 applyTaskContractConfig(state, pluginConfig);
 // T3 通用化（2026-08-31）：声明式绑定覆盖表注入（rule-engine.json 可选键 handlerOverrides；缺省 {}）
@@ -108,6 +111,44 @@ state.handlerOverrides = pluginConfig?.handlerOverrides || {};
 // 残余1 剥离（2026-08-31）：本机默认偏好表注入（rule-engine.json 可选键 handlerDefaultMap；
 // 通用部署=空表——代码零本机编号，本机偏好不随包走、升级不丢）
 state.handlerDefaultMap = pluginConfig?.handlerDefaultMap || {};
+// P2（2026-09-04）：本机集成参数化层（localIntegrations）——默认空=通用行为不变；
+// 本机专属约定（统一入口脚本名/M8 双通道/手册路径豁免扩展）由配置注入，代码零本机字面量
+state.localIntegrations = pluginConfig?.localIntegrations || {};
+// A-8（0.6.0，启动自检硬验收）：localIntegrations 存在但 entryScript 指向的脚本文件在磁盘不存在
+// → 启动即审计告警（失败不阻断加载，但留下可观测证据——无声守卫消失风险的对策）
+// 0.6.0 修正：裸文件名（无路径段）视为脚本名——可能在工作区/全局 PATH，
+// 不告警（防误报）；仅当 entryScript 含明确路径段（\ / 盘符）且文件不存在时才告警。
+{
+  const li = state.localIntegrations;
+  const script = li?.entryScript;
+  const isBareName = typeof script === "string" && /^[A-Za-z0-9._-]+$/.test(script.replace(/\\/g, "/"));
+  if (typeof script === "string" && script && !isBareName) {
+    let found = false;
+    try { found = existsSync(script); } catch { found = false; }
+    if (!found) {
+      audit({
+        kind: "entry-script-missing",
+        rule: "__entry-script-missing",
+        name: "启动自检：统一入口脚本不存在",
+        event: "startup",
+        reason: `localIntegrations.entryScript 指向的脚本（${script}）在磁盘不存在——本机守卫仍按配置工作，但入口通道可能失效；请检查配置或部署该脚本`,
+        session: "global"
+      });
+    }
+  }
+}
+// li-skipped（0.6.0 A2-2 补充）：无 localIntegrations.entryScript → 启动登记一次 skipped 审计
+// （验证"默认无"留痕；登录于启动/配置加载时，而非每次工具调用——修正此前写类分支被 12A 前置拦截的缺陷）
+if (!state.localIntegrations?.entryScript) {
+  audit({
+    kind: "li-skipped",
+    rule: "19",
+    name: "本地集成未配置（守卫无对象）",
+    event: "startup",
+    reason: "skipped: no localIntegrations.entryScript——该守卫在此环境不存在（0.6.0 默认无）",
+    session: "global"
+  });
+}
 // reloadRules 内部已统一刷新理解产物（P0-3），此处不再重复写
 reloadRules(state);
 
@@ -434,15 +475,18 @@ export function handleSessionEvent(ctx, session, event) {
     return;
   }
   if (event.type === "turn/end") {
-    // M8 双通道机制：本回合用 dsh-manual-write 落盘手册/AGENTS 后，必须同轮 engram_store 沉淀记忆；
+    // M8 双通道机制：本回合用统一入口落盘手册/AGENTS 后，必须同轮 engram_store 沉淀记忆；
     // 缺失 → 审计 + 注入纠正（用户明确要求机制化，2026-08-24）
-    if (s.turn.manualWriteSeen && !s.turn.engramStoreSeen) {
+    // A3-1（0.6.0）：默认关闭 → 显式 enabled:true + 配置 entryMarker 才生效（无配置 = M8 机制整体不存在）
+    const m8Cfg = state.localIntegrations?.m8 || {};
+    const m8Marker = m8Cfg.entryMarker;
+    if (m8Cfg.enabled === true && m8Marker && s.turn.manualWriteSeen && !s.turn.engramStoreSeen) {
       audit({
         kind: "engram-gap",
         rule: "__engram-gap",
         name: "双通道记忆缺失",
         event: "turn/end",
-        reason: "本回合 dsh-manual-write 落盘了手册/AGENTS，但未同轮调用 engram_store；按规则 19/77/M8 应在同一回合完成记忆沉淀",
+        reason: "本回合经本机配置的统一入口落盘了手册/AGENTS，但未同轮调用 engram_store；按规则 19/77/M8 应在同一回合完成记忆沉淀",
         session: sid
       });
       maybeInject(ctx, sid, {
@@ -659,7 +703,7 @@ export function handleSessionEvent(ctx, session, event) {
         pendingCall.backupPaths.push(bpTool);
       }
     }
-    if (isManualReadTool(toolName, args)) s.manualReadSeen = true;
+    if (isManualReadTool(toolName, args, state.localIntegrations?.manualExempt?.paths || [])) s.manualReadSeen = true;
     // 规则 5/31 扩展（2026-09-01）：查询类工具调用记下回合号（"近 3 回合有据"判定）
     if (isReadOnlyTool(toolName, args)) s.lastQueryTurn = s.turn.number;
     if (toolName === "skill" && args?.name) s.turn.skillNames.push(args.name);
@@ -772,10 +816,13 @@ export function handleSessionEvent(ctx, session, event) {
       }
     }
 
-    // M8 双通道机制（2026-08-24）：dsh-manual-write 落盘成功 → 标记；同轮 engram_store 成功 → 标记
+    // M8 双通道机制（2026-08-24）：统一入口落盘成功 → 标记；同轮 engram_store 成功 → 标记
+    // A3-1（0.6.0）：默认关闭 → 显式 enabled:true + 配置 entryMarker 才生效（无配置 = M8 机制整体不存在）
     if (!isError && pendingCall) {
       const cmd = pendingCall.args?.command || pendingCall.args?.code || "";
-      if ((pendingCall.name === "pwsh" || pendingCall.name === "bash") && /\bdsh-manual-write\.mjs/.test(cmd)) {
+      const m8Cfg2 = state.localIntegrations?.m8 || {};
+      const marker = m8Cfg2.entryMarker;
+      if (m8Cfg2.enabled === true && marker && (pendingCall.name === "pwsh" || pendingCall.name === "bash") && cmd.includes(marker)) {
         s.turn.manualWriteSeen = true;
       }
       if (pendingCall.name === "engram_store") {
@@ -1036,7 +1083,7 @@ export function handleSessionEvent(ctx, session, event) {
           rule: "23",
           name: "交付声明缺验证闸门记录",
           event: "assistant/message",
-          reason: "交付/完成类声明缺少同会话近期 verify-pass（ALL TESTS PASSED / check-plugin-load RESULT: PASS）记录",
+          reason: "交付/完成类声明缺少同会话近期 verify-pass（测试全绿或冷加载探针 RESULT: PASS）记录",
           session: sid
         });
         // v0.5.7 后续（用户拍板"暗示型统一裁决"）：23④ 词面命中只是嫌疑——"完成"≠交付声明
@@ -1081,7 +1128,7 @@ export function handleSessionEvent(ctx, session, event) {
       }
     }
     // F1（2026-08-28 阶段三）：规则 2 违规不在此时投递——标记 pendingRule2，turn/end 复核（Get-Date 定案）①
-    let violations = detectViolations({ configs: state.configs, session: s, text, reasoningText: s.turn.reasoningText, mountRevision: state.mountRevision });
+    let violations = detectViolations({ configs: state.configs, session: s, text, reasoningText: s.turn.reasoningText, mountRevision: state.mountRevision, rule5Window: pluginConfig.rule5SourceWindow ?? 3 });
     const rule2s = violations.filter((v) => v.ruleId === "2");
     for (const v of rule2s) {
       if (!s.turn.pendingRule2) s.turn.pendingRule2 = v.reason;
@@ -1148,7 +1195,8 @@ const COMMAND_SPECS = [
   { name: "budget", args: "...", desc: "设置预算（agents=N files=... deps=allow hash=allow）" },
   { name: "contract", args: "", desc: "查看当前任务契约" },
   { name: "contract categories", args: "...", desc: "设定契约类别白名单（0.5.12）" },
-  { name: "label", args: "<id> <label>", desc: "给审计记录打标（correct/incorrect/inconclusive）" }
+  { name: "label", args: "<id> <label>", desc: "给审计记录打标（correct/incorrect/inconclusive）" },
+  { name: "approve", args: "<type> <路径> [min]", desc: "物理确认：授予指定类型+路径的临时授权（仅用户输入；默认 10 分钟）" }
 ];
 
 const USAGE = [
@@ -1204,6 +1252,17 @@ function parseCommand(rawInput) {
   if (m) return { kind: "label", eventId: m[1], label: m[2].toLowerCase() };
   m = text.match(/^label\s+clear\s+(.+)$/i);
   if (m) return { kind: "label-clear", fingerprint: m[1].trim() };
+  // C4：/guard approve <type> <路径> [min]——物理确认（类型在 executeGuard 校验枚举）
+  m = text.match(/^approve\s+([A-Za-z_][A-Za-z0-9_-]*)\s*("(?:[^"]*)"|'(?:[^']*)'|\S+)(?:\s+(\d+))?$/i);
+  if (m) {
+    const p = m[2];
+    return {
+      kind: "approve",
+      type: m[1].toLowerCase(),
+      path: p.replace(/^["']|["']$/g, ""),
+      minutes: m[3] ? Number(m[3]) : 10
+    };
+  }
   return { kind: "invalid" };
 }
 
@@ -1281,6 +1340,30 @@ async function executeGuard(ctx, invocation) {
         text: `已临时放行全部守卫 ${minutes} 分钟。到期自动恢复，也可 /guard reload 后立即恢复。`
       };
     }
+    case "approve": {
+      // C4（2026-09-03）物理确认：用户亲手输入=词表无法误读；最小范围（类型+路径+时长）；无全局通配
+      if (!loadPluginConfig().approveEnabled) {
+        return { kind: "error", text: "/guard approve 未开启：请在 rule-engine.json 设 approveEnabled=true（设置页开关随后续版本）后使用" };
+      }
+      if (!APPROVE_TYPES().includes(command.type)) {
+        return { kind: "error", text: `不支持的类型 ${command.type}（可用：${APPROVE_TYPES().join("/")}；any=全局通配被禁止——物理确认必须最小范围）` };
+      }
+      if (!command.path) return { kind: "error", text: "路径缺失：/guard approve <type> <路径> [min]（建议路径用双引号包裹，如 /guard approve write \"D:\\...\\file.json\" 10）" };
+      const minutes = Math.min(Math.max(1, command.minutes), 720);
+      const pfx = normalizePath(command.path);
+      const sid = sessionIdOfInvocation(invocation);
+      recordAuthorization(state, sid, {
+        type: command.type,
+        pathPrefix: pfx,
+        source: "physical-confirm",
+        expiresAt: Date.now() + minutes * 60000
+      });
+      audit({ kind: "guard-command", rule: "__physical-confirm", name: "物理确认授权", event: "command", reason: `/guard approve ${command.type} ${pfx} ${minutes}m`, session: sid });
+      return {
+        kind: "success",
+        text: `已物理确认授权：${command.type}｜${pfx}｜${minutes} 分钟。仅该类型+该路径（含子路径）生效；/guard revoke 可立即撤销；到期自动失效。`
+      };
+    }
     case "lock": {
       state.unlockUntil = 0;
       state.bypassUntil = 0;
@@ -1554,7 +1637,10 @@ export function apply(ctx) {
         //（调整/补充/评估/建议且无落盘词）→ approval-gap 审计 + 注入提醒（规则 22 自证③：方案性指令 ≠ 落盘授权）
         {
           const cmd = exec?.arguments?.command || exec?.arguments?.code || "";
-          if ((exec?.name === "pwsh" || exec?.name === "bash") && /\bdsh-manual-write\.mjs/.test(cmd)) {
+          const entryScript = state.localIntegrations?.entryScript;
+          // A3-2（0.6.0）：入口脚本名从配置读取并转义；无配置不走本分支。
+          // 边界裁决（v1.3 关键裁决 4）：正则保持无尾部 \b（保守匹配，xxx.mjs.bak 等变体同样命中）。
+          if ((exec?.name === "pwsh" || exec?.name === "bash") && entryScript && new RegExp(`\\b${entryScript.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(cmd)) {
             const s7 = getSessionState(state, sessionIdOfExec(exec));
             if (needsApprovalReminder(s7.turn.userText || "")) {
               audit({

package/lib/service.js

@@ -204,7 +204,8 @@ class RuleEngineService extends TypertRemoteService {
           askEnabled: conf.askEnabled === true,
           taskContractMode: conf.taskContractMode === "armed" ? "armed" : "observe",
           taskContractDefaults: conf.taskContractDefaults || {},
-          turnCard: { enabled: conf.turnCard?.enabled === true }
+          turnCard: { enabled: conf.turnCard?.enabled === true },
+          approveEnabled: conf.approveEnabled === true
         }
       };
     } catch (error) {
@@ -215,6 +216,7 @@ class RuleEngineService extends TypertRemoteService {
   /** 保存任务契约配置（设置页；写入 rule-engine.json 并热同步 state） */
   async setTaskContractConfig(partial) {
     try {
+      audit({ kind: "guard-command", rule: "__settings-save", name: "设置页保存", event: "command", reason: `setTaskContractConfig keys=${JSON.stringify(Object.keys(partial || {}))}`, session: "global" });
       const conf = savePluginConfig(partial || {});
       applyTaskContractConfig(state, conf);
       return {
@@ -224,7 +226,8 @@ class RuleEngineService extends TypertRemoteService {
           askEnabled: conf.askEnabled === true,
           taskContractMode: conf.taskContractMode === "armed" ? "armed" : "observe",
           taskContractDefaults: conf.taskContractDefaults || {},
-          turnCard: { enabled: conf.turnCard?.enabled === true }
+          turnCard: { enabled: conf.turnCard?.enabled === true },
+          approveEnabled: conf.approveEnabled === true
         }
       };
     } catch (error) {