dsh-rule-engine 0.5.5 → 0.5.7

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.7-blue)
+
 DSH 规则执行引擎 v3 的插件实现。它把 `~/.dsh/AGENTS.md` 当作唯一真相源，自动解析规则四要素与执行等级，再通过「工具守卫 + 文本检测 + 时序检查 + 审计台账」执行用户规则，而不是内置一套与用户无关的安全清单。
 
+> 当前版本 **0.5.7**（2026-08-26 发布）。本插件面向"规则机器化执行"：规则写在 AGENTS.md 里，引擎负责让它们真的被遵守；所有规则动态解析，规则增删改后无需重写插件。
+
 ## 项目背景
 
 这个项目来自一个非常具体的个人需求：
@@ -22,6 +27,25 @@ 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`）→ 对账交付（计划×实际逐项 ✅/❌/跳过原因）。
+
 ## 任务契约与反过度工程（可选）
 
 - 默认**关闭**；可在规则引擎设置页开启「任务边界与反过度工程」总开关。
@@ -88,6 +112,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 +141,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 +173,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,7 @@ import {
   isReadOnlyTool,
   isSensitiveToolCall,
   isVariablePath,
+  isVerificationCommand,
   pathTarget
 } from "./patterns.js";
 import { authMatches, describeAuth, describeOp, describeScopes, findMatchingAuth, operationOf, askQuestionText, inferPathPrefixFromText, inferTypeFromText, scopesFromIntents } from "./authorization.js";
@@ -177,6 +178,9 @@ function taskContractGuardDecision(state, exec, session) {
   if (!isArmed(contract, state.taskContract)) return null;
   const action = classifyAction(exec?.name, exec?.arguments);
   const dec = decideContractAction({ contract, action, config: state.taskContract });
+  // 2026-08-25 预算双判防护：AGENT_BUDGET_EXHAUSTED 唯一裁决点 = tools/pre-execute 钩子（扣减前判定）；
+  // guard 层可能在 pre-execute 扣减之后运行（收到已扣 contract），若在此重判会误拒“预算内”调用（允许 N 实际 N-1）。
+  if (dec.reasonCode === "AGENT_BUDGET_EXHAUSTED") return null;
   if (dec.outcome === "deny") {
     return makeHit(
       { ruleId: "__task-contract", title: `任务契约：${dec.reasonCode}`, action: "deny" },
@@ -350,6 +354,21 @@ 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;
     // 只使用本回合的 scopes（execute 子句 + 本回合 ask 授权已由 handleSessionEvent 写入 turn.scopes）；
     // 不再把 session.authorizations 里历史 ask 授权拉进来，避免上一轮授权放宽本轮。
     const scopes = Array.isArray(session.turn.scopes) && session.turn.scopes.length > 0
@@ -405,7 +424,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) {
@@ -480,7 +499,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 本身即用户对受保护配置的授权
@@ -571,7 +590,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/intent.js

@@ -25,15 +25,15 @@ export const TAG_RE = /【(执行|方案|问询|信息)】/;
 export const QUESTION_RE = /[？?]|吗|为什么|是否|能不能|行不行|难道|是不是|能否|怎么|为何|是否要|影响吗|可以吗|要不要|需不需要/;
 
 const DEFER_RE = /待确认|确认后再|等我确认|先方案|先别|不要执行|之后再说|确认后|再确认|先确认|不要直接/;
-const ACTION_RE = /执行|落盘|开始|写入|写(?:下|好|完|成|作|文件)?|保存|另存为|删除|修改|改(?:为|成|动|一下|进|善)?|补(?:上|齐|全|充|写)?|修(?:改|复|一下)?|做(?:好|完|一下)?|创建|安装|发布|下载|提交|运行|修复|替换|重建|启动|重启|停止|卸载|开始改|开始写|改进|优化|增强|完善|升级|迁移|整理|调整|实现|实施|添加|增加|补充|重写|改造|调试|排查|处理|解决|继续|推进|更新|部署|核实|梳理|诊断|对齐|跟进|落实|设计并实现|调查|开工|动手|进行|完成|产出|编写|撰写|生成|审查|阅读|查看|核对|检查|审阅|复核|查阅|验证|对照|调研|研究/;
+const ACTION_RE = /执行|落盘|开始|写入|写(?:下|好|完|成|作|文件)?|保存|另存为|删除|修改|改(?:为|成|动|一下|进|善)?|补(?:上|齐|全|充|写)?|修(?:改|复|一下)?|做(?:好|完|一下)?|创建|安装|发布|下载|提交|运行|修复|替换|重建|启动|重启|停止|卸载|开始改|开始写|改进|优化|增强|完善|升级|迁移|整理|调整|实现|实施|添加|增加|补充|重写|改造|调试|排查|处理|解决|继续|推进|更新|部署|核实|梳理|诊断|对齐|跟进|落实|设计并实现|调查|开工|动手|进行|完成|选择|采纳|选定|产出|编写|撰写|生成|审查|阅读|查看|核对|检查|审阅|复核|查阅|验证|对照|调研|研究/;
 const PLAN_RE = /方案|建议|评估|分析|设计|规划|计划|给出|提供/;
-const STRONG_EXEC_RE = /执行吧|开始执行|直接执行|立即执行|现在执行|马上执行|请落盘|开始写|开始改|执行以下|执行第|执行这个|执行它|落盘|开始蒸馏|开始迁移|开始修复|开始改进|开始优化/;
+const STRONG_EXEC_RE = /执行吧|开始执行|直接执行|立即执行|现在执行|马上执行|请落盘|开始写|开始改|执行以下|执行第|执行这个|执行它|落盘|开始蒸馏|开始迁移|开始修复|开始改进|开始优化|采纳|选定/;
 const NUMBERED_ITEM_RE = /^\s*(?:\(?(\d+)[\)、.．)]\s*)/;
 
 // 状态信号：对先前指令的就绪/完成确认（“我已重启 / 已输入 / 重启完成 / 好了 / done”）。
 // 语义 = 与“无用户消息回合”同等待遇：不触发规则 22 的“无执行分点”判定（规则 22⑩）。
 export const STATUS_SIGNAL_RE =
-  /(?:我已|我已经|我(?:们)?(?:刚)?(?:重启|输入|执行|完成|搞定|做完|弄好|输完|输好))(?:了|完毕|完成|好)?|(?:^|\s)(?:已|已经)?(?:重启|输入|执行|完成|搞定|做完|弄好|输完|输好|unlock)(?:了|完毕|完成|好)?(?:\s|$)|(?:^|\s)(?:重启|输入|命令|操作)(?:完成|完毕|好了|已输入)(?:\s|$)|(?:^|\s)好了(?:\s|$)|^(?:done|restarted|finished|entered)$/i;
+  /(?:我已|我已经|我(?:们)?(?:刚)?(?:重启|输入|执行|完成|搞定|做完|弄好|输完|输好))(?:了|完毕|完成|好)?|(?:^|\s)(?:已|已经)?(?:重启|输入|执行|完成|搞定|做完|弄好|输完|输好|unlock)(?:了|完毕|完成|好)?(?:\s|$)|(?:^|\s)已经(?:刚)?(?:重启|输入|执行|完成|搞定|做完|弄好|输完|输好|unlock)[^\s]*(?:\s|$)|(?:^|\s)(?:重启|输入|命令|操作)(?:完成|完毕|好了|已输入)(?:\s|$)|(?:^|\s)好了(?:\s|$)|^(?:done|restarted|finished|entered)$/i;
 
 // 危险动作词：命中则不当状态信号（防“我已删除了某文件”被当成就绪确认）
 const DANGEROUS_ACTION_RE = /删除|覆盖|移除|清空|卸载|remove-item|rm\s+-r|del\s+/i;

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,8 @@ 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");
+}

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)\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,10 @@ export function auditOutputFailed(output) {
   return /DUPLICATES FOUND|INCONSISTENT|\[MISSING\]/i.test(String(output || ""));
 }
 
-/** 判断是否命中敏感操作（需要授权证据；只读操作永远不算） */
-export function isSensitiveToolCall(toolName, args) {
+/** 判断是否命中敏感操作（需要授权证据；只读操作永远不算）
+ *  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 +461,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 +485,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);
@@ -112,6 +132,7 @@ export function getSessionState(state, sessionId) {
   if (!s) {
     s = {
       id: key,
+      ruleStats: {}, // C2：每规则 detected/suppressed/injected 统计（会话级，跨回合累计）
       manualReadSeen: false,
       lastUserText: "",
       selfCertCount: new Map(),
@@ -205,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";
 
@@ -51,6 +53,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
@@ -74,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,
@@ -119,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) {
@@ -223,5 +242,26 @@ 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++;
+    }
+  }
+  // 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 } 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,9 +177,39 @@ 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）计数（实际投递尝试，上限内）
+  {
+    const sStat = getSessionState(state, sessionId);
+    const st = (sStat.ruleStats ||= {});
+    const k = (st[violation.ruleId] ||= { detected: 0, suppressed: 0, injected: 0 });
+    k.injected++;
+  }
   const timer = setTimeout(() => {
     pendingInjectTimers.delete(timer);
     try {
@@ -207,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();
@@ -216,6 +297,15 @@ async function refreshSkills(ctx) {
   }
 }
 
+/** v0.5.7 P0-4：验证通过记录持久化（文件损坏/写失败不阻断运行时） */
+function persistVerifyPass(state) {
+  try {
+    writeFileSync(verifyFilePath(), JSON.stringify((state.verifyPass || []).slice(-100)), "utf8");
+  } catch {
+    // 持久化失败仅降级（内存态仍有效），不阻断
+  }
+}
+
 export function handleSessionEvent(ctx, session, event) {
   maybeReloadIfChanged(state);
   const sid = session?.id || "global";
@@ -298,6 +388,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 范围
@@ -560,10 +651,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：持久化（热重载/重启不丢）
       }
     }
 
@@ -590,6 +682,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);
         // 授权范围只取“问题核心 + 用户实际选择”，不再把全部选项描述纳入；
@@ -664,6 +757,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;
@@ -720,7 +816,25 @@ export function handleSessionEvent(ctx, session, event) {
         reason: v.reason,
         session: sid
       });
-      maybeInject(ctx, sid, v);
+    }
+    // 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: `本轮检出 ${immediate.length} 项：${briefs}——请按 /guard log 明细应对`
+      });
+    } 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 }));
@@ -945,12 +1059,25 @@ 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 {
+    // 首次运行/文件缺失：无历史记录，正常
   }
 
   // 0.0.1 LLM 意图兜底配置（guardDecision 为纯函数，经 state 传入）
@@ -1005,6 +1132,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 自证③：方案性指令 ≠ 落盘授权）
         {
@@ -1127,15 +1265,32 @@ export function apply(ctx) {
     }
   });
 
-  // 1.1 任务契约 ask 通道：仅在总开关 + askEnabled 时对“应询问”动作返回 ask
+  // 1.1 任务契约裁决钩子：deny 物理拒绝 + ask 通道 + 委托预算启动即计。
+  // 2026-08-25 修复（预算语义偏差，实弹：第 2 个子代理被误拒——允许 N 实际 N-1）：
+  // 根因 = 扣减（本钩子）先于 guard 层的 decideContractAction（L1138 用已扣 contract 重判 → 2+1>2 → 误拒）。
+  // 修复 = 本钩子成为契约唯一裁决点（deny 在扣减**前**判定并物理拒绝），guard 层跳过预算类 deny（防双判）。
   ctx.on("tools/pre-execute", async (exec, next) => {
     try {
-      if (!state.taskContract?.taskContractEnabled || !state.taskContract?.askEnabled) return next();
+      if (!state.taskContract?.taskContractEnabled) return next();
       const sid = sessionIdOfExec(exec);
       const s = getSessionState(state, sid);
       if (!isArmed(s.contract, state.taskContract)) return next();
       const action = classifyAction(exec?.name, exec?.arguments);
       const dec = decideContractAction({ contract: s.contract, action, config: state.taskContract });
+      // deny（在扣减前判定，语义=本次调用发生时点）
+      if (dec.outcome === "deny") {
+        audit({
+          kind: "task-contract-deny",
+          rule: "__task-contract",
+          name: `任务契约拒绝：${dec.reasonCode}`,
+          event: "tools/pre-execute",
+          tool: exec?.name,
+          args: summarizeArgs(exec?.arguments),
+          reason: dec.reason,
+          session: sid
+        });
+        return { kind: "deny", reason: `【硬拦截】${dec.reason}（${dec.reasonCode}｜任务契约｜放行：${dec.nextStep || "请调整契约"}）` };
+      }
       // 批次 5.5（2026-08-24）：委托启动即计预算——原 tool/result 扣减因 subagent 无 pendingCall 从未执行（agents 恒 0）
       if (dec.outcome === "allow" && action.mutability === "delegate" && action.delegationCount > 0) {
         s.contract = consumeDelegateBudget(s.contract, action.delegationCount);

package/lib/service.js

@@ -16,7 +16,8 @@ const REMOTE_METHODS = [
   "getAuditLog",
   "getUnderstanding",
   "getTaskContractConfig",
-  "setTaskContractConfig"
+  "setTaskContractConfig",
+  "getRuleStats"
 ];
 
 function currentVersion() {
@@ -210,6 +211,39 @@ class RuleEngineService extends TypertRemoteService {
       return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
   }
+
+  /** C2 轻量版：规则统计（detected/suppressed/injected，会话聚合；只读） */
+  async getRuleStats() {
+    try {
+      const rows = aggregateRuleStats(state.sessions.values());
+      return {
+        ok: true,
+        stats: rows,
+        totals: rows.reduce((t, r) => ({
+          detected: t.detected + r.detected,
+          suppressed: t.suppressed + r.suppressed,
+          injected: t.injected + r.injected
+        }), { detected: 0, suppressed: 0, injected: 0 }),
+        sessions: state.sessions.size
+      };
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+}
+
+/** 纯函数：聚合各会话 ruleStats（C2，可独立测试） */
+export function aggregateRuleStats(sessions) {
+  const merged = {};
+  for (const s of sessions) {
+    for (const [ruleId, st] of Object.entries(s.ruleStats || {})) {
+      const m = (merged[ruleId] ||= { ruleId, detected: 0, suppressed: 0, injected: 0 });
+      m.detected += st.detected || 0;
+      m.suppressed += st.suppressed || 0;
+      m.injected += st.injected || 0;
+    }
+  }
+  return Object.values(merged).sort((a, b) => b.detected - a.detected);
 }
 
 export { RuleEngineService, RuleEngineService as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-rule-engine",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "DSH 规则执行引擎 v3：容器解析 AGENTS.md + 理解器 + 匹配机 + 执行框架",
   "type": "module",
   "main": "lib/index.js",

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");