dsh-rule-engine 0.5.4 → 0.5.6

package/lib/core/llm-intent.js

@@ -0,0 +1,148 @@
+// llm-intent.js - LLM 用户消息意图兜底（方案 A，v0.5.5 规划，2026-08-24）。
+// 原则：
+//   - 词表是主裁决器（快/免费/可测试/可复现）；LLM 只补低置信/歧义/未命中边缘；
+//   - 非对称：LLM 只在词表判“拦”时参与解救（hasExecute → 放行）；词表判“放行”时永不收紧（防软化）；
+//   - 失败/未就绪/超时/限额一律保守：维持词表裁决（拦截方向不变）；
+//   - 全程审计：谁判的（词表/LLM）、置信、延迟。
+// 纯依赖注入 ctx.llm；复用 llm-understander.js 的 resolveRoute/callLlm/parseJsonOutput。
+import { createHash } from "node:crypto";
+import { parseUserIntents, shouldDenyMutation } from "./intent.js";
+import { resolveRoute, callLlm } from "./llm-understander.js";
+import { audit } from "./audit.js";
+
+const LLM_PROMPT = [
+  "你是 DSH 规则引擎的意图判定器。输出严格 JSON，不要输出其他内容：",
+  '{"hasExecute":bool,"hasPlan":bool,"hasQuestion":bool,"ambiguous":bool,"reason":"一句话","confidence":0-1}',
+  "规则：hasExecute=消息含明确执行指令（动作词+非疑问句）；hasQuestion=含疑问/征询；hasPlan=要方案/评估/设计；ambiguous=同一消息内标签或语气冲突（如【执行】标签+疑问正文）；confidence=你的把握。",
+  "待判定用户消息：{{TEXT}}"
+].join("\n");
+
+const cacheKey = (text) => "intent:" + createHash("sha256").update(String(text), "utf8").digest("hex");
+
+/** 是否需要 LLM 兜底（仅词表低置信且非确定性分类的消息） */
+export function needsLlmEnrich(intents) {
+  if (!intents) return false;
+  if (intents.confidence === "high") return false;
+  // status/execute/plan 均为确定性分类，不走 LLM：
+  // plan（要方案）绝不因 LLM 误判 execute 而变成执行授权（安全方向，防误放行）
+  if (intents.hasStatus || intents.hasExecute || intents.hasPlan) return false;
+  return true;
+}
+
+/**
+ * 同步三级裁决（守卫路径调用，纯函数）：
+ * - 词表放行 → 维持放行（LLM 不收紧，非对称）
+ * - 词表判拦 + turn.llmIntent.raw 匹配当前 userText 且 verdict.hasExecute 且 !ambiguous：
+ *     confidence >= high → LLM 放行（来源 llm-high）
+ *     confidence >= low  → LLM 放行（来源 llm-low，reason 标注低置信）
+ *     否则 → 词表拦截
+ * - 无 LLM 结果/raw 不匹配 → 词表拦截（保守）
+ */
+export function verdictForDeny(turn, cfg = {}, lexiconDenied = true) {
+  if (!lexiconDenied) return { mutationDenied: false, source: "lexicon", reason: "词表放行" };
+  const high = cfg.thresholdHigh ?? 0.8;
+  const low = cfg.thresholdLow ?? 0.5;
+  const llm = turn?.llmIntent;
+  if (llm && llm.raw === turn?.userText && llm.verdict?.hasExecute && !llm.verdict.ambiguous) {
+    const conf = Number(llm.verdict.confidence) || 0;
+    if (conf >= high) return { mutationDenied: false, source: "llm-high", reason: `LLM 高置信(${conf})` };
+    if (conf >= low) return { mutationDenied: false, source: "llm-low", reason: `LLM 低置信(${conf})` };
+  }
+  return { mutationDenied: true, source: "lexicon", reason: "" };
+}
+
+/**
+ * 异步预取：对低置信消息调用一次 LLM，结果写入 turn.llmIntent。
+ * 不进同步守卫路径；失败/超时/限额仅审计并保留词表裁决。
+ * @param {object} ctx Cordis ctx（需 llm 服务）
+ * @param {object} state 引擎运行时状态
+ * @param {string} sid 会话 id
+ * @param {string} text 用户消息文本
+ * @param {object} cfg llmIntent 配置段（config.js DEFAULT_CONFIG.llmIntent）
+ */
+export async function enrichIntentWithLlm(ctx, state, sid, text, cfg) {
+  if (!ctx?.llm || !cfg?.enabled) return;
+  const intents = parseUserIntents(text);
+  if (!needsLlmEnrich(intents)) return;
+  const session = state.sessions.get(sid);
+  if (!session) return;
+  session.turn.intentState = "llm-pending";
+  const key = cacheKey(text);
+  if (!state.llmIntentCache) state.llmIntentCache = new Map();
+  const cached = state.llmIntentCache.get(key);
+  if (cached) {
+    session.turn.llmIntent = { raw: text, verdict: cached, at: Date.now(), ms: 0 };
+    session.turn.intentState = "llm-ready";
+    state.llmIntentHits = (state.llmIntentHits || 0) + 1;
+    return;
+  }
+  if (!state.llmIntentBudget) state.llmIntentBudget = new Map();
+  const used = state.llmIntentBudget.get(sid) || 0;
+  if (used >= (cfg.dailyLimitPerSession ?? 50)) {
+    session.turn.intentState = "lexicon";
+    return; // 超限降级词表
+  }
+  state.llmIntentBudget.set(sid, used + 1);
+  const started = Date.now();
+  try {
+    const route = await resolveRoute(ctx);
+    if (!route) throw new Error("no llm route");
+    const userText = String(text).slice(0, 2000);
+    const messages = [
+      { role: "user", content: [{ type: "text", text: LLM_PROMPT.replace("{{TEXT}}", userText) }] }
+    ];
+    const out = await callLlm(ctx, route, { ruleId: "__intent", title: "LLM 意图判定", body: messages[0].content[0].text });
+    if (!out) throw new Error("llm parse fail");
+    const verdict = {
+      hasExecute: Boolean(out.hasExecute),
+      hasPlan: Boolean(out.hasPlan),
+      hasQuestion: Boolean(out.hasQuestion),
+      ambiguous: Boolean(out.ambiguous),
+      reason: String(out.reason || "").slice(0, 120),
+      confidence: Number(out.confidence) || 0
+    };
+    const ms = Date.now() - started;
+    session.turn.llmIntent = { raw: text, verdict, at: Date.now(), ms };
+    session.turn.intentState = "llm-ready";
+    state.llmIntentCache.set(key, verdict);
+    const maxCache = cfg.cacheSize ?? 500;
+    while (state.llmIntentCache.size > maxCache) {
+      const firstKey = state.llmIntentCache.keys().next().value;
+      if (firstKey === undefined) break;
+      state.llmIntentCache.delete(firstKey);
+    }
+    auditIntent(state, sid, text, verdict, ms, false);
+  } catch {
+    session.turn.intentState = "lexicon";
+    auditIntent(state, sid, text, null, Date.now() - started, false);
+  }
+}
+
+function auditIntent(state, sid, text, verdict, ms, limitHit) {
+  try {
+    state.llmIntentLast = {
+      text: String(text).slice(0, 60),
+      verdict: verdict ? { ...verdict, confidence: Number(verdict.confidence) } : null,
+      source: verdict ? "llm" : "fail",
+      at: Date.now()
+    };
+    audit({
+      kind: "intent-llm",
+      rule: "__intent-llm",
+      name: "LLM 意图判定",
+      event: "user/message",
+      reason: verdict
+        ? `词表低置信 → LLM:${JSON.stringify(verdict)}（延迟 ${ms}ms${limitHit ? " 限额" : ""}）`
+        : `词表低置信 → LLM 失败降级（延迟 ${ms}ms）`,
+      session: sid,
+      text: String(text).slice(0, 120)
+    });
+  } catch {
+    // 审计失败不阻断预取
+  }
+}
+
+/** 供测试：needsLlmEnrich 与 verdictForDeny 的纯函数路径（不依赖 ctx） */
+export function shouldDenyWithLlm(turn, cfg, lexiconDenied) {
+  return verdictForDeny(turn, cfg, lexiconDenied);
+}

