dsh-rule-engine 0.5.6 → 0.5.8

package/README.md

@@ -1,7 +1,12 @@
 # dsh-rule-engine
 
+![npm](https://img.shields.io/npm/v/dsh-rule-engine)
+![version](https://img.shields.io/badge/version-0.5.8-blue)
+
 DSH 规则执行引擎 v3 的插件实现。它把 `~/.dsh/AGENTS.md` 当作唯一真相源，自动解析规则四要素与执行等级，再通过「工具守卫 + 文本检测 + 时序检查 + 审计台账」执行用户规则，而不是内置一套与用户无关的安全清单。
 
+> 当前版本 **0.5.7**（2026-08-26 发布）。本插件面向"规则机器化执行"：规则写在 AGENTS.md 里，引擎负责让它们真的被遵守；所有规则动态解析，规则增删改后无需重写插件。
+
 ## 项目背景
 
 这个项目来自一个非常具体的个人需求：
@@ -22,6 +27,32 @@ DSH 规则执行引擎 v3 的插件实现。它把 `~/.dsh/AGENTS.md` 当作唯
 
 当前实现以「模式库兜底」为主，LLM 理解器预留扩展点；所有规则均从 AGENTS.md 实时解析。
 
+## 注入噪音治理（0.5.6 / 0.5.7）
+
+只提醒真正值得提醒的事——这条原则贯穿 0.5.6 与 0.5.7：
+
+- **0.5.6**：同一回复中多条违规 → 聚合为一条注入（明细全在 `/guard log`）；回复含「规则 X 已自证/已核对…」标记 → 该规则当轮不再重复触发；C2 规则统计（detected/suppressed/injected，`getRuleStats` 面板接口）。
+- **0.5.7（错误才值得被提醒）**：
+  1. **词表只产嫌疑**：语义型命中不再直接定罪，标记 `awaitingJudge` 送裁决；
+  2. **LLM 裁决**：给「规则正文 + 完整回复」判定是否真违规——合规声明/引述/非违规 → 不投递（`judge-false`）；仅裁决为违规才投递（`judge-pass`）；裁决不可用 → 不投递（**fail-closed**，`judge-unavailable`）。模型**追随会话模型**，`sha256` 缓存 + 每日 50 次/会话预算；
+  3. **注入轮不检测**：没有真实用户消息的回合（引擎注入触发的轮次）不做检测与投递——这是"引擎自己打乒乓"循环的根治（燃料=它对自身回声的检测）；
+  4. **投递资格闸**：同规则同会话仅提醒一次（记住已处理）；会话每小时至多 3 条弹窗；
+  5. **审计完整性**：嫌疑/裁决/拦截/投递全部写入 `/guard log`——"看了不冤枉"的凭据。
+
+## 质量与验证（2026-08-26，对齐官方 docs/testing.zh.md）
+
+- `npm run test`（全量单测；`test/run-all.mjs` 统一入口，注意 ESM 缓存顺序约定）；
+- `node scripts/verify-all.mjs` —— 交付前四层体检：语法（lib 全文件 `node --check`）→ 单元（run-all）→ **组合冒烟**（`test/loader-smoke.e2e.mjs`：真实引擎代码 + 真实审计文件，仅 mock LLM 边界，断言**外部世界**——审计文件里真的出现 judge-false/judge-pass 记录，而非自我报告）→ **真实判例**（近 24h 台账 judge-pass/false 记录数，0 条 = WARN 提示需实弹）；
+- `node scripts/health-audit.mjs` —— 找茬清单：近 24h 失败/降级类统计（intent-llm 失败、judge-unavailable、verify-gap、inject-skip…）+ 关键导出接线交叉（疑似未接线 = 告警）——"失败可见化"，不再有静默躺 20 小时的降级；
+- 执行协议（本仓库自身交付纪律）：方案冻结单（范围/影响面/测试计划/失败预测）→ todo 化 → 小步闭环（每改动立即 `node --check`）→ 对账交付（计划×实际逐项 ✅/❌/跳过原因）。
+
+## 0.5.8（2026-08-26 追加）
+
+- **白名单持久化**："允许使用 X"（未归类工具批准）落盘 `~/.dsh/rule-engine-tools.json`——此前为内存态，热重载/重启即清（用户需反复重发，实测 esr_task/esr_close 各被清一次）；
+- **只读命令词表补全**：`Select-Object / Out-String / Format-Table / Measure-Object / Sort-Object / Where-Object / Group-Object / Out-Null / ConvertTo-Json` 等常见只读 cmdlet 纳入只读判定（此前 `Get-Item | Select-Object` 被误判为变更拦截）——含"管道内含写操作仍判变更"的安全回归；
+- **`npm run verify`** 注册（= `scripts/verify-all.mjs` 四层体检别名）；
+- 工作区内低风险变更豁免（12A 正文对齐：只读诊断脚本不再被拦——0.5.7 的延续项）。
+
 ## 任务契约与反过度工程（可选）
 
 - 默认**关闭**；可在规则引擎设置页开启「任务边界与反过度工程」总开关。
@@ -88,6 +119,7 @@ dsh plugin --profile web add dsh-rule-engine
 - 技能目录实时联动：`ctx.skills` 目录变化后自动刷新，已禁用/不存在的技能不触发 12B
 - LLM 增量理解：对非 high 置信规则调用 `ctx.llm` 补全结构化理解，失败自动回退模式库；AGENTS.md 变化触发重载后会自动补一次增量理解（按规则+版本去重，不重复烧 token）
 - D 级自证泛化：按规则特征触发自证提示，每规则每会话限 3 次
+- D 级自证泛化（0.5.7 起取代上行语义）：词表只产嫌疑，LLM 裁决确认错误才提醒；同规则同会话仅提醒一次 + 会话每小时 3 条弹窗预算；无真实用户消息的回合不检测不投递（乒乓根治）
 - 授权记录默认 10 分钟 TTL，无路径的全局授权 TTL 缩短为 2 分钟；可用 `/guard revoke` 撤销
 - 用户直接命令式指令（如“删除这个文件”）也视为授权
 - 规则 1 支持“用户明确要求重试”豁免
@@ -116,6 +148,7 @@ dsh plugin --profile web add dsh-rule-engine
 
 5. **跨会话持久化**
    授权/备份目前为内存态，重启失效。持久化涉及写入保护、并发与恢复，风险较高，暂未实现。
+    注（0.5.7）：验证通过记录 verifyPass 已持久化（`~/.dsh/rule-engine-verify.json`，热重载/重启不丢）——规则 23④ 证据链；授权/备份仍为内存态。
 
 6. **输出文本实时拦截**
    受 DSH 官方架构限制，`assistant/message` 无法“拦下不发”，只能事后审计 + 纠正注入；这是平台边界，不是插件能单独突破的。
@@ -147,6 +180,10 @@ npm test
 bash scripts/build.sh
 ```
 
+交付前体检（0.5.7 起）：`node scripts/verify-all.mjs`（四层：语法/单元/组合冒烟/真实判例）与 `node scripts/health-audit.mjs`（找茬）——详见「质量与验证」。
+
+发布：`node ../../scripts/release-plugin.mjs <插件目录> <版本号>`（一键 npm + git + GitHub Release，见 `scripts/release-plugin.mjs` 注释）。
+
 ## License
 
 MIT

package/lib/core/guard-core.js

@@ -20,6 +20,8 @@ import {
   isReadOnlyTool,
   isSensitiveToolCall,
   isVariablePath,
+  isVerificationCommand,
+  isLowRiskWorkspaceNew,
   pathTarget
 } from "./patterns.js";
 import { authMatches, describeAuth, describeOp, describeScopes, findMatchingAuth, operationOf, askQuestionText, inferPathPrefixFromText, inferTypeFromText, scopesFromIntents } from "./authorization.js";
@@ -337,6 +339,12 @@ function matchRule(cfg, ctx) {
     }
     if (cls === "unknown") return null; // 物理不拦；pre-execute ask 层首调询问
     if (denyMutation) {
+      // v0.5.7 后续（用户拍板）：工作区内低风险变更豁免——12A 正文豁免的机器实现
+      //（只读诊断脚本被拦的最终修复：此前 --profile 模板/多根/验证伴生已修，本项补齐）
+      if (isLowRiskWorkspaceNew(name, args)) {
+        audit?.({ kind: "allow", rule: cfg.ruleId, name: "低风险新建豁免", tool: name, reason: `工作区内低风险变更（12A 正文豁免）：${describeOp(operationOf(name, args))}`, session: sessionIdOf(exec) });
+        return null;
+      }
       // LLM 意图兜底（方案 A，2026-08-24）：词表判拦 + LLM 高/低置信判 execute → 放行
       //（非对称：LLM 只解救不收紧；审计在预取时已记 intent-llm）
       const verdict = verdictForDeny(session.turn, state.llmIntentCfg || {});
@@ -353,6 +361,18 @@ function matchRule(cfg, ctx) {
     if (isReadOnlyTool(name, args)) return null;
     if (!COVERED_MUTATION_TOOLS.has(name) && !looksLikeFileMutation(name, args)) return null;
     const op = operationOf(name, args);
+    // v0.5.7 P0-1（用户拍板 2026-08-26）：验证类命令伴生放行——本回合已有 write/any/command
+    // 授权（用户已批"修改/执行"）时，运行测试/冷加载/审计/语法检查属于该变更的验证闭环，
+    // 不再被 write vs command 类型不匹配误拦（今天实弹连卡 4 次）。
+    if ((name === "pwsh" || name === "bash") && isVerificationCommand(cmd)) {
+      const verScopes = Array.isArray(session.turn.scopes) && session.turn.scopes.length > 0
+        ? session.turn.scopes
+        : scopesFromIntents(turnIntents);
+      if (verScopes.some((s) => s.type === "write" || s.type === "any" || s.type === "command")) {
+        audit?.({ kind: "allow", rule: cfg.ruleId, name: "验证命令伴生放行", tool: name, reason: `本回合已有 ${describeScopes(verScopes)} 授权 → 验证命令伴生（${describeOp(op)}）`, session: sessionIdOf(exec) });
+        return null;
+      }
+    }
     // 保护性备份豁免（2026-08-26，backup 口径修复）：规则 12A 豁免③ / 13A ⑦ 均豁免
     // 复制到 .backups/.bak 的保护性备份——与 13A 分支口径一致，backup 类型不再被 22 粒度误拦。
     if (op.type === "backup") return null;
@@ -411,7 +431,7 @@ function matchRule(cfg, ctx) {
     // 统一入口命令豁免：dsh-manual-write.mjs 每次写入前自身执行备份（backup() 保留 5 份），
     // 引擎静态扫描看不到脚本内部动作（已知盲区）；入口命令也已被 __self-protect 限定为唯一写通道。
     if ((name === "pwsh" || name === "bash") && isEntryChannelCommand(cmd)) return null;
-    const destructive = (name === "pwsh" || name === "bash") && cmd && (DESTRUCTIVE_CMD.test(cmd) || (isSensitiveToolCall(name, args) && !/git\s+(push|commit)/i.test(cmd)));
+    const 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;
     if (destructive || highRiskWrite) {
@@ -486,7 +506,7 @@ function matchRule(cfg, ctx) {
 
   // 规则 12A：敏感操作需要匹配授权证据
   if (cfg.handler === "rule12a-approval") {
-    if (isSensitiveToolCall(name, args)) {
+    if (isSensitiveToolCall(name, args, sessionIdOf(exec))) {
       // 规则 19：dsh-usage-manual/SKILL.md 正文更新免逐次确认（仅手册本身）
       if (p && MANUAL_PATH_RE.test(p)) return null;
       // /guard unlock 本身即用户对受保护配置的授权
@@ -577,7 +597,7 @@ function matchRule(cfg, ctx) {
   if (hints.includes("manual") && session.turn.toolCount === 0 && !session.manualReadSeen && !isManualReadTool(name, args)) {
     return makeHit(cfg, `【硬拦截】${cfg.title}`);
   }
-  if (hints.includes("sensitive") && isSensitiveToolCall(name, args)) {
+  if (hints.includes("sensitive") && isSensitiveToolCall(name, args, sessionIdOf(exec))) {
     if (p && MANUAL_PATH_RE.test(p)) return null;
     if (unlock && isProtectedConfigPath(p)) return null;
     const op = operationOf(name, args);

package/lib/core/judge.js

@@ -0,0 +1,85 @@
+// judge.js - D 级嫌疑裁决器（v0.5.7，用户拍板 2026-08-26）。
+// 原则：词表命中只是"嫌疑"；"是否是错误"由 LLM 确认——只有裁决为违规的才进入投递。
+// 模型：追随会话模型（复用 llm-understander.resolveRoute，与现有 LLM 意图判定同一路由机制，
+//       用户拍板：不单独固定模型，避免独立路由稳定性问题）。
+// 保护：sha256(ruleId+text) 缓存（同文本不重复调用）；每会话每日 JUDGE_DAILY_LIMIT 次预算；
+//       调用失败/超时/无路由 → 返回 unavailable（fail-closed：不投递，只审计）。
+import { createHash } from "node:crypto";
+import { resolveRoute, parseJsonOutput } from "./llm-understander.js";
+
+/** 每日裁决预算（用户拍板：50 次/会话/天；超预算 → unavailable，只审计不投递）。 */
+export const JUDGE_DAILY_LIMIT = 50;
+
+export function judgeCacheKey(ruleId, text) {
+  return createHash("sha256").update(`${ruleId}\n${text}`).digest("hex");
+}
+
+export function judgeBudgetKey(sessionId, now = Date.now()) {
+  const d = new Date(now);
+  return `${sessionId}:${d.getUTCFullYear()}-${d.getUTCMonth() + 1}-${d.getUTCDate()}`;
+}
+
+/**
+ * 裁决一次嫌疑。
+ * @returns {Promise<{action:"deliver"|"suppress"|"unavailable", note:string, model?:string}>}
+ *   deliver      = 确认真违规 → 允许投递
+ *   suppress     = 确认合规声明/引述/非违规 → 不投递（审计 judge-false）
+ *   unavailable  = 无法裁决（预算满/无路由/调用失败）→ 不投递（fail-closed，审计 judge-unavailable）
+ */
+export async function judgeViolation(ctx, state, sessionId, violation, text) {
+  const key = judgeCacheKey(violation.ruleId, text);
+  const cached = state.judgeCache?.get(key);
+  if (cached) return cached;
+
+  const bKey = judgeBudgetKey(sessionId);
+  const budget = state.judgeBudget?.get(bKey) || { count: 0 };
+  if (budget.count >= JUDGE_DAILY_LIMIT) {
+    return { action: "unavailable", note: `裁决日预算已满（${JUDGE_DAILY_LIMIT}/日/会话）` };
+  }
+
+  try {
+    const route = await resolveRoute(ctx);
+    if (!route) return { action: "unavailable", note: "无法解析模型路由（追随会话模型解析失败）" };
+    const rawCfg = Array.isArray(state.configs)
+      ? state.configs.find((c) => String(c.ruleId) === String(violation.ruleId))
+      : undefined;
+    const prompt = [
+      "你是 DSH 规则裁决器。判断下面这段【执行者回复】是否违反【规则】。只输出 JSON，不要其他内容。",
+      'JSON 格式：{"violated": true|false, "note": "一句话理由"}',
+      "判定要点：",
+      "1. 回复若是在表达合规声明（如“我不再/将避免/规则 X 已自证/无重复推销”）或引述规则文本——violated=false；",
+      "2. 只有确实发生规则禁止的行为（如真的再次推销/真的发布未声明/真的遗漏事项）才 violated=true；",
+      "3. 拿不准时给出倾向性判断（false 偏不打扰）。",
+      "规则编号：" + violation.ruleId,
+      "规则标题：" + violation.title,
+      "检测提示：" + String(violation.reason || ""),
+      "规则正文：" + (rawCfg?.body || "(未提供)"),
+      "执行者回复：",
+      text,
+      "只输出 JSON。"
+    ].join("\n");
+    const messages = [{ role: "user", content: [{ type: "text", text: prompt }] }];
+    let out = "";
+    for await (const chunk of ctx.llm.stream({
+      provider: route.provider,
+      model: route.model,
+      messages,
+      maxTokens: 300,
+      temperature: 0
+    })) {
+      if (chunk && chunk.type === "text-delta" && typeof chunk.text === "string") out += chunk.text;
+    }
+    budget.count += 1;
+    state.judgeBudget.set(bKey, budget);
+    const parsed = parseJsonOutput(out);
+    const verdict = {
+      action: parsed?.violated === true ? "deliver" : "suppress",
+      note: typeof parsed?.note === "string" ? parsed.note.slice(0, 120) : "",
+      model: route.model
+    };
+    state.judgeCache.set(key, verdict);
+    return verdict;
+  } catch (error) {
+    return { action: "unavailable", note: `裁决调用失败：${error instanceof Error ? error.message : String(error)}` };
+  }
+}

package/lib/core/llm-understander.js

@@ -7,7 +7,10 @@ export async function resolveRoute(ctx) {
   try {
     const providers = ctx.llm.listProviders?.() || [];
     if (providers.length === 0) return null;
-    const provider = process.env.DSH_LLM_PROVIDER || providers[0]?.name || providers[0];
+    // v0.5.7 修复（实弹抓到，2026-08-26）：必须用 provider 的 **id**（如 "deepseek-official"）调
+    // listModels/resolve——pi-ai 按 id 找 profile，name（显示名）可能不同 → 传 name 会抛
+    // NO_ADAPTER → 全部分析失败（旧 llmIntent 自启用起 31 次调用全降级的同根因）。
+    const provider = process.env.DSH_LLM_PROVIDER || providers[0]?.id || providers[0]?.name || providers[0];
     const models = await ctx.llm.listModels?.(provider);
     const model = process.env.DSH_LLM_MODEL || (models && models[0]?.id) || (models && models[0]) || null;
     if (!model) return null;
@@ -35,7 +38,7 @@ function buildPrompt(rule) {
   ].join("\n");
 }
 
-function parseJsonOutput(text) {
+export function parseJsonOutput(text) {
   const t = String(text || "").trim();
   const fence = t.match(/```(?:json)?\s*([\s\S]*?)```/);
   const raw = fence ? fence[1].trim() : t;

package/lib/core/paths.js

@@ -33,3 +33,13 @@ export function disabledRulesFilePath() {
 export function baselineFilePath() {
   return join(dshHome(), "rule-engine-baseline.json");
 }
+
+/** v0.5.7 P0-4：验证通过记录持久化文件（热重载/重启不丢——规则 23④ 证据链） */
+export function verifyFilePath() {
+  return join(dshHome(), "rule-engine-verify.json");
+}
+
+/** v0.5.7 后续（用户批准）：unknown 工具白名单持久化文件（"允许使用 X" → 重启不丢） */
+export function toolsWhitelistFilePath() {
+  return join(dshHome(), "rule-engine-tools.json");
+}

package/lib/core/patterns.js

@@ -237,7 +237,7 @@ 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|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;
+  /(?:\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|Select-Object|Out-String|Format-Table|Format-List|Format-Wide|Measure-Object|Sort-Object|Where-Object|Group-Object|Out-Null|ConvertTo-Json|ConvertFrom-Json)\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|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;
 
@@ -298,15 +298,24 @@ export function needsApprovalReminder(userText) {
   return PLAN_INSTRUCTION_RE.test(t) && !WRITE_INSTRUCTION_RE.test(t);
 }
 
-let workspaceRootOverride = "";
+let workspaceRoots = []; // 全局注册的工作区根（兜底层）
+const sessionWorkspaceRoots = new Map(); // v0.5.7 P0-3：会话→工作区根（精确层，根随会话走）
 
-/** 由插件 apply 阶段从 workspaceRegistry 设置工作区根目录 */
+/** 由插件 apply 阶段从 workspaceRegistry 设置工作区根目录（单根兼容入口） */
 export function setWorkspaceRoot(p) {
-  workspaceRootOverride = p || "";
+  setWorkspaceRoots(p ? [p] : []);
 }
 
-function workspaceRoot() {
-  return workspaceRootOverride || process.env.DSH_WORKSPACE || "";
+/** v0.5.7 P0-3：注册全部工作区根（多工作区环境；兜底层用） */
+export function setWorkspaceRoots(paths) {
+  workspaceRoots = Array.isArray(paths) ? paths.filter((p) => typeof p === "string" && p.length > 0) : [];
+}
+
+/** v0.5.7 P0-3：注册"会话→工作区根"映射——多工作区正确模型：根随会话走（写其他工作区=外部，需授权） */
+export function setSessionWorkspaceRoot(sessionId, root) {
+  if (sessionId && typeof root === "string" && root.length > 0) {
+    sessionWorkspaceRoots.set(String(sessionId), root);
+  }
 }
 
 function isPathInside(target, root) {
@@ -320,11 +329,26 @@ function normalizePathForCompare(p) {
   return String(p).replace(/\\/g, "/").toLowerCase().replace(/\/+$/, "");
 }
 
-/** 判断路径是否在工作区外（用于“工作区外写入”敏感判定） */
-export function isOutsideWorkspace(p) {
+/**
+ * 判断路径是否在工作区外（用于"工作区外写入"敏感判定）。
+ * v0.5.7 P0-3（用户拍板多工作区模型，2026-08-26）：
+ *  ① 会话已知且已映射 → 只用该会话的工作区根（精确：写其他工作区/他盘 = 外部 = 要授权）；
+ *  ② 无会话映射 → 全局注册根列表（任一命中=内部）；
+ *  ③ 仍无 → 环境变量/进程 cwd（最后尝试）；
+ *  ④ 全不可得 → 保守判"内部"（受保护文件/数据目录有独立清单兜底，避免工作区内普通文件被
+ *  误判外→12A 全量要授权——此前"只读脚本被拦"的根因）。
+ */
+export function isOutsideWorkspace(p, sessionId) {
   if (typeof p !== "string") return false;
   if (!/^[a-z]:[\\/]/i.test(p) && !p.startsWith("/")) return false; // 只判断绝对路径
-  return !isPathInside(p, workspaceRoot());
+  if (sessionId) {
+    const root = sessionWorkspaceRoots.get(String(sessionId));
+    if (root) return !isPathInside(p, root);
+  }
+  const roots = workspaceRoots.length > 0 ? workspaceRoots
+    : [process.env.DSH_WORKSPACE, process.cwd()].filter(Boolean);
+  if (roots.length === 0) return false;
+  return !roots.some((root) => isPathInside(p, root));
 }
 
 const ABS_PATH_RE = /[A-Za-z]:[\\/][^\s'"`，。；：！？（）【】《》、]+/g;
@@ -360,9 +384,9 @@ export function absolutePathTokens(command) {
   return [...new Set([...quoted, ...unquoted])];
 }
 
-function commandHasOutsideWrite(cmd) {
+function commandHasOutsideWrite(cmd, sessionId) {
   if (typeof cmd !== "string") return false;
-  return writeTargetPathsFromCommand(cmd).some((p) => isOutsideWorkspace(p));
+  return writeTargetPathsFromCommand(cmd).some((p) => isOutsideWorkspace(p, sessionId));
 }
 
 export const GENERIC_EXEC_TOOLS = new Set([
@@ -398,6 +422,18 @@ export function isAuditCommand(command) {
   return false;
 }
 
+/**
+ * v0.5.7 P0-1（用户拍板 2026-08-26）：验证类命令判定——运行测试/冷加载探针/挂载审计/语法检查。
+ * 与"修/改/写"授权伴生放行使用：用户授权修改后，验证是变更的正常闭环，不再被
+ * write vs command 类型不匹配误拦（今天实弹连卡 4 次）。
+ */
+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|--test)\b/i.test(command)) return true;
+  if (/\b(?:npm|pnpm)\s+(?:test|run\s+test)\b/i.test(command)) return true;
+  return false;
+}
+
 /** 审计输出是否明确通过（无 DUPLICATES/INCONSISTENT/MISSING 且出现通过标记） */
 export function auditOutputPassed(output) {
   const text = String(output || "");
@@ -409,8 +445,29 @@ export function auditOutputFailed(output) {
   return /DUPLICATES FOUND|INCONSISTENT|\[MISSING\]/i.test(String(output || ""));
 }
 
-/** 判断是否命中敏感操作（需要授权证据；只读操作永远不算） */
-export function isSensitiveToolCall(toolName, args) {
+/**
+ * v0.5.7 后续（2026-08-26 用户拍板，承诺兑现）：工作区内低风险变更判定——规则 12A 正文
+ * "工作区内低风险新建"豁免的机器实现（此前只修了相邻项：--profile 模板/多工作区根/验证伴生；
+ * 本项未修——只读诊断脚本被拦的承诺闭环于此）。edit/write 且：目标在工作区内 / 非受保护路径 /
+ * 非插件装配文件 / 非高风险启动入口 → 低风险变更（22-7 无执行分点回合也放行；12A 侧
+ * isSensitiveToolCall 本就对工作区普通文件返回 false）。
+ */
+export function isLowRiskWorkspaceNew(toolName, args) {
+  const name = String(toolName || "");
+  if (name !== "edit" && name !== "write") return false;
+  const p = pathTarget(args);
+  if (!p) return false;
+  if (isProtectedConfigPath(p)) return false;
+  if (isOutsideWorkspace(p)) return false;
+  if (isAssemblyMutationTool(name, args)) return false;
+  if (isHighRiskEntryFile(p)) return false;
+  return true;
+}
+
+/** 判断是否命中敏感操作（需要授权证据；只读操作永远不算）
+ *  v0.5.7 P0-3（复查修复 2026-08-26）：透传 sessionId——"工作区外"判定需按会话精确根（多工作区
+ *  模型：会话根优先；此前遗漏透传导致会话级根从未在运行时激活，只有全局兜底层生效）。 */
+export function isSensitiveToolCall(toolName, args, sessionId) {
   if (isReadOnlyTool(toolName, args)) return false;
   const name = String(toolName || "");
   const p = pathTarget(args);
@@ -423,13 +480,13 @@ export function isSensitiveToolCall(toolName, args) {
     // P0-1c：受保护文件名检查必须配合「写类命令」——纯描述性文本（如 gh release --notes 里的
     // "AGENTS.md" 字样、echo 输出内容）不再触发敏感判定；真写类命令（Set-Content/Remove-Item 等
     // 命中 MUTATING_CMD_RE）提到受保护文件仍判敏感。
-    if (cmd && (SENSITIVE_CMD.test(cmd) || (MUTATING_CMD_RE.test(cmd) && PROTECTED_FILENAME_RE.test(cmd)) || commandHasOutsideWrite(cmd))) return true;
+    if (cmd && (SENSITIVE_CMD.test(cmd) || (MUTATING_CMD_RE.test(cmd) && PROTECTED_FILENAME_RE.test(cmd)) || commandHasOutsideWrite(cmd, sessionId))) return true;
   }
   if (name === "edit" || name === "write") {
-    if (p && (isProtectedConfigPath(p) || isOutsideWorkspace(p))) return true;
+    if (p && (isProtectedConfigPath(p) || isOutsideWorkspace(p, sessionId))) return true;
   }
   if (name === "str_replace_editor" && args?.command !== "view") {
-    if (p && (isProtectedConfigPath(p) || isOutsideWorkspace(p))) return true;
+    if (p && (isProtectedConfigPath(p) || isOutsideWorkspace(p, sessionId))) return true;
   }
   if (GENERIC_EXEC_TOOLS.has(name)) return true;
   return false;
@@ -447,3 +504,32 @@ export const TERM_EXPLANATION_RE =
 /** 建议类表述（规则 16 重复推销：会话内同类建议 ≥2 → 自证） */
 export const SUGGEST_RE =
   /我建议|建议用|推荐|更优方案|建议(?:是|考虑|换成|用|来)|档位建议|不如换|优化建议/;
+
+/**
+ * v0.5.7 P0.5-6（用户拍板）：否定/合规声明语境（"不再/避免/停止/无 XX"）——那不是重复推销。
+ * 粗筛层直接不计数（合规声明不产生重复计数）；语义判断权仍归裁决器，
+ * 此处只为省钱（不送 LLM 裁决）并消除"自证--触发"噪音。
+ */
+export function isNegatingSuggestion(text) {
+  if (typeof text !== "string") return false;
+  return /(?:不再|不重复|避免|停止|取消|暂不|未再|不要(?:再)?|以后(?:不|别)|今后(?:不|别)|已呼应|已回应|无(?:新)?(?:建议|重复)|没有(?:新)?(?:建议|重复)|只等待)/.test(text);
+}
+
+/**
+ * v0.5.7 P0.5-5（用户拍板）：承诺词处于引述/改写语境（"把'保证'改成…"）→ 是引述不是承诺。
+ * 判定：词前 8 字符内配对开引号 + 词后 8 字符内配对闭引号；或前后 12 字符内引述标记词。
+ */
+export function isPromiseQuoteContext(text) {
+  if (typeof text !== "string") return false;
+  for (const m of text.matchAll(/(?:包在我身上|肯定能|绝对没问题|保证|一定可以|万无一失)/g)) {
+    const before = text.slice(0, m.index);
+    const after = text.slice(m.index + m[0].length);
+    // 引述包装 = 承诺词两侧 8 字符内都有引号（ASCII/中文弯引号均算；不区分左右——
+    // ASCII 单引号左右同形，分区判定会自相矛盾；双侧近邻引号即视为被引述包裹）。
+    const openNear = /[“"「『‘'””」』’]/.test(before.slice(-8));
+    const closeNear = /[“"「『‘'””」』’]/.test(after.slice(0, 8));
+    if (openNear && closeNear) return true;
+    if (/引述|引用|原文|写过|改成|改为|换成/.test(before.slice(-12)) || /改成|改为|换成/.test(after.slice(0, 12))) return true;
+  }
+  return false;
+}

package/lib/core/semantic.js

@@ -0,0 +1,43 @@
+// semantic.js - 投递资格语义层（v0.5.7，用户拍板 2026-08-26）。
+// 原则：只有"错误的行为"才值得被提醒（D 级无法硬拦，提醒是唯一执行手段）。
+// 本文件只放纯函数，不做 LLM——"是否错误"的裁决在 judge.js；
+// 这里的职责是：① 注入轮不检测判定（乒乓根治）；② 投递资格闸（提醒一次并记住 + 会话每小时预算）。
+
+/** 会话弹窗预算：每小时最多 3 条注入（跨全部规则，含聚合）。 */
+export const INJECT_BUDGET_PER_HOUR = 3;
+
+/**
+ * 第 0 站（检测前传）：只有"真实用户在场"的回合才做违规检测与投递。
+ * 真实用户在场 = 本回合 user/message 来源为 user，或 ask_user_question 获得用户答复。
+ * 引擎注入触发的回合（source=plugin / 依赖注入出的无用户消息轮）不检测——
+ * 那些回合的"回复-检测-再注入"正是乒乓循环的燃料（实测 2026-08-26 12:37 六圈）。
+ */
+export function shouldDetectTurn({ realUserSeen }) {
+  return realUserSeen === true;
+}
+
+/**
+ * 投递资格闸：决定这条注入该不该"进对话"（无论结果如何都会写审计）。
+ * 规则：① 同规则同会话仅投递一次（__self-cert 聚合除外）；
+ *      ② 会话每小时至多 INJECT_BUDGET_PER_HOUR 条（超出只审计不投递）。
+ * 两者同时满足才投递；被拦的违规全部留在 /guard log 审计（inject-skip）。
+ * @param {object} p
+ * @param {number} p.now           当前时间戳
+ * @param {string} p.ruleId        规则 id（__self-cert 不做每规则去重）
+ * @param {number|null} p.firstAt  该规则在本会话首次投递时间（null=从未投递）
+ * @param {number[]} p.budgetTimes 本会话投递时间戳列表（用于预算窗口统计）
+ * @returns {{ok:true}|{ok:false, reason:"dedup"|"budget"}}
+ */
+export function shouldDeliver({ now, ruleId, firstAt, budgetTimes }) {
+  // 机制类注入（`__` 前缀：__engram-gap / __version-guard / __self-cert 聚合等）是事件驱动、
+  // 低频且重要，不做"每规则一次"去重（总量由下面的每小时预算约束）；只有真实规则 id 才"提醒一次并记住"。
+  const isMechanism = String(ruleId || "").startsWith("__");
+  if (!isMechanism && firstAt != null) {
+    return { ok: false, reason: "dedup" };
+  }
+  const recent = (budgetTimes || []).filter((t) => now - t < 60 * 60 * 1000);
+  if (recent.length >= INJECT_BUDGET_PER_HOUR) {
+    return { ok: false, reason: "budget" };
+  }
+  return { ok: true };
+}

package/lib/core/state.js

@@ -28,6 +28,11 @@ export function createState() {
     sessions: new Map(),
     retryCounts: new Map(),
     injectCounts: new Map(),
+    injectAt: new Map(), // v0.5.7：key `${sessionId}:${ruleId}` → 首次投递时间（提醒一次并记住）
+    injectBudget: new Map(), // v0.5.7：sessionId → 投递时间戳数组（会话每小时预算）
+    judgeCache: new Map(), // v0.5.7：sha256(ruleId+text) → 裁决结果（同文本不重复调用）
+    judgeBudget: new Map(), // v0.5.7：`${sessionId}:${UTC日期}` → {count}（每日裁决预算）
+    judgeFn: null, // v0.5.7：可注入裁决函数（生产=judge.js LLM 实现；测试=stub）
     globalAuthorizations: [],
     skillNames: null,
     llmEnrichedKeys: new Set(),
@@ -97,6 +102,21 @@ export function pruneState(state) {
     const keys = [...state.injectCounts.keys()];
     for (let i = 0; i < keys.length - MAX_INJECT_KEYS; i++) state.injectCounts.delete(keys[i]);
   }
+  // v0.5.7：投递资格/裁决状态超限清理（优先保留新 key 语义——按插入序删最旧）
+  for (const m of [state.injectAt, state.judgeCache]) {
+    if (m.size > MAX_INJECT_KEYS) {
+      const keys = [...m.keys()];
+      for (let i = 0; i < keys.length - MAX_INJECT_KEYS; i++) m.delete(keys[i]);
+    }
+  }
+  if (state.injectBudget.size > MAX_SESSIONS) {
+    const keys = [...state.injectBudget.keys()];
+    for (let i = 0; i < keys.length - MAX_SESSIONS; i++) state.injectBudget.delete(keys[i]);
+  }
+  if (state.judgeBudget.size > MAX_SESSIONS * 2) {
+    const keys = [...state.judgeBudget.keys()];
+    for (let i = 0; i < keys.length - MAX_SESSIONS * 2; i++) state.judgeBudget.delete(keys[i]);
+  }
   // 清理过期授权（顺便释放内存）
   for (const s of state.sessions.values()) {
     s.authorizations = s.authorizations.filter((a) => !a.expiresAt || a.expiresAt > now);
@@ -206,6 +226,7 @@ export function freshTurn() {
   return {
     number: 0,
     userText: "",
+    realUserSeen: false, // v0.5.7：本回合是否有真实用户消息（注入轮不检测的依据）
     askSeen: false,
     askRejected: false, // 本回合 ask 已被拒（防连环 ask，弹窗消减）
     questionOnly: false,

package/lib/core/text-detect.js

@@ -8,7 +8,9 @@ import {
   URL_RE,
   TECH_TERM_RE,
   TERM_EXPLANATION_RE,
-  SUGGEST_RE
+  SUGGEST_RE,
+  isNegatingSuggestion,
+  isPromiseQuoteContext
 } from "./patterns.js";
 import { detectOverengineeringText } from "./overengineering.js";
 
@@ -88,7 +90,8 @@ export function detectViolations({ configs, session, text, reasoningText = "", m
   }
 
   const promiseCfg = byId.get("7");
-  if (promiseCfg && PROMISE_WORDS.test(text)) {
+  // v0.5.7 P0.5-5：承诺词处于引述/改写语境（"把'保证'改成…"）→ 引述不是承诺，不触发
+  if (promiseCfg && PROMISE_WORDS.test(text) && !isPromiseQuoteContext(text)) {
     hits.push({
       ruleId: "7",
       title: promiseCfg.title,
@@ -133,8 +136,10 @@ export function detectViolations({ configs, session, text, reasoningText = "", m
   }
 
   // 批次 5：重复推销（规则 16——会话内同类建议 ≥2 次 → 自证，防反复推销）
+  // v0.5.7 P0.5-6：否定/合规声明语境（"不再/无 XX"）不计数——那不是重复推销（粗筛省钱，
+  // 语义判断权仍归裁决器）
   const suggestCfg = byId.get("16");
-  if (suggestCfg && SUGGEST_RE.test(text)) {
+  if (suggestCfg && SUGGEST_RE.test(text) && !isNegatingSuggestion(text)) {
     session.suggestionCounts = session.suggestionCounts || {};
     session.suggestionCounts.general = (session.suggestionCounts.general || 0) + 1;
     if (session.suggestionCounts.general >= 2) {
@@ -253,5 +258,10 @@ export function detectViolations({ configs, session, text, reasoningText = "", m
       if (k) k.suppressed++;
     }
   }
+  // v0.5.7：D 级语义型命中 = 嫌疑（awaitingJudge）——词表只产嫌疑，"是否错误"由 judge 裁决。
+  // 只有裁决 = 违规 的才进入投递（兑现"只有错误的行为才值得被提醒"）。
+  for (const h of kept) {
+    if (h.kind === "self-certify") h.awaitingJudge = true;
+  }
   return kept;
 }

package/lib/index.js

@@ -25,7 +25,9 @@ import {
   isReadOnlyTool,
   needsApprovalReminder,
   PRIVATE_NETWORK_RE,
-  setWorkspaceRoot
+  setWorkspaceRoot,
+  setWorkspaceRoots,
+  setSessionWorkspaceRoot
 } from "./core/patterns.js";
 import {
   askQuestionCoreText,
@@ -56,6 +58,8 @@ import { SAFE_UNCOVERED_TOOLS } from "./core/guard-core.js";
 import { toolClass } from "./core/tool-catalog.js";
 import { state } from "./core/runtime.js";
 import { detectViolations, extractAssistantText } from "./core/text-detect.js";
+import { shouldDetectTurn, shouldDeliver } from "./core/semantic.js";
+import { judgeViolation } from "./core/judge.js";
 import {
   applyContract,
   contractSummary,
@@ -75,7 +79,7 @@ import {
   recordAction
 } from "./core/overengineering.js";
 import { writeUnderstanding } from "./core/understanding-store.js";
-import { agentsFilePath, auditFilePath } from "./core/paths.js";
+import { agentsFilePath, auditFilePath, verifyFilePath, toolsWhitelistFilePath } from "./core/paths.js";
 import { isVersionedFile, validateEditedFile } from "./core/version-guard.js";
 import { computeMountSignature, profileNameFromArgs } from "./core/mount-signature.js";
 import { detectSilentError, extractToolOutput } from "./core/silent-error.js";
@@ -173,8 +177,31 @@ const pendingInjectTimers = new Set();
 function maybeInject(ctx, sessionId, violation) {
   if (!pluginConfig.correctInject) return;
   const key = `${sessionId}:${violation.ruleId}`;
+  // v0.5.7 投递资格闸（用户拍板"提醒一次并记住 + 会话每小时 3 条预算"，2026-08-26）：
+  // 同规则同会话仅投递一次（__self-cert 聚合除外），会话每小时至多 3 条。
+  // 被拦的违规仍写审计（inject-skip）——只有"弹进对话"被省掉，审计完整性不降级。
+  const gate = shouldDeliver({
+    now: Date.now(),
+    ruleId: violation.ruleId,
+    firstAt: state.injectAt.get(key) ?? null,
+    budgetTimes: state.injectBudget.get(sessionId) || []
+  });
+  if (!gate.ok) {
+    audit({
+      kind: "inject-skip",
+      rule: violation.ruleId,
+      name: "投递资格拦截",
+      event: "inject",
+      reason: `未投递（${gate.reason}）：${String(violation.reason || "").slice(0, 80)}`,
+      session: sessionId
+    });
+    return;
+  }
+  state.injectAt.set(key, Date.now());
+  const budgetArr = state.injectBudget.get(sessionId) || [];
+  budgetArr.push(Date.now());
+  state.injectBudget.set(sessionId, budgetArr.slice(-20));
   const count = state.injectCounts.get(key) || 0;
-  if (count >= pluginConfig.injectLimitPerRulePerSession) return;
   state.injectCounts.set(key, count + 1);
   // C2 统计：注入（injected）计数（实际投递尝试，上限内）
   {
@@ -214,6 +241,53 @@ function maybeInject(ctx, sessionId, violation) {
   pendingInjectTimers.add(timer);
 }
 
+/**
+ * v0.5.7：D 级嫌疑异步裁决并投递（用户拍板"只有错误的行为才值得被提醒"）。
+ * 裁决函数可注入（state.judgeFn，测试用 stub；生产 = judge.js 的 LLM 实现）。
+ * 结果审计：judge-pass（确认违规→投递）/ judge-false（合规声明/引述→不投）/
+ * judge-unavailable（失败/超时/预算满→fail-closed 不投）——三类全部留 /guard log 可对质。
+ */
+async function deliverSuspects(ctx, sessionId, suspects, text) {
+  const judgeFn = state.judgeFn || judgeViolation;
+  const results = await Promise.all(suspects.map(async (v) => {
+    try {
+      const verdict = await judgeFn(ctx, state, sessionId, v, text);
+      const kind = verdict.action === "deliver" ? "judge-pass"
+        : verdict.action === "suppress" ? "judge-false"
+        : "judge-unavailable";
+      audit({
+        kind,
+        rule: v.ruleId,
+        name: "违规裁决",
+        event: "assistant/message",
+        reason: `${verdict.action}：${verdict.note || ""}${verdict.model ? `（model=${verdict.model}）` : ""}`,
+        session: sessionId
+      });
+      return verdict.action === "deliver" ? v : null;
+    } catch (error) {
+      audit({
+        kind: "judge-unavailable",
+        rule: v.ruleId,
+        name: "裁决异常",
+        event: "assistant/message",
+        reason: `未投递：${error instanceof Error ? error.message : String(error)}`,
+        session: sessionId
+      });
+      return null;
+    }
+  }));
+  const deliver = results.filter(Boolean);
+  if (deliver.length > 1) {
+    const briefs = deliver.map((v) => `规则 ${v.ruleId}（${String(v.reason || "").slice(0, 60)}）`).join("；");
+    maybeInject(ctx, sessionId, {
+      ruleId: "__self-cert",
+      reason: `裁决通过 ${deliver.length} 项：${briefs}——请按 /guard log 明细应对`
+    });
+  } else if (deliver.length === 1) {
+    maybeInject(ctx, sessionId, deliver[0]);
+  }
+}
+
 async function refreshSkills(ctx) {
   try {
     const list = await ctx.skills.list();
@@ -223,6 +297,24 @@ async function refreshSkills(ctx) {
   }
 }
 
+/** v0.5.7 P0-4：验证通过记录持久化（文件损坏/写失败不阻断运行时） */
+function persistVerifyPass(state) {
+  try {
+    writeFileSync(verifyFilePath(), JSON.stringify((state.verifyPass || []).slice(-100)), "utf8");
+  } catch {
+    // 持久化失败仅降级（内存态仍有效），不阻断
+  }
+}
+
+/** v0.5.7 后续（用户批准）：unknown 工具白名单持久化（~/.dsh/rule-engine-tools.json——"允许使用 X"重启/热重载不丢） */
+function persistToolWhitelist(state) {
+  try {
+    writeFileSync(toolsWhitelistFilePath(), JSON.stringify([...(state.unknownToolApproved || [])]), "utf8");
+  } catch {
+    // 持久化失败仅降级（内存态仍有效），不阻断
+  }
+}
+
 export function handleSessionEvent(ctx, session, event) {
   maybeReloadIfChanged(state);
   const sid = session?.id || "global";
@@ -294,6 +386,7 @@ export function handleSessionEvent(ctx, session, event) {
       if (toolClass(toolName, {}) !== "unknown") continue; // 只对未归类工具有意义（已知工具不走 unknown 分支）
       const isNew = !state.unknownToolApproved.has(toolName);
       state.unknownToolApproved.add(toolName);
+      persistToolWhitelist(state); // v0.5.7 后续：白名单持久化（重启/热重载不丢——用户批准"这句不用每次发"）
       audit({
         kind: "unknown-tool-whitelist",
         rule: "__unknown-tool",
@@ -305,6 +398,7 @@ export function handleSessionEvent(ctx, session, event) {
     }
     s.lastUserText = text;
     s.turn.userText = text;
+    s.turn.realUserSeen = true; // v0.5.7：真实用户在场（注入轮不检测的依据——乒乓根治）
     s.turn.questionOnly = isQuestionMessage(text);
     s.turn.intents = parseUserIntents(text);
     // 规则 22 粒度升级（2026-08-24）：本回合授权范围 = 各 execute 子句推导出的 type+path 范围
@@ -567,10 +661,11 @@ export function handleSessionEvent(ctx, session, event) {
     // pendingToolCalls 状态（what 降级记录），verify-pass 语义不变（输出即证据）。
     if (!isError) {
       const output = extractToolOutput(d);
-      if (/\bALL TESTS PASSED\b|RESULT:\s*PASS/.test(output)) {
+      if (/\bALL TESTS PASSED\b|RESULT:\s*PASS|\bVERIFY ALL OK\b/.test(output)) {
         if (!state.verifyPass) state.verifyPass = [];
         state.verifyPass.push({ at: Date.now(), sessionId: sid, what: pendingCall?.name || "tool-result" });
         if (state.verifyPass.length > 100) state.verifyPass.splice(0, state.verifyPass.length - 100);
+        persistVerifyPass(state); // v0.5.7 P0-4：持久化（热重载/重启不丢）
       }
     }
 
@@ -597,6 +692,7 @@ export function handleSessionEvent(ctx, session, event) {
     if (pending) {
       const result = d.result ?? d.value ?? d;
       if (askResultApproved(result)) {
+        s.turn.realUserSeen = true; // v0.5.7：ask 弹窗答复也算"真实用户在场"
         const qText = askQuestionText(pending.questions);
         const selectedText = askResultSelectedText(result);
         // 授权范围只取“问题核心 + 用户实际选择”，不再把全部选项描述纳入；
@@ -624,6 +720,7 @@ export function handleSessionEvent(ctx, session, event) {
           if (!state.unknownToolApproved) state.unknownToolApproved = new Set();
           const isNew = !state.unknownToolApproved.has(wname);
           state.unknownToolApproved.add(wname);
+          persistToolWhitelist(state); // v0.5.7 后续：白名单持久化（见上）
           audit({
             kind: "unknown-tool-whitelist",
             rule: "__unknown-tool",
@@ -671,6 +768,9 @@ export function handleSessionEvent(ctx, session, event) {
   }
   if (event.type === "assistant/message") {
     const text = extractAssistantText(d.message);
+    // v0.5.7 第 0 站：注入轮（无真实用户消息）不检测不投递——这是乒乓循环的根治：
+    // 引擎自己的注入 → 我的回复 → 再检测 的燃料被掐断（实测 2026-08-26 12:37 六圈即此循环）。
+    if (!shouldDetectTurn({ realUserSeen: s.turn.realUserSeen })) return;
     // 交付声明机器闸门（机制批 M3，规则 23④）：完成类声明 → 核对同会话 30 分钟内 verify-pass 记录，缺失注入纠正
     if (/完成|已通过|已修复|搞定|验证通过|全部通过|修复完成|落盘完成/.test(text)) {
       const windowStart = Date.now() - 30 * 60 * 1000;
@@ -684,7 +784,15 @@ export function handleSessionEvent(ctx, session, event) {
           reason: "交付/完成类声明缺少同会话近期 verify-pass（ALL TESTS PASSED / check-plugin-load RESULT: PASS）记录",
           session: sid
         });
-        maybeInject(ctx, sid, { ruleId: "23", reason: "规则 23④：完成/通过类声明需同会话近期验证记录（测试全绿或冷加载 PASS），缺失已记审计——请先运行验证并附证据再宣布完成" });
+        // v0.5.7 后续（用户拍板"暗示型统一裁决"）：23④ 词面命中只是嫌疑——"完成"≠交付声明
+        //（"完成社区检索"类误触的修复）：送 LLM 裁决，确认违规才投递。
+        void deliverSuspects(ctx, sid, [{
+          ruleId: "23",
+          title: "变更与交付验证（执行等级：D 强）",
+          kind: "self-certify",
+          awaitingJudge: true,
+          reason: "规则 23④：完成/通过类声明需同会话近期验证记录（测试全绿或冷加载 PASS），缺失已记审计"
+        }], text);
       }
     }
     // 需求基线覆盖核查（RB-09，2026-08-24）：方案/重构/整体完成类声明 → 基线仍存在 planned 需求 → 审计纠正（fail-closed）
@@ -728,18 +836,24 @@ export function handleSessionEvent(ctx, session, event) {
         session: sid
       });
     }
-    // 注入噪音治理 v0.5.6（建议1/B1 聚合注入）：同回合多条违规 → 聚合为一条注入（明细全在 /guard log）；
-    // 单条仍按逐规则投递（保留完整提示文本与逐规则计数上限）；聚合注入用伪规则 __self-cert 计数。
-    if (violations.length > 1) {
-      const briefs = violations
+    // v0.5.7 分流水线：B 级机器型（correct，词表=确定证据）立即投递；
+    // D 级语义型命中 = 嫌疑（awaitingJudge）→ 先裁决，只有裁决=违规的才投递
+    // （用户拍板："只有错误的行为才值得被提醒"——词表只产嫌疑，不再定罪）。
+    const immediate = violations.filter((v) => v.kind !== "self-certify");
+    const suspects = violations.filter((v) => v.awaitingJudge === true);
+    if (immediate.length > 1) {
+      const briefs = immediate
         .map((v) => `规则 ${v.ruleId}（${String(v.reason || "").slice(0, 60)}）`)
         .join("；");
       maybeInject(ctx, sid, {
         ruleId: "__self-cert",
-        reason: `本轮检出 ${violations.length} 项待自证：${briefs}——请按 /guard log 明细一次性自证`
+        reason: `本轮检出 ${immediate.length} 项：${briefs}——请按 /guard log 明细应对`
       });
-    } else if (violations.length === 1) {
-      maybeInject(ctx, sid, violations[0]);
+    } else if (immediate.length === 1) {
+      maybeInject(ctx, sid, immediate[0]);
+    }
+    if (suspects.length > 0) {
+      void deliverSuspects(ctx, sid, suspects, text);
     }
     if (violations.length) {
       state.lastActive = violations.map((v) => ({ ruleId: v.ruleId, title: v.title, reason: v.reason }));
@@ -964,12 +1078,36 @@ async function executeGuard(ctx, invocation) {
 // ── 插件主体 ────────────────────────────────────────────────────────────────
 
 export function apply(ctx) {
-  // 0. 从 workspaceRegistry 获取真实工作区根目录，避免 process.cwd() 误判
+  // 0. v0.5.7 P0-3：注册全部工作区根（多工作区环境；精确层=会话级，在 guard 回调按会话同步）
   try {
-    const ws = ctx.workspaceRegistry?.list?.()?.[0]?.path;
-    setWorkspaceRoot(ws || process.env.DSH_WORKSPACE || "");
+    const list = ctx.workspaceRegistry?.list?.() || [];
+    setWorkspaceRoots(list.map((e) => e && (e.path || e.record?.path)).filter(Boolean));
   } catch {
-    setWorkspaceRoot(process.env.DSH_WORKSPACE || "");
+    setWorkspaceRoots([]);
+  }
+
+  // v0.5.7 P0-4：加载持久化验证记录（热重载/重启后规则 23④ 证据链不丢；仅保留 30 分钟内）
+  try {
+    const raw = readFileSync(verifyFilePath(), "utf8");
+    const arr = JSON.parse(raw);
+    if (Array.isArray(arr)) {
+      state.verifyPass = arr
+        .filter((v) => v && v.at && Date.now() - Number(v.at) < 30 * 60 * 1000)
+        .slice(-100);
+    }
+  } catch {
+    // 首次运行/文件缺失：无历史记录，正常
+  }
+
+  // v0.5.7 后续（用户批准）：加载白名单持久化（"允许使用 X"重启/热重载不丢）
+  try {
+    const wlRaw = readFileSync(toolsWhitelistFilePath(), "utf8");
+    const wlArr = JSON.parse(wlRaw);
+    if (Array.isArray(wlArr)) {
+      state.unknownToolApproved = new Set(wlArr.filter((n) => typeof n === "string"));
+    }
+  } catch {
+    // 首次运行/无文件：空白名单
   }
 
   // 0.0.1 LLM 意图兜底配置（guardDecision 为纯函数，经 state 传入）
@@ -1024,6 +1162,17 @@ export function apply(ctx) {
   ctx.effect(
     function* () {
       yield ctx.tools.guard((exec) => {
+        // v0.5.7 P0-3：多工作区正确模型——根随会话走。每个工具调用前按当前会话同步其工作区根
+        //（官方 workspaceRegistry.sessionPath 提供会话→工作区映射；新工作区零维护自动识别）。
+        try {
+          const gsid = sessionIdOfExec(exec);
+          if (gsid && gsid !== "global" && ctx.workspaceRegistry?.sessionPath) {
+            const root = ctx.workspaceRegistry.sessionPath(gsid);
+            if (root) setSessionWorkspaceRoot(gsid, root);
+          }
+        } catch {
+          // 会话未映射时安静走全局兜底，不阻塞裁决
+        }
         // 落盘授权粒度提醒（机制批 M7，2026-08-24）：受保护文件统一入口调用 + 本回合用户消息为方案性指令
         //（调整/补充/评估/建议且无落盘词）→ approval-gap 审计 + 注入提醒（规则 22 自证③：方案性指令 ≠ 落盘授权）
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-rule-engine",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "DSH 规则执行引擎 v3：容器解析 AGENTS.md + 理解器 + 匹配机 + 执行框架",
   "type": "module",
   "main": "lib/index.js",
@@ -43,6 +43,7 @@
   "scripts": {
     "test": "node test/run-all.mjs",
     "check": "node --check lib/index.js",
+    "verify": "node scripts/verify-all.mjs",
     "audit:mount": "node scripts/audit-mount-consistency.mjs --profile web"
   },
   "peerDependencies": {

package/scripts/health-audit.mjs

@@ -0,0 +1,60 @@
+// health-audit.mjs - 健康审计（找茬，不是证明；2026-08-26）。
+// 输出"问题清单"（近 24h），无问题也要列出"查了什么"：
+// ① 失败/降级类统计：intent-llm（成功/失败降级）、judge-pass/false/unavailable、
+//    verify-gap、inject-skip、source-skip——失败可见化（"LLM 意图 31 次全降级"从此自浮现）；
+// ② 接口接线交叉：关键导出符号在 lib 下引用计数 ≤1（仅定义，无引用）→ 疑似未接线；
+// ③ 与 verify-all 的真实判例口径一致（供人工核对）。
+import { readdirSync, statSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const auditPath = join(process.env.DSH_HOME || join(process.env.USERPROFILE || "", ".dsh"), "rule-engine.log.jsonl");
+const now = Date.now();
+const cuts = { intentFail: 0, intentOk: 0, judgePass: 0, judgeFalse: 0, judgeUnavail: 0, verifyGap: 0, injectSkip: 0, sourceSkip: 0 };
+
+try {
+  for (const line of readFileSync(auditPath, "utf8").split("\n")) {
+    const m = line.match(/"ts":"([^"]+)"/);
+    if (!m || now - new Date(m[1]).getTime() > 24 * 3600 * 1000) continue;
+    if (line.includes('"kind":"intent-llm"')) (line.includes("LLM 失败降级") ? cuts.intentFail++ : cuts.intentOk++);
+    if (line.includes('"kind":"judge-pass"')) cuts.judgePass++;
+    if (line.includes('"kind":"judge-false"')) cuts.judgeFalse++;
+    if (line.includes('"kind":"judge-unavailable"')) cuts.judgeUnavail++;
+    if (line.includes('"kind":"verify-gap"')) cuts.verifyGap++;
+    if (line.includes('"kind":"inject-skip"')) cuts.injectSkip++;
+    if (line.includes('"kind":"source-skip"')) cuts.sourceSkip++;
+  }
+} catch {
+  // 无日志文件：一切 0
+}
+
+// ② 接线交叉：导出符号引用计数（>1 = 定义+引用；=1 = 疑似仅定义未接线）
+const EXPORTS = [
+  "setSessionWorkspaceRoot", "setWorkspaceRoots", "isVerificationCommand",
+  "isNegatingSuggestion", "isPromiseQuoteContext", "judgeViolation",
+  "shouldDetectTurn", "shouldDeliver", "isReadOnlyCommand"
+];
+let libText = "";
+(function walk(d) {
+  for (const f of readdirSync(d)) {
+    const p = join(d, f);
+    if (statSync(p).isDirectory()) walk(p);
+    else if (/\.js$/.test(f)) libText += readFileSync(p, "utf8") + "\n";
+  }
+})(join(root, "lib"));
+const orphans = EXPORTS.filter((n) => ((libText.match(new RegExp("\\b" + n + "\\b", "g")) || []).length) <= 1);
+
+console.log("== 健康审计（近 24h）==");
+console.log(`intent-llm 失败降级 ${cuts.intentFail} 条 / 成功 ${cuts.intentOk} 条`);
+console.log(`judge-pass ${cuts.judgePass} 条 / judge-false ${cuts.judgeFalse} 条 / judge-unavailable ${cuts.judgeUnavail} 条`);
+console.log(`verify-gap ${cuts.verifyGap} 条 / inject-skip ${cuts.injectSkip} 条 / source-skip ${cuts.sourceSkip} 条`);
+console.log(`接线交叉：${EXPORTS.length} 个关键导出 → 疑似未接线 ${orphans.length ? orphans.join("、") : "0 个"}`);
+if (cuts.judgePass + cuts.judgeFalse === 0) {
+  console.log("⚠️ 问题：近 24h 无真实判例——裁决器无运行证据（需实弹）");
+}
+if (cuts.intentFail > 0) {
+  console.log(`⚠️ 问题：intent-llm 失败降级 ${cuts.intentFail} 条——LLM 意图判定不可用（需查模型路由/密钥）`);
+}
+console.log(orphans.length ? `❌ 问题：疑似未接线：${orphans.join("、")}` : `✅ 接线：全部导出有引用`);
+console.log("（已查：失败统计 8 类 + 接线交叉 9 个导出；无问题也列出如上）");

package/scripts/verify-all.mjs

@@ -0,0 +1,81 @@
+// verify-all.mjs - 交付前体检报告（2026-08-26，对齐官方 docs/testing.zh.md 分层验证）。
+// 四层：① 语法（lib 全部 .js node --check）
+//       ② 单元（test/run-all.mjs——单元+机制层，不含 e2e）
+//       ③ 组合冒烟（test/loader-smoke.e2e.mjs——真实接线 + 外部世界断言）
+//       ④ 真实判例（外部世界：近 24h 台账中 judge-pass/judge-false 记录数；
+//          0 条 = WARN 提示需实弹，≥1 条 = 有真实裁决证据——读文件，不是自我报告）
+// 任一 ❌ → exit 1；⚠️（WARN）不阻塞但必须明示。
+// 注意：子进程输出捕获需完整权限运行（受限模式 EPERM）。
+import { execFileSync } from "node:child_process";
+import { readdirSync, statSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const lines = [];
+
+function step(name, cmd, args) {
+  try {
+    const out = execFileSync(cmd, args, { cwd: root, encoding: "utf8", stdio: "pipe", maxBuffer: 64 * 1024 * 1024 });
+    lines.push(`✅ ${name}`);
+    return out;
+  } catch (e) {
+    lines.push(`❌ ${name}`);
+    lines.push(String(e.stdout || e.stderr || e.message).slice(-500));
+    return null;
+  }
+}
+
+// ── ① 语法 ──
+const files = [];
+(function walk(d) {
+  for (const f of readdirSync(d)) {
+    const p = join(d, f);
+    if (statSync(p).isDirectory()) walk(p);
+    else if (/\.js$/.test(f)) files.push(p);
+  }
+})(join(root, "lib"));
+let sOk = true;
+for (const f of files) {
+  try {
+    execFileSync(process.execPath, ["--check", f], { cwd: root, stdio: "pipe", encoding: "utf8" });
+  } catch (e) {
+    sOk = false;
+    lines.push(`❌ 语法 ${f}`);
+    lines.push(String(e.stderr || e.message).slice(-300));
+  }
+}
+if (sOk) lines.push(`✅ 语法（${files.length} 个 lib 文件）`);
+
+// ── ② 单元 ──
+step("单元（test/run-all.mjs）", process.execPath, [join(root, "test", "run-all.mjs")]);
+
+// ── ③ 组合冒烟 ──
+step("组合冒烟（loader-smoke，真实接线+外部世界断言）", process.execPath, [join(root, "test", "loader-smoke.e2e.mjs")]);
+
+// ── ④ 真实判例（外部世界） ──
+let judgeReal = 0;
+const auditPath = join(process.env.DSH_HOME || join(process.env.USERPROFILE || "", ".dsh"), "rule-engine.log.jsonl");
+const since = Date.now() - 24 * 3600 * 1000;
+try {
+  for (const line of readFileSync(auditPath, "utf8").split("\n")) {
+    if (!line.includes("judge-pass") && !line.includes("judge-false")) continue;
+    const m = line.match(/"ts":"([^"]+)"/);
+    if (m && new Date(m[1]).getTime() >= since) judgeReal++;
+  }
+} catch {
+  // 无日志：提示即可
+}
+if (judgeReal > 0) {
+  lines.push(`✅ 真实判例（近 24h judge-pass/judge-false = ${judgeReal} 条——裁决器真实工作证据）`);
+} else {
+  lines.push("⚠️ 真实判例：近 24h 无 judge-pass/judge-false 记录——裁决器需要一次实弹（非阻塞 WARN，但说明运行证据尚未产生）");
+}
+
+console.log(lines.join("\n"));
+const failed = lines.filter((l) => l.startsWith("❌"));
+if (failed.length) {
+  console.log(`\nVERIFY FAIL：${failed.length} 项问题，见上`);
+  process.exit(1);
+}
+console.log("\nVERIFY ALL OK");