dsh-rule-engine 0.5.16 → 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/llm-intent.js

@@ -143,6 +143,7 @@ function auditIntent(state, sid, text, verdict, ms, limitHit) {
         ? `词表低置信 → LLM:${JSON.stringify(verdict)}（延迟 ${ms}ms${limitHit ? " 限额" : ""}）`
         : `词表低置信 → LLM 失败降级（延迟 ${ms}ms）`,
       session: sid,
+      verdictSource: verdict ? "llm-intent" : "lexicon",
       text: String(text).slice(0, 120)
     });
   } catch {

package/lib/core/patterns.js

@@ -28,12 +28,18 @@ export const PROTECTED_FILENAME_RE =
 export const DATA_DIR_RE =
   /(?:^|[\\/])\.dsh[\\/](?:sessions|storages|\.backups)[\\/]/i;
 
+/** 当下时间词（规则 2①：写当下相对时间前必须先 Get-Date 核对——A1 拆组，2026-09-03） */
 export const TIME_WORDS =
-  /今天|昨天|前天|上周|本周|刚才|\d+\s*分钟前|\d{1,2}\s*月\s*\d{1,2}\s*日|\d{4}\s*年\s*\d{1,2}\s*月\s*\d{1,2}\s*日/;
+  /今天|昨天|前天|上周|本周|刚才|\d+\s*分钟前/;
 
-/** 事件时间证据标注（规则 2②：过去事件时间必须绑定事件自身证据；"之前/当时"等模糊词不触发检测、不采信） */
+/** 历史日期/绝对日期（规则 2②：只要求事件证据锚，不要求 Get-Date——A1 拆组；含 ISO 格式，本机高频表述） */
+export const HISTORIC_DATE_RE =
+  /\d{1,2}\s*月\s*\d{1,2}\s*日|\d{4}\s*年\s*\d{1,2}\s*月\s*\d{1,2}\s*日|20\d{2}[-/.]\d{1,2}[-/.]\d{1,2}/;
+
+/** 事件时间证据标注（规则 2②：过去事件时间必须绑定事件自身证据；"之前/当时"等模糊词不触发检测、不采信）
+ *  A1 增补证据锚（2026-09-03）：commit hash / 版本号 / 踩坑 N / 版本记录 vX —— 历史日期带锚即视为已标注来源，免 Get-Date */
 export const EVIDENCE_MARK_RE =
-  /日志\s*(?:ts|时间戳)|mtime|启动时间|进程\s*StartTime|文件\s*修改时间|来源[:：]|ts\s*[:＝]|Get-Date\s*输出|事件时间已核实|【时间未核实】/i;
+  /日志\s*(?:ts|时间戳)|mtime|启动时间|进程\s*StartTime|文件\s*修改时间|来源[:：]|ts\s*[:＝]|Get-Date\s*输出|事件时间已核实|【时间未核实】|\b[0-9a-f]{7,40}\b|\bv\d+(?:\.\d+){1,2}\b|踩坑\s*\d+|版本(?:记录)?\s*v\d+(?:\.\d+){1,2}/i;
 
 export const PROMISE_WORDS =
   /包在我身上|肯定能|绝对没问题|保证(?!不|无法)|一定可以|放心(?:，|,)?肯定|万无一失/;
@@ -48,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;
 }