package/lib/core/llm-understander.js

@@ -2,7 +2,7 @@
 // 对非 high 置信规则调用 ctx.llm 做结构化理解；失败/不可用时回退模式库。
 // 纯依赖注入 ctx.llm，不 import 官方包。
 
-async function resolveRoute(ctx) {
+export async function resolveRoute(ctx) {
   if (!ctx?.llm) return null;
   try {
     const providers = ctx.llm.listProviders?.() || [];
@@ -46,7 +46,7 @@ function parseJsonOutput(text) {
   }
 }
 
-async function callLlm(ctx, route, rule) {
+export async function callLlm(ctx, route, rule) {
   const messages = [
     {
       role: "user",

package/lib/core/overengineering.js

@@ -18,8 +18,9 @@ export function detectHashIntent(toolName, args) {
   const name = String(toolName || "");
   const cmd = commandText(args) || "";
   if (name === "pwsh" || name === "bash") return HASH_RE.test(cmd);
-  const text = JSON.stringify(args || {});
-  return HASH_RE.test(text);
+  // 批次 4：只对命令类字段判定——写入类工具内容含命令字样 ≠ 相关操作（参数全文匹配导致 hash=deny 误拦一切含字样的写入）
+  const cmdish = ["script", "query", "sql", "code"].map((k) => (typeof args?.[k] === "string" ? args[k] : "")).join("\n");
+  return HASH_RE.test(cmdish);
 }
 
 /** 是否命中“添加依赖”类动作 */
@@ -27,8 +28,9 @@ export function detectDependencyIntent(toolName, args) {
   const name = String(toolName || "");
   const cmd = commandText(args) || "";
   if (name === "pwsh" || name === "bash") return DEPENDENCY_RE.test(cmd);
-  const text = JSON.stringify(args || {});
-  return DEPENDENCY_RE.test(text);
+  // 批次 4：只对命令类字段判定（同上：写入内容含依赖安装字样 ≠ 添加依赖动作）
+  const cmdish = ["script", "query", "sql", "code"].map((k) => (typeof args?.[k] === "string" ? args[k] : "")).join("\n");
+  return DEPENDENCY_RE.test(cmdish);
 }
 
 /** 粗分类一次工具调用的可变更性 */

package/lib/core/paths.js

@@ -28,3 +28,8 @@ export function understandingFilePath() {
 export function disabledRulesFilePath() {
   return join(dshHome(), "disabled-rules.json");
 }
+
+/** 需求基线文件（需求覆盖校验机制，RB-09，2026-08-24） */
+export function baselineFilePath() {
+  return join(dshHome(), "rule-engine-baseline.json");
+}

package/lib/core/patterns.js

@@ -237,15 +237,29 @@ export function isGetDateCommand(command) {
 
 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|cat|type|dir|ls|grep|findstr|more|netstat|where)\b/i;
+  /(?:\b(?:Get-Content|Get-ChildItem|Get-Item|Get-Command|Get-Date|Select-String|Find-String|Test-Path|Get-Process|Get-Service|cat|type|dir|ls|grep|findstr|more|netstat|where|echo|Write-Output|Write-Host|Get-Location|pwd|cwd|Get-Help|help)\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|$))|(?:\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|Remove-Item|Move-Item|Copy-Item|Rename-Item|New-Item|Clear-Content|git\s+(?:push|commit)|rm\s+-r|rmdir\s+\/s|del\s+\/s|(?:^|[^0-9])>>|(?:^|[^0-9])>)/i;
 
-/** 判断命令文本是否只读（读文件/查询类，无写入/删除/提交副作用） */
+/** 只读命令链按分隔符折段（机制 B，2026-08-24）：`; 换行 && || |`（管道前后是命令链；`2>&1`/`2>$null` 的 stderr 重定向不拆分） */
+function splitCommandSegments(command) {
+  return String(command)
+    .split(/\r?\n|;|&&|\|\||(?<!\d)\|/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/** 判断命令文本是否只读（读文件/查询类，无写入/删除/提交副作用）。
+ *  2026-08-24 分段化：整条命令按 ; | & 换行拆段，每段都必须只读——
+ *  修复 "git -C <dir> status" 变体不匹配、"git status; echo ok" 链式被误判为写 的实测缺陷。 */
 export function isReadOnlyCommand(command) {
   if (typeof command !== "string") return false;
-  if (MUTATING_CMD_RE.test(command)) return false;
-  return READONLY_CMD_RE.test(command);
+  const segments = splitCommandSegments(command);
+  if (segments.length === 0) return false;
+  return segments.every((seg) => {
+    if (MUTATING_CMD_RE.test(seg)) return false;
+    return READONLY_CMD_RE.test(seg);
+  });
 }
 
 /** 判断一次工具调用是否只读（必须无条件放行） */
@@ -259,6 +273,31 @@ export function isReadOnlyTool(toolName, args) {
   return false;
 }
 
+/**
+ * node -e 内联代码的危险特征判定（机制批 M4：diag-run 受控诊断工具使用）。
+ * 黑名单命中任一 = 判定有写/网络/进程副作用（保守：宁可拒）。规则 9 正文不动（A2=B 方案）。
+ */
+const DANGEROUS_INLINE_NODE_RE =
+  /(?:fs\.|\bwriteFile(?:Sync)?\b|\bappendFile(?:Sync)?\b|\bcreateWriteStream\b|\bunlink(?:Sync)?\b|\brm(?:Sync)?\b|\bcopyFile(?:Sync)?\b|\brename(?:Sync)?\b|\bmkdir(?:Sync)?\b|\brmdir(?:Sync)?\b|\bchild_process\b|\bexec(?:Sync)?\b|\bspawn\b|\bfetch\s*\(|\bhttps?\.|\bnet\.|\bcreateServer\b|\brequire\s*\(\s*["']fs|from\s+["']node:fs|from\s+["']node:child_process|process\.env(?:\.[A-Za-z_][A-Za-z0-9_]*)?\s*=)/i;
+/** 供 diag-run 及其测试使用：true = 判定有副作用（应拒绝执行） */
+export function isDangerousInlineNode(code) {
+  return DANGEROUS_INLINE_NODE_RE.test(String(code || ""));
+}
+
+/**
+ * 落盘授权粒度提醒（机制批 M7，2026-08-24，用户确认）：
+ * 方案性指令（调整/补充/评估/建议/草案……）不构成"落盘/发布"授权（规则 22 自证③）。
+ * true = 用户消息更像"要方案"而非"授权落盘"——此时对受保护文件统一入口调用应记 approval-gap 提醒。
+ * 保守：含落盘性词（落盘/写入/发布/改为……）→ false（不提醒）。
+ */
+const PLAN_INSTRUCTION_RE = /方案|调整|补充|建议|评估|草案|完善|优化|改进|提炼|重构|梳理/;
+const WRITE_INSTRUCTION_RE = /落盘|写入|发布|正式写入|正式落盘|改为|改成|保存到手册|写进手册|确定为|确认后(?:落盘|写入|发布)/;
+export function needsApprovalReminder(userText) {
+  const t = String(userText || "");
+  if (!t) return false;
+  return PLAN_INSTRUCTION_RE.test(t) && !WRITE_INSTRUCTION_RE.test(t);
+}
+
 let workspaceRootOverride = "";
 
 /** 由插件 apply 阶段从 workspaceRegistry 设置工作区根目录 */
@@ -395,3 +434,16 @@ export function isSensitiveToolCall(toolName, args) {
   if (GENERIC_EXEC_TOOLS.has(name)) return true;
   return false;
 }
+
+// ── 批次 5 文本健康检测词表（2026-08-24） ──────────────────────────────
+/** 技术术语（规则 11③ 零基础表达：中文提问 + 术语 + 无解释 → 自证）。英文词带 \b，中文词组按字面。 */
+export const TECH_TERM_RE =
+  /\b(?:API|JSON|REST|WebSocket|OAuth|JWT|ORM|Schema|SSR|CSR|DI|Docker|Kubernetes|K8s|npm|pnpm|Node\.js|TypeScript|Git)\b|正则(?:表达|表达式)?|异步|回调|闭包|哈希|令牌|中间件|依赖注入|虚拟DOM|虚拟 DOM|数据库|SQL|序列化|反序列化|面向对象|函数式|类型推断|泛型/i;
+
+/** 术语解释伴随词（出现任一 → 视为已解释，不触发密度自证） */
+export const TERM_EXPLANATION_RE =
+  /例如|比如|即\b|就是|简单说|换言之|类比|也就是说|通俗|直白|理解为|打个比方|举个例子/;
+
+/** 建议类表述（规则 16 重复推销：会话内同类建议 ≥2 → 自证） */
+export const SUGGEST_RE =
+  /我建议|建议用|推荐|更优方案|建议(?:是|考虑|换成|用|来)|档位建议|不如换|优化建议/;

package/lib/core/state.js

@@ -6,7 +6,7 @@ import { agentsFilePath, disabledRulesFilePath } from "./paths.js";
 import { understandAll } from "./understander.js";
 import { writeUnderstanding } from "./understanding-store.js";
 import { AUTH_TTL_MS } from "./authorization.js";
-import { defaultContract } from "./contract.js";
+import { initSessionContract } from "./contract.js";
 
 const MAX_SESSIONS = 200;
 const MAX_RETRY_KEYS = 500;
@@ -41,7 +41,15 @@ export function createState() {
       askEnabled: false,
       taskContractMode: "observe"
     },
-    labels: new Map()
+    labels: new Map(),
+    askRejections: [], // { sessionId, at }（ask 被拒记录，弹窗消减/节流）
+    llmIntentCache: new Map(), // sha256(text) → verdict（LRU 上限 cfg.cacheSize）
+    llmIntentBudget: new Map(), // sessionId → 当日调用数（上限 cfg.dailyLimitPerSession）
+    llmIntentHits: 0, // LLM 缓存命中计数（/guard status 观测）
+    llmIntentLast: null, // { text, verdict, at }（最近一次 LLM 采用/失败，/guard status 观测）
+    verifyPass: [], // { at, sessionId, what }（测试通过/冷加载探针输出采集，交付闸门 M3 用）
+    deniedKeys: new Set(), // 引擎 deny 的调用 key（规则 1 计数解耦）
+    unknownToolApproved: new Set() // 机制 B：已 ask 过的未归类工具（本会话内批准后不再重复询问）
   };
 }
 
@@ -104,6 +112,7 @@ export function getSessionState(state, sessionId) {
   if (!s) {
     s = {
       id: key,
+      ruleStats: {}, // C2：每规则 detected/suppressed/injected 统计（会话级，跨回合累计）
       manualReadSeen: false,
       lastUserText: "",
       selfCertCount: new Map(),
@@ -114,7 +123,10 @@ export function getSessionState(state, sessionId) {
       lastCommandOutput: "",
       lastSeen: Date.now(),
       turn: freshTurn(),
-      contract: { ...defaultContract(), ...(state.taskContract?.defaults || {}) },
+      // 批次 4（阶段 3 默认武装）：global 会话自身不继承（防循环）；其他会话继承 global 模板（/guard 命令写入）
+      contract: key === "global"
+        ? initSessionContract(state.taskContract, null)
+        : initSessionContract(state.taskContract, getSessionState(state, "global").contract),
       recentActions: []
     };
     state.sessions.set(key, s);
@@ -123,7 +135,11 @@ export function getSessionState(state, sessionId) {
   return s;
 }
 
-/** 记录一条授权证据（结构化：type/pathPrefix/at/source/expiresAt）。同时写入全局池，便于子代理/跨会话工具调用复用。 */
+/**
+ * 记录一条授权证据（结构化：type/pathPrefix/at/source/expiresAt）。
+ * 2026-08-24（R1 统一授权存储）：自动来源（执行分点/用户消息/ask）**绝不同步进 globalAuthorizations**——
+ * 全局池仅显式白名单可写（recordGlobalAuth），杜绝"一个会话的授权被其它会话复用"与 revoke 残留。
+ */
 export function recordAuthorization(state, sessionId, auth) {
   const record = {
     at: Date.now(),
@@ -133,10 +149,37 @@ export function recordAuthorization(state, sessionId, auth) {
   };
   const s = getSessionState(state, sessionId);
   s.authorizations.push(record);
-  state.globalAuthorizations.push(record);
   return s.authorizations;
 }
 
+/**
+ * 显式白名单授权（用户明确选择"记住此授权"时写入；当前无 UI 入口，结构预留）。
+ * 这是 globalAuthorizations 的唯一写入通道。
+ */
+export function recordGlobalAuth(state, sessionId, auth) {
+  const list = recordAuthorization(state, sessionId, auth);
+  const record = list[list.length - 1];
+  state.globalAuthorizations.push(record);
+  return list;
+}
+
+/**
+ * revoke 全清（R1.3，2026-08-24）：session.authorizations + turn.scopes + globalAuthorizations + askRejections。
+ * @returns {number} 清理的授权/范围条目数（供审计描述）
+ */
+export function clearAuthorizations(state) {
+  let count = 0;
+  for (const s of state.sessions.values()) {
+    count += (s.authorizations || []).length + ((s.turn && s.turn.scopes) ? s.turn.scopes.length : 0);
+    s.authorizations = [];
+    if (s.turn) s.turn.scopes = [];
+  }
+  count += (state.globalAuthorizations || []).length;
+  state.globalAuthorizations = [];
+  if (Array.isArray(state.askRejections)) state.askRejections = [];
+  return count;
+}
+
 /** 记录一条备份证据（目标路径 → 备份路径） */
 export function recordBackup(state, sessionId, targetPath, backupPath) {
   const s = getSessionState(state, sessionId);
@@ -164,7 +207,11 @@ export function freshTurn() {
     number: 0,
     userText: "",
     askSeen: false,
+    askRejected: false, // 本回合 ask 已被拒（防连环 ask，弹窗消减）
     questionOnly: false,
+    intents: null,
+    intentState: "lexicon", // lexicon | llm-pending | llm-ready（LLM 意图兜底状态）
+    llmIntent: null, // { raw, verdict, reason, confidence, at }（LLM 裁决，非高置信时词表兜底）
     pendingAsk: null,
     pendingToolCalls: new Map(),
     getDateSeen: false,
@@ -174,7 +221,12 @@ export function freshTurn() {
     skillNames: [],
     toolNames: [],
     commands: [],
-    reasoningText: ""
+    reasoningText: "",
+    // 规则 22 粒度升级（2026-08-24）：本回合已获授权范围（execute 子句 + ask 授权）
+    scopes: [],
+    // M8 双通道机制（2026-08-24）：dsh-manual-write 落盘后同轮 engram_store 校验
+    manualWriteSeen: false,
+    engramStoreSeen: false
   };
 }
 
@@ -182,7 +234,9 @@ export function resetTurn(state, sessionId, turnNumber) {
   const s = getSessionState(state, sessionId);
   s.turn = freshTurn();
   s.turn.number = typeof turnNumber === "number" ? turnNumber : 0;
-  s.turn.userText = s.lastUserText || "";
+  // 2026-08-24（事故复盘 P0-3 根修）：不再继承上一轮 lastUserText——
+  // 上一轮若为询问（含“为什么”等）会把旧意图带进新回合导致误拦；
+  // turn.userText 只由真实的 user/message 事件写入；无消息回合不做规则 22 判定（12A/13A 仍把关）。
   return s.turn;
 }
 

package/lib/core/text-detect.js

@@ -5,7 +5,10 @@ import {
   PROMISE_WORDS,
   SOURCE_MARK,
   TIME_WORDS,
-  URL_RE
+  URL_RE,
+  TECH_TERM_RE,
+  TERM_EXPLANATION_RE,
+  SUGGEST_RE
 } from "./patterns.js";
 import { detectOverengineeringText } from "./overengineering.js";
 
@@ -27,7 +30,6 @@ const SELF_CERT_HINTS = {
   "14": { re: /总结|汇报|完成/, reason: "请按规则 14 一次性完整汇报，区分事实与推断" },
   "22": { re: /我记下了|记住了|收到，我记下了|放心，我记住了/i, reason: "检测到「我记下了」类空话；正确动作是落盘执行并汇报" },
   "23": { re: /完成|交付/, reason: "交付/完成声明未附运行时验证证据" },
-  "6": { re: /(?:API|JSON|正则|异步|依赖注入|回调|schema|DI)/i, reason: "请按规则 6 用零基础用户能懂的语言解释" },
   "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" },
@@ -49,6 +51,20 @@ function isMostlyEnglish(text) {
   return letters > 30 && cjk === 0;
 }
 
+/**
+ * 注入噪音治理 v0.5.6（建议2/3 已自证抑制）：同一条回复中已含"规则 X 已按/已自证/已核对…"标记时，
+ * 该规则本轮不再计为新违规——打断"自证回复复述触发词 → 再次注入"的自循环。
+ * 仅对 kind=self-certify 的 D 级自证命中生效；B 级纠察（kind=correct）不受影响（审计优先）。
+ */
+export function isSelfCertified(text, ruleId) {
+  if (!text || !ruleId) return false;
+  const id = String(ruleId).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const tail = "(?:已按|已按要求|已自证|已核对|已核实|核实通过|合规|已满足|已一次性说明|已合并提出|已回应|已实施|已落地)";
+  const suffix = "(?:[①②③④⑤⑥⑦⑧⑨⑩]|\\.\\d+|\\d+)?";
+  const re = new RegExp(`(?:规则\\s*${id}${suffix}\\s*${tail}|${tail}\\s*规则\\s*${id}${suffix})`);
+  return re.test(text);
+}
+
 /**
  * 检测一次 assistant/message 的 B/D 级违规。
  * @param {object} options
@@ -105,6 +121,32 @@ export function detectViolations({ configs, session, text, reasoningText = "", m
     });
   }
 
+  // 批次 5：术语密度（规则 11③——零基础表达：中文提问 + 术语 + 无解释伴随 → 自证）
+  const termCfg = byId.get("11");
+  if (termCfg && session.lastUserText && CJK_RE.test(session.lastUserText) && TECH_TERM_RE.test(text) && !TERM_EXPLANATION_RE.test(text)) {
+    hits.push({
+      ruleId: "11",
+      title: termCfg.title,
+      kind: "self-certify",
+      reason: "规则 11③：回答含技术术语且未用零基础语言解释（请用类比/日常语言说明，或标注术语含义）"
+    });
+  }
+
+  // 批次 5：重复推销（规则 16——会话内同类建议 ≥2 次 → 自证，防反复推销）
+  const suggestCfg = byId.get("16");
+  if (suggestCfg && SUGGEST_RE.test(text)) {
+    session.suggestionCounts = session.suggestionCounts || {};
+    session.suggestionCounts.general = (session.suggestionCounts.general || 0) + 1;
+    if (session.suggestionCounts.general >= 2) {
+      hits.push({
+        ruleId: "16",
+        title: suggestCfg.title,
+        kind: "self-certify",
+        reason: "规则 16：检测到重复建议（同类建议在会话内再次提出）——请确认必要性并避免反复推销；已并入同一框架请说明"
+      });
+    }
+  }
+
   const directCfg = byId.get("22");
   if (directCfg && /我记下了|记住了|收到，我记下了|放心，我记住了/i.test(text)) {
     hits.push({
@@ -195,5 +237,21 @@ export function detectViolations({ configs, session, text, reasoningText = "", m
     });
   }
 
-  return hits;
+  // C2 统计：命中（detected）计数——在抑制过滤前逐条累计
+  for (const h of hits) {
+    const st = (session.ruleStats ||= {});
+    const k = (st[h.ruleId] ||= { detected: 0, suppressed: 0, injected: 0 });
+    k.detected++;
+  }
+  // 注入噪音治理 v0.5.6（建议2/3）：已自证标记（"规则 X 已按/已自证/已核对…"）→ 该规则本轮不计新违规
+  const kept = hits.filter((h) => h.kind !== "self-certify" || !isSelfCertified(text, h.ruleId));
+  // C2 统计：被抑制（suppressed）计数
+  for (const h of hits) {
+    if (!kept.includes(h)) {
+      const st = session.ruleStats || {};
+      const k = st[h.ruleId];
+      if (k) k.suppressed++;
+    }
+  }
+  return kept;
 }

package/lib/core/tool-catalog.js

@@ -0,0 +1,85 @@
+// tool-catalog.js - 工具分类制（机制 B，2026-08-24）
+// 任何插件（现有/未来）注册的工具都按此分类：
+//   analysis  = 只读分析（无条件放行）
+//   artifact  = 写产物（低风险：放行 + 审计留痕；受保护路径仍由 13A/__self-protect 把关）
+//   mutating  = 变更类（维持现有严格授权：规则 22 粒度 / 12A / 13A）
+//   unknown   = 未归类（guard 不物理拦；由 index.js 的 pre-execute deny 层首调拦截，
+//                批次 3：ask 被 approval 层自动放行 → 改 deny，用户"允许使用 X"白名放行）
+// 设计原则：
+//   1. 不依赖 ctx.tools 运行时 API（纯静态表 + 命令文本分析，可独立测试）；
+//   2. 方向性修正：旧逻辑"按参数名猜写不写、猜不出就放行"（反向漏洞）→
+//      "未知默认 ask"（fail-closed，用户 2026-08-24 确认）；
+//   3. 分类表随实测/新插件逐步扩充（机制允许快速扩展，无需改逻辑）。
+import { isReadOnlyTool } from "./patterns.js";
+
+// 只读分析类：无任何文件副作用（或仅有会话内状态），无条件放行
+const ANALYSIS_TOOLS = new Set([
+  "read", "grep", "glob", "read_image",
+  // 视觉分析类（纯看图，无文件副作用）
+  "vision_describe", "vision_detect", "vision_ground", "vision_colors", "vision_ocr", "vision_bootstrap",
+  // 查询/状态类（工具自身状态，无持久副作用）
+  "job_list", "job_output", "list_agents", "get_goal", "schedule_list",
+  "dev_plugin_status", "dev_injected_list", "dev_stage_list", "dev_self_test",
+  "engram_recall", "engram_detail", "engram_model",
+  // 官方只读联网工具（@deepseek-ai/dsh-tool-web 家族，2026-08-25 补）：只读抓取/搜索，无文件副作用；
+  // 公网访问由 12C 的 B 级留痕与 D⑤ 边界继续把关（回环/内网/SSRF 防护不因分类豁免）
+  "web_fetch", "web_search",
+  // 子代理交付工具（官方 dsh-tool-subagent-report，2026-08-24 实测发现）：仅子代理环境注册，
+  // 参数仅 output 文本 → 直接交付父代理，无文件副作用 → analysis（避免子代理交付被 unknown deny 阻断）
+  "report"
+]);
+
+// 产物类：工具自然行为会写文件（artifact/工作区/会话存储），低风险——放行 + 审计。
+// 若写目标命中受保护路径/工作区外，仍由 __self-protect / 13A / 12A 独立把关（不因分类而豁免）。
+const ARTIFACT_TOOLS = new Set([
+  // 视觉产物类（裁剪/截图/长图 OCR/矢量化/抠图/物化/展示 → 写 artifact）
+  "vision_crop", "vision_pixel_diff", "vision_trace", "vision_extract_foreground",
+  "vision_html_screenshot", "vision_long_screenshot_ocr", "vision_materialize", "vision_present",
+  // 记忆/日程（写引擎存储，低风险）
+  "engram_store", "schedule_create", "schedule_delete",
+  // 开发侧 staging（写 staging 区，dev_* 工具的自然行为）
+  "dev_stage_add", "dev_stage_call", "dev_stage_promote", "dev_stage_demote"
+]);
+
+// 变更类：维持现有严格授权（规则 22 粒度比对 / 12A 敏感授权 / 13A 备份）
+const MUTATING_TOOLS = new Set([
+  "edit", "write", "str_replace_editor", "pwsh", "bash",
+  // 插件装配类（规则 24/27 管辖）
+  "dev_install_package", "dev_inject_plugin", "dev_uninject_plugin", "dev_reload_package",
+  "dev_fix_patch", "dev_heal_links",
+  // 提交/网络写类由命令文本与 12C 管辖，此处不重复枚举
+  "upload_file"
+]);
+
+/**
+ * 工具分类判定（纯函数）。
+ * @param {string} name 工具名
+ * @param {object} args 工具参数（pwsh/bash 需要命令文本判读写）
+ * @returns {'analysis'|'artifact'|'mutating'|'unknown'}
+ */
+export function toolClass(name, args = {}) {
+  const n = String(name || "");
+  if (n === "pwsh" || n === "bash") {
+    return isReadOnlyTool(n, args) ? "analysis" : "mutating";
+  }
+  if (ANALYSIS_TOOLS.has(n)) return "analysis";
+  if (ARTIFACT_TOOLS.has(n)) return "artifact";
+  if (MUTATING_TOOLS.has(n)) return "mutating";
+  return "unknown";
+}
+
+/**
+ * unknown 工具的处置决策（pre-execute 层调用）。
+ * 批次 3（2026-08-24，用户拍板分支 A）：ask → deny——实测 DSH approval 层自动放行 ask
+ *（guardian ask 与 unknown 首调均无弹窗直接执行 = fail-open 洞），未知工具首调必须物理拦截；
+ * 批准路径 = 用户明确"允许使用 X"（handleSessionEvent 写入会话白名）；白名后本会话放行。
+ * @param {string} name 工具名
+ * @param {object} args 工具参数
+ * @param {Set<string>|null} whitelist 会话内已批准工具集（可选）
+ * @returns {'deny'|null} unknown 且未白名 → 'deny'；已知分类或已白名 → null
+ */
+export function unknownToolDecision(name, args = {}, whitelist = null) {
+  if (toolClass(name, args) !== "unknown") return null;
+  if (whitelist && whitelist.has(name)) return null;
+  return "deny";
+}

package/lib/core/understander.js

@@ -25,7 +25,7 @@ const HANDLER_BY_RULE = {
   "12B": "rule12b-skill",
   "12C": "rule12c-network",
   "13A": "rule13a-backup",
-  "13B": "rule13b-session",
+  // 13B 已于 2026-08-24 外移至手册（规则正文删除，映射一并清理，防死映射）
   14: "rule14-report",
   18: "rule18-manual-first",
   21: "rule21-meta",