@@ -246,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 = [
@@ -587,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

@@ -5,6 +5,7 @@ import {
   PROMISE_WORDS,
   SOURCE_MARK,
   TIME_WORDS,
+  HISTORIC_DATE_RE,
   EVIDENCE_MARK_RE,
   URL_RE,
   TECH_TERM_RE,
@@ -107,8 +108,13 @@ export function isSelfCertified(text, ruleId) {
  * @returns {Array<{ruleId,title,kind,reason}>}
  */
 export function detectTimeRule(session, text, timeCfg) {
-  if (!timeCfg || !TIME_WORDS.test(text) || isQuoteOrParaphraseContext(text, TIME_WORDS)) return [];
-  if (!session?.turn?.getDateSeen) {
+  const hasNow = TIME_WORDS.test(text);
+  const hasHist = HISTORIC_DATE_RE.test(text);
+  if (!timeCfg || (!hasNow && !hasHist)) return [];
+  if (isQuoteOrParaphraseContext(text, TIME_WORDS) || isQuoteOrParaphraseContext(text, HISTORIC_DATE_RE)) return [];
+  // A1（2026-09-03 拆组）：当下时间词才要求 Get-Date 核对（①）；历史日期只走证据锚（②），
+  // 不再要求 Get-Date——消除"引用历史日期必判未核对"的误报（规则 2②：每时间点绑定自己证据）。
+  if (hasNow && !session?.turn?.getDateSeen) {
     return [{
       ruleId: "2",
       title: timeCfg.title,
@@ -116,12 +122,12 @@ export function detectTimeRule(session, text, timeCfg) {
       reason: "回答出现具体时间词/日期，但本回合未先调用 Get-Date 核对"
     }];
   }
-  if (!EVIDENCE_MARK_RE.test(text)) {
+  if ((hasNow || hasHist) && !EVIDENCE_MARK_RE.test(text)) {
     return [{
       ruleId: "2",
       title: timeCfg.title,
       kind: "correct",
-      reason: "回答含具体时间词但未附事件证据标注（日志 ts/文件 mtime/进程启动时间等）——Get-Date 当前时间不算过去事件证据（规则 2②）。正确动作：查该事件证据补（来源：…）或删时间词/标【时间未核实】，勿以当前时间替代"
+      reason: "回答含具体时间词/日期但未附事件证据标注（日志 ts/文件 mtime/进程启动时间/commit 锚/版本行/踩坑 N 等）——Get-Date 当前时间不算过去事件证据（规则 2②）。正确动作：查该事件证据补（来源：…）或删时间词/标【时间未核实】，勿以当前时间替代"
     }];
   }
   return [];
@@ -138,30 +144,31 @@ 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]));
 
   const timeCfg = byId.get("2");
   // v0.5.11（用户定稿）：① 只命中具体时间词（TIME_WORDS 为具体词表——"之前/当时"等模糊词不命中，不新增）；
   // ② 具体时间词 + 无事件证据标注（日志 ts/文件 mtime/进程启动时间等）→ 违规，Get-Date 当前时间不算事件证据。
+  // A1（2026-09-03）：时间词拆组——当下词（TIME_WORDS）才要求 Get-Date①；历史日期（HISTORIC_DATE_RE）只查证据锚②。
   // F1（2026-08-28 阶段三）：本检测仅作"判定"，投递时机由调用方在 turn/end 复核（见 detectTimeRule 注释）。
   // B3（2026-08-29）：引述/转述语境的时间词不触发（"你昨天说…"是转述，不是我的时间表述）；
   // 第一人称"我说昨天…"仍触发（转述不了自己）。
-  if (timeCfg && TIME_WORDS.test(text) && !isQuoteOrParaphraseContext(text, TIME_WORDS)) {
-    if (!session.turn.getDateSeen) {
+  if (timeCfg && (TIME_WORDS.test(text) || HISTORIC_DATE_RE.test(text)) && !isQuoteOrParaphraseContext(text, TIME_WORDS) && !isQuoteOrParaphraseContext(text, HISTORIC_DATE_RE)) {
+    if (!session.turn.getDateSeen && TIME_WORDS.test(text)) {
       hits.push({
         ruleId: "2",
         title: timeCfg.title,
         kind: "correct",
         reason: "回答出现具体时间词/日期，但本回合未先调用 Get-Date 核对"
       });
-    } else if (TIME_WORDS.test(text) && !EVIDENCE_MARK_RE.test(text)) {
+    } else if (!EVIDENCE_MARK_RE.test(text)) {
       hits.push({
         ruleId: "2",
         title: timeCfg.title,
         kind: "correct",
-        reason: "回答含具体时间词但未附事件证据标注（日志 ts/文件 mtime/进程启动时间等）——Get-Date 当前时间不算过去事件证据（规则 2②）"
+        reason: "回答含具体时间词/日期但未附事件证据标注（日志 ts/文件 mtime/进程启动时间/commit 锚/版本行/踩坑 N 等）——Get-Date 当前时间不算过去事件证据（规则 2②）"
       });
     }
   }
@@ -188,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——请标注手册位置或删去断言`
         });
       }
     }