dsh-rule-engine 0.5.4 → 0.5.6

package/lib/core/guard-core.js

@@ -22,7 +22,10 @@ import {
   isVariablePath,
   pathTarget
 } from "./patterns.js";
-import { describeAuth, describeOp, findMatchingAuth, operationOf, askQuestionText, inferPathPrefixFromText, inferTypeFromText } from "./authorization.js";
+import { authMatches, describeAuth, describeOp, describeScopes, findMatchingAuth, operationOf, askQuestionText, inferPathPrefixFromText, inferTypeFromText, scopesFromIntents } from "./authorization.js";
+import { parseUserIntents, shouldDenyMutation } from "./intent.js";
+import { toolClass } from "./tool-catalog.js";
+import { verdictForDeny } from "./llm-intent.js";
 import { computeMountSignature, profileNameFromArgs } from "./mount-signature.js";
 import { findBackupForPath, getSessionState, maybeReloadIfChanged } from "./state.js";
 import { isVersionedFile, validateEditedFile } from "./version-guard.js";
@@ -44,7 +47,7 @@ const RULE_HINTS = {
   "13A": "先对目标路径执行备份（复制到 .bak/.backups/trash-）",
   "18": "先读取 ~/.dsh/skills/dsh-usage-manual/SKILL.md",
   "21": "按规则 21 分级确认后再落盘",
-  "22": "先回答/展示方案，待用户明确授权（非疑问句+动作词，或 ask 授权答复）后再执行",
+  "22": "先回答/展示方案，或补充明确执行分点（工具类别+路径范围）；已授权变更必须落在本回合执行分点/ask 授权范围内",
   "24": "确认插件 dsh.bundle 类型或改用正确挂载",
   "27": "先运行 node scripts/audit-mount-consistency.mjs --profile web"
 };
@@ -60,11 +63,11 @@ function makeHit(cfg, reason) {
   };
 }
 
-const COVERED_MUTATION_TOOLS = new Set([
+export const COVERED_MUTATION_TOOLS = new Set([
   "edit", "write", "str_replace_editor", "pwsh", "bash",
   "dev_stage_add", "dev_stage_call", "dev_stage_promote", "dev_stage_demote"
 ]);
-const SAFE_UNCOVERED_TOOLS = new Set([
+export const SAFE_UNCOVERED_TOOLS = new Set([
   "ask_user_question", "todo_write", "subagent", "workflow", "visualize", "skill",
   "read", "grep", "glob", "read_image", "job_list", "job_output", "list_agents",
   "get_goal", "dev_plugin_status", "dev_reload_package", "dev_injected_list",
@@ -174,6 +177,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" },
@@ -190,7 +196,7 @@ function taskContractGuardDecision(state, exec, session) {
  * @param {number} now
  * @returns {object|null}
  */
-export function guardDecision(state, exec, now = Date.now()) {
+export function guardDecision(state, exec, now = Date.now(), opts = {}) {
   if (state.enabled === false) return null;
   if (state.bypassUntil > now) return null;
   maybeReloadIfChanged(state, now);
@@ -208,16 +214,24 @@ export function guardDecision(state, exec, now = Date.now()) {
   const contractHit = taskContractGuardDecision(state, exec, session);
   if (contractHit) return contractHit;
 
-  // E3：已有匹配授权时，拦截重复 ask_user_question，避免 AI 反复询问已授权事项
+  // ask_user_question 必须真正送达用户；已有授权不再吞弹窗（2026-08-24 修复：
+  // __already-authorized 之前会把 ask 拦截成内部“已有授权”，导致用户收不到任何弹窗）
   if (name === "ask_user_question") {
     const qText = askQuestionText(args?.questions);
     if (qText) {
-      const op = { type: inferTypeFromText(qText), pathPrefix: inferPathPrefixFromText(qText) };
-      const auth = findMatchingAuth([...(session.authorizations || []), ...(state.globalAuthorizations || [])], op);
-      if (auth) {
+      // 弹窗消减（2026-08-24）：本回合 ask 已被拒 → 再次 ask 直接拦（提示改用普通文本）
+      if (session.turn.askRejected) {
         return makeHit(
-          { ruleId: "__already-authorized", title: "已有授权，无需重复询问", action: "deny" },
-          `【提示】本次询问范围 ${describeOp(op)} 已有匹配授权：${describeAuth(auth)}。无需重复 ask，请继续执行。`
+          { ruleId: "__ask-rejected", title: "本回合 ask 已被拒绝", action: "deny" },
+          `【提示】本回合的 ask 已遭拒绝，请勿再次弹窗询问；改用普通文本说明即可（规则 22 沟通直接性）。`
+        );
+      }
+      // 5 分钟内已有被拒的 ask 记录 → 拦（防连环弹窗 → not-pending 诱因链）
+      const recentReject = (state.askRejections || []).some((r) => r.sessionId === session.id && now - r.at < 5 * 60 * 1000);
+      if (recentReject) {
+        return makeHit(
+          { ruleId: "__ask-throttle", title: "ask 请求过频", action: "deny" },
+          `【提示】5 分钟内已发起过 ask 且遭拒绝，请改用普通文本说明，勿连环弹窗询问。`
         );
       }
     }
@@ -266,29 +280,92 @@ export function guardDecision(state, exec, now = Date.now()) {
 
   for (const cfg of state.configs) {
     if (cfg.disabled) continue;
-    // 低置信规则不硬拦（保守不误拦，交给 /guard rules 人工复核）
-    if (cfg.confidence === "low") continue;
+    // 低置信规则不硬拦（保守不误拦，交给 /guard rules 人工复核）——批次 3：跳过必须留痕（N2 防御可观测）
+    if (cfg.confidence === "low") {
+      opts?.audit?.({
+        kind: "n2-skip",
+        rule: cfg.ruleId,
+        name: "低置信规则跳过",
+        event: "tool/guard",
+        reason: `规则 ${cfg.ruleId} 理解低置信 → 跳过硬拦（保守不误拦；请在 /guard rules 对该规则复核）`,
+        session: sessionIdOf(exec)
+      });
+      continue;
+    }
     // 分级执行：只有 A 硬拦 / C 时序 / M 元规则才进入工具守卫
     const actions = cfg.actions || [];
     if (!actions.some((a) => a === "deny" || a === "ask" || a === "meta")) continue;
-    const hit = matchRule(cfg, { name, args, p, cmd, session, unlock, state, now });
+    const hit = matchRule(cfg, { name, args, p, cmd, session, unlock, state, now, audit: opts?.audit, exec });
     if (hit) return hit;
   }
   return null;
 }
 
 function matchRule(cfg, ctx) {
-  const { name, args, p, cmd, session, unlock, state, now } = ctx;
+  const { name, args, p, cmd, session, unlock, state, now, audit, exec } = ctx;
   const id = String(cfg.ruleId);
+  // 防热重载/事件顺序导致意图状态落后：若当前 turn.userText 与已缓存 intents.raw 不一致，
+  // 或尚无 intents 但有用户文本，则以最新用户文本重新解析并回写，避免用旧状态误拦。
+  // P0-3 根修（2026-08-24）：裁决基底只用“本回合”的真实用户文本（turn.userText），
+  // 不再回退 lastUserText——上一轮残留文本（如含“为什么”的询问）不得裁决本轮。
+  const currentText = session.turn.userText || "";
+  let turnIntents = session.turn.intents;
+  if (turnIntents && currentText && turnIntents.raw !== currentText) {
+    turnIntents = parseUserIntents(currentText);
+    session.turn.intents = turnIntents;
+  } else if (!turnIntents && currentText) {
+    turnIntents = parseUserIntents(currentText);
+    session.turn.intents = turnIntents;
+  }
+  // 无用户消息回合（委派/ask 答复后/状态信号）不做规则 22 判定；敏感操作由 12A/13A 独立把关
+  const denyMutation = turnIntents
+    ? shouldDenyMutation(turnIntents, session.turn.askSeen && !session.turn.askRejected)
+    : false;
 
-  // 规则 22⑦ 机器化：用户消息是疑问句 → 本回合禁止变更类工具调用
+  // 规则 22 机器化：无执行分点/存在歧义 → 本回合禁止变更类工具调用
   //（"你的执行方案难道没问题吗？"虽含"执行"仍是疑问句——同形词不构成指令，不豁免）
   if (cfg.handler === "rule22-7-direct") {
-    if (session.turn.questionOnly) {
-      if (isReadOnlyTool(name, args)) return null; // 只读 → 豁免③
-      if (SAFE_UNCOVERED_TOOLS.has(name)) return null; // 展示/授权/查询类（含 ask_user_question）→ 豁免③
-      return makeHit(cfg, `【硬拦截】用户消息是疑问句而非授权（规则 22⑦）：请先回答/展示方案，待用户明确授权后再执行（放行：非疑问句+动作词，或 ask_user_question 授权答复）`);
+    // 机制 B（2026-08-24）：工具分类制（纯函数，覆盖现有与未来插件注册的全部工具）——
+    // control（SAFE 无条件放行）/ analysis（只读分析放行）/ artifact（产物放行+审计）/
+    // unknown（物理不拦，由 pre-execute ask 层首调询问，防新插件绕过）；mutating 维持原有严格逻辑。
+    if (SAFE_UNCOVERED_TOOLS.has(name)) return null; // 授权/委托/技能/查询展示类 → 无条件放行
+    const cls = toolClass(name, args);
+    if (cls === "analysis") return null;
+    if (cls === "artifact") {
+      audit?.({ kind: "allow", rule: cfg.ruleId, name: "产物类工具放行", tool: name, reason: `分类 artifact（低风险产物写入，留痕可对账）：${describeOp(operationOf(name, args))}`, session: sessionIdOf(exec) });
+      return null;
+    }
+    if (cls === "unknown") return null; // 物理不拦；pre-execute ask 层首调询问
+    if (denyMutation) {
+      // LLM 意图兜底（方案 A，2026-08-24）：词表判拦 + LLM 高/低置信判 execute → 放行
+      //（非对称：LLM 只解救不收紧；审计在预取时已记 intent-llm）
+      const verdict = verdictForDeny(session.turn, state.llmIntentCfg || {});
+      if (!verdict.mutationDenied) return null;
+      if (isReadOnlyTool(name, args)) return null; // 只读 → 豁免
+      const llmNote = verdict.source === "llm-low" ? "（LLM 低置信未能挽救）" : "";
+      return makeHit(cfg, `【硬拦截】用户消息是询问/没有明确执行分点（规则 22）${llmNote}：请先回答/展示方案，待用户明确授权后再执行（放行：存在执行分点，或 ask_user_question 授权答复）`);
     }
+    // 规则 22 粒度升级（2026-08-24，用户点名治本项）：
+    // 存在执行分点时不再"同回合一词放行"，而是逐项比对本次变更是否落在
+    // 本回合 execute 子句或 ask 授权的「工具类别 + 路径前缀」范围内；未覆盖 → 拦。
+    // 无用户消息/状态信号/ask 答复后回合仍不做规则 22 判定（由 12A/13A 把关）。
+    if (!turnIntents || !turnIntents.hasExecute) return null;
+    if (isReadOnlyTool(name, args)) return null;
+    if (!COVERED_MUTATION_TOOLS.has(name) && !looksLikeFileMutation(name, args)) return null;
+    const op = operationOf(name, args);
+    // 保护性备份豁免（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
+      ? session.turn.scopes
+      : scopesFromIntents(turnIntents);
+    if (!scopes.some((scope) => authMatches(scope, op))) {
+      return makeHit(cfg, `【硬拦截】本次变更操作不在本回合执行分点/授权范围内（规则 22）：已授权范围 [${describeScopes(scopes)}]；本次操作 [${describeOp(op)}]。请补充明确授权（可用 ask_user_question）后再执行`);
+    }
+    // 可观测性（阶段 0，2026-08-24）：规则 22 粒度放行是最高频放行路径，必须留痕可查
+    audit?.({ kind: "allow", rule: cfg.ruleId, name: "授权命中放行", tool: name, reason: `由授权放行（规则 22 粒度命中）：${describeScopes(scopes)} 覆盖 ${describeOp(op)}`, session: sessionIdOf(exec) });
     return null;
   }
 
@@ -346,7 +423,11 @@ function matchRule(cfg, ctx) {
       if (targetPath && isVariablePath(targetPath)) return null;
       // 已获 12A/12D 授权的操作 = 用户已明确确认本次操作 → 跳过 13A 机械备份（P1-2，一次授权覆盖全规则）
       // 但高风险运行入口文件除外：即使已授权也必须有备份证据或明确提示
-      if (findMatchingAuth([...(session.authorizations || []), ...(state.globalAuthorizations || [])], op) && !isHighRiskEntryFile(targetPath)) return null;
+      const auth13 = findMatchingAuth([...(session.authorizations || []), ...(state.globalAuthorizations || [])], op);
+      if (auth13 && !isHighRiskEntryFile(targetPath)) {
+        audit?.({ kind: "allow", rule: cfg.ruleId, name: "授权命中放行", tool: name, reason: `由授权放行（13A 跳过备份）：${describeAuth(auth13)}`, session: sessionIdOf(exec) });
+        return null;
+      }
       // 复制/新建到“尚不存在”的目标文件：属于创建新文件，不适用 13A 覆盖备份要求
       const isCreateNewTarget = !highRiskWrite && cmd && /copy-item|new-item/i.test(cmd) && targetPath && !existsSync(targetPath);
       if (!isCreateNewTarget) {
@@ -365,14 +446,18 @@ function matchRule(cfg, ctx) {
   }
 
   // 规则 12B：技能调用四步时序（关键词→授权→调用；豁免技能除外）
-  if (cfg.handler === "rule12b-skill" || (cfg.hints || []).includes("skill")) {
+  // 2026-08-24 修复：旧条件 `handler==='rule12b-skill' || hints.includes('skill')` 会把
+  // hints 含 "skill" 的其它规则 cfg（如 12A：hints=["ask","skill","sensitive",...]）截胡——
+  // 非 skill 工具时 return null，导致 12A 敏感授权检查静默失效（C-2 实测 Move-Item 放行）。
+  // 现在：hints 兜底仅在「name === 'skill'」时进入；handler 明确为 rule12b-skill 时维持原语义。
+  if (cfg.handler === "rule12b-skill") {
     if (name === "skill") {
       const skillName = typeof args?.name === "string" ? args.name : "";
       if (SKILL_EXEMPT.has(skillName)) return null;
       // 技能目录实时联动：已加载目录且该技能不存在/被禁用时，规则不激活
       if (state.skillNames && state.skillNames.size > 0 && !state.skillNames.has(skillName)) return null;
-      if (session.turn.questionOnly) {
-        return makeHit(cfg, `【硬拦截】当前用户消息是询问而非授权，技能 ${skillName} 未获授权`);
+      if (denyMutation) {
+        return makeHit(cfg, `【硬拦截】当前用户消息是询问/没有明确执行分点，技能 ${skillName} 未获授权`);
       }
       const op = { type: "skill", pathPrefix: "" };
       const auth = findMatchingAuth([...(session.authorizations || []), ...(state.globalAuthorizations || [])], op);
@@ -380,6 +465,21 @@ function matchRule(cfg, ctx) {
         const existing = session.authorizations.map(describeAuth).join("；") || "无";
         return makeHit(cfg, `【硬拦截】技能调用缺少匹配授权：${skillName}（已有授权：${existing}；本次范围：${describeOp(op)}）`);
       }
+      audit?.({ kind: "allow", rule: cfg.ruleId, name: "授权命中放行", tool: name, reason: `由授权放行（技能 ${skillName}）：${describeAuth(auth)}`, session: sessionIdOf(exec) });
+      return null;
+    }
+    return null;
+  }
+  if ((cfg.hints || []).includes("skill") && name === "skill") {
+    // hints 兜底：理解器未分配 handler 但 hints 含 skill 的 cfg——仅 skill 工具时参与，不截胡其它规则
+    const skillName = typeof args?.name === "string" ? args.name : "";
+    if (SKILL_EXEMPT.has(skillName)) return null;
+    if (state.skillNames && state.skillNames.size > 0 && !state.skillNames.has(skillName)) return null;
+    const op = { type: "skill", pathPrefix: "" };
+    const auth = findMatchingAuth([...(session.authorizations || []), ...(state.globalAuthorizations || [])], op);
+    if (!auth) {
+      const existing = session.authorizations.map(describeAuth).join("；") || "无";
+      return makeHit(cfg, `【硬拦截】技能调用缺少匹配授权：${skillName}（已有授权：${existing}；本次范围：${describeOp(op)}）`);
     }
     return null;
   }
@@ -392,14 +492,18 @@ function matchRule(cfg, ctx) {
       // /guard unlock 本身即用户对受保护配置的授权
       if (unlock && isProtectedConfigPath(p)) return null;
       const op = operationOf(name, args);
-      if (session.turn.questionOnly) {
-        return makeHit(cfg, `【硬拦截】当前用户消息是询问而非授权，未构成授权证据（本次操作：${describeOp(op)}）`);
+      // 规则 12A 正文豁免：保护性备份（创建/复制/移动文件到 .backups/ 或 .backups/trash-<时间戳>/）免询问
+      if (op.type === "backup") return null;
+      if (denyMutation) {
+        return makeHit(cfg, `【硬拦截】当前用户消息是询问/没有明确执行分点，未构成授权证据（本次操作：${describeOp(op)}）`);
       }
       const auth = findMatchingAuth([...(session.authorizations || []), ...(state.globalAuthorizations || [])], op);
       if (!auth) {
         const existing = session.authorizations.map(describeAuth).join("；") || "无";
         return makeHit(cfg, `【硬拦截】敏感操作缺少匹配授权：已有授权范围 [${existing}]；本次操作范围 [${describeOp(op)}]`);
       }
+      audit?.({ kind: "allow", rule: cfg.ruleId, name: "授权命中放行", tool: name, reason: `由授权放行（12A 敏感操作）：${describeAuth(auth)}`, session: sessionIdOf(exec) });
+      return null;
     }
     return null;
   }
@@ -477,14 +581,15 @@ function matchRule(cfg, ctx) {
     if (p && MANUAL_PATH_RE.test(p)) return null;
     if (unlock && isProtectedConfigPath(p)) return null;
     const op = operationOf(name, args);
-    if (session.turn.questionOnly) {
-      return makeHit(cfg, `【硬拦截】当前用户消息是询问而非授权（本次操作：${describeOp(op)}）`);
+    if (denyMutation) {
+      return makeHit(cfg, `【硬拦截】当前用户消息是询问/没有明确执行分点（本次操作：${describeOp(op)}）`);
     }
     const auth = findMatchingAuth([...(session.authorizations || []), ...(state.globalAuthorizations || [])], op);
     if (!auth) {
       const existing = session.authorizations.map(describeAuth).join("；") || "无";
       return makeHit(cfg, `【硬拦截】${cfg.title}：缺少匹配授权（已有：${existing}；本次：${describeOp(op)}）`);
     }
+    audit?.({ kind: "allow", rule: cfg.ruleId, name: "授权命中放行", tool: name, reason: `由授权放行（${cfg.title}）：${describeAuth(auth)}`, session: sessionIdOf(exec) });
   }
   return null;
 }

package/lib/core/intent.js

@@ -0,0 +1,267 @@
+// intent.js - 用户消息子句级意图解析（规则 22 分点语义的引擎侧实现）。
+// 输入同一条用户消息，输出：
+//   - 按数字列表/标签/单条消息切分出的子句
+//   - 每个子句的意图类型：execute / plan / question / info / status / ambiguous
+//   - 聚合标志：hasExecute / hasPlan / hasQuestion / hasStatus / ambiguous
+//
+// 设计原则：
+//   - 数字列表是确定性切分结构；
+//   - 标签是高置信语义标注；
+//   - 无标签时用保守规则分类，宁可少授权、不多授权。
+//   - “可以执行吗？”是询问，不是执行授权；
+//   - “请给出执行方案”是方案请求，不是执行授权；
+//   - “我已重启/已输入”等状态信号（规则 22⑩）是对先前指令的就绪确认：
+//     不构成执行授权、也不触发“无执行分点”拦截；变更类操作仍由 12A/13A 把关。
+//
+// 2026-08-24（v0.5.5 规划，事故复盘 P1-5/P0-3/规则 22⑩）：
+//   - 词表单一来源：QUESTION_RE 同时供 authorization.isQuestionMessage 使用，
+//     消灭“两套疑问词判定不一致”（如 authorization 的“影响吗”与 intent 的“怎么”）。
+//   - 新增 STATUS_SIGNAL_RE / isStatusSignal()：状态信号分类（宽松版，危险词排除，
+//     12A/13A 兜底），与“无用户消息回合”同等待遇。
+
+export const TAG_RE = /【(执行|方案|问询|信息)】/;
+
+// 统一疑问词表（合并原 intent 与 authorization 两套：怎么/为何 + 影响吗/可以吗/要不要/需不需要）
+export const QUESTION_RE = /[？?]|吗|为什么|是否|能不能|行不行|难道|是不是|能否|怎么|为何|是否要|影响吗|可以吗|要不要|需不需要/;
+
+const DEFER_RE = /待确认|确认后再|等我确认|先方案|先别|不要执行|之后再说|确认后|再确认|先确认|不要直接/;
+const ACTION_RE = /执行|落盘|开始|写入|写(?:下|好|完|成|作|文件)?|保存|另存为|删除|修改|改(?:为|成|动|一下|进|善)?|补(?:上|齐|全|充|写)?|修(?:改|复|一下)?|做(?:好|完|一下)?|创建|安装|发布|下载|提交|运行|修复|替换|重建|启动|重启|停止|卸载|开始改|开始写|改进|优化|增强|完善|升级|迁移|整理|调整|实现|实施|添加|增加|补充|重写|改造|调试|排查|处理|解决|继续|推进|更新|部署|核实|梳理|诊断|对齐|跟进|落实|设计并实现|调查|开工|动手|进行|完成|选择|采纳|选定|产出|编写|撰写|生成|审查|阅读|查看|核对|检查|审阅|复核|查阅|验证|对照|调研|研究/;
+const PLAN_RE = /方案|建议|评估|分析|设计|规划|计划|给出|提供/;
+const STRONG_EXEC_RE = /执行吧|开始执行|直接执行|立即执行|现在执行|马上执行|请落盘|开始写|开始改|执行以下|执行第|执行这个|执行它|落盘|开始蒸馏|开始迁移|开始修复|开始改进|开始优化|采纳|选定/;
+const NUMBERED_ITEM_RE = /^\s*(?:\(?(\d+)[\)、.．)]\s*)/;
+
+// 状态信号：对先前指令的就绪/完成确认（“我已重启 / 已输入 / 重启完成 / 好了 / done”）。
+// 语义 = 与“无用户消息回合”同等待遇：不触发规则 22 的“无执行分点”判定（规则 22⑩）。
+export const STATUS_SIGNAL_RE =
+  /(?:我已|我已经|我(?:们)?(?:刚)?(?:重启|输入|执行|完成|搞定|做完|弄好|输完|输好))(?:了|完毕|完成|好)?|(?:^|\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;
+
+/** DSH 在会话上下文里注入的系统文本（工作区指令/技能目录等），不是用户的真实消息 */
+export function isInjectedContextMessage(text) {
+  const t = String(text || "");
+  return t.includes("<system-reminder>") || t.includes("</system-reminder>");
+}
+
+/**
+ * 规则引擎自身注入的纠正/提示消息（maybeInject 发出，前缀 [规则引擎]），不是用户消息。
+ * 2026-08-24 修复：此前这类文本含“请直接执行/继续执行”，会被 handleSessionEvent 当成用户执行分点
+ * 并 recordAuthorization → 引擎自我续授权，导致 /guard revoke 后仍会被自己加回全局授权。
+ */
+export function isEngineInjectedMessage(text) {
+  const t = String(text || "").trim();
+  return t.startsWith("[规则引擎]");
+}
+
+// 已知系统注入模板（机制 A 兜底层，2026-08-24）：
+// source.kind 主判之外，对"标记为 user 但实为注入"的消息做模板兜底——
+// 命中即整体跳过：不覆盖回合状态、不产生 scopes/授权。
+// 本机实证来源：runtime context 快照（无 system-reminder 标签）、子代理完成通知（B3）、
+// vision-router 自动挂载提醒（index.js:3494-3518）、引擎自身注入（[规则引擎]）。
+// super-injector 的近距离引导模板待实测后收窄补充。
+const SYSTEM_INJECTION_PREFIXES = [
+  /^Current runtime context\./,
+  /^Background subagent\b/,
+  /^\[规则引擎\]/,
+  /^本轮消息包含图片，像素级视觉工具已自动挂载/
+];
+
+/** 整条文本是否为"已知系统注入"（不是用户想说的事） */
+export function isKnownSystemInjection(text) {
+  const t = String(text || "").trim();
+  return SYSTEM_INJECTION_PREFIXES.some((re) => re.test(t));
+}
+
+/**
+ * 剥离 system-reminder 注入块，返回剩余用户文本。
+ * 2026-08-24 v2：注入可能与真实用户消息合并为同一事件（本会话实测模式：
+ * <system-reminder> 块 + 用户文本同在一个 content 数组，整条跳过会把真实消息也丢弃）。
+ * 无注入 → 原样返回；纯注入 → 空串（调用方按"跳过"处理）。
+ */
+export function stripInjectedContext(text) {
+  const t = String(text || "");
+  if (!t.includes("<system-reminder>")) return t;
+  return t.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
+}
+
+/** 状态信号判定（规则 22⑩）：对先前指令的就绪确认，且不含危险动作词 */
+export function isStatusSignal(text) {
+  const t = String(text || "");
+  // 命令式排除（2026-08-25 RB-05）：行首裸“完成/重启/执行/搞定等 + 空格 + 宾语”= 命令
+  //（“完成 A 和 C 两项”/“重启服务”），不是对先前指令的就绪确认；状态信号须带“已/我已完成”前缀
+  // 或“了/完成/完毕/好”后缀（根因：STATUS_SIGNAL_RE 的“裸词 + 可选后缀”分支把命令式误判为状态）。
+  if (/^(?:请|帮我)?\s*(?:先|接着|然后)?\s*(?:完成|重启|执行|搞定|做完|弄好)\s+\S/.test(t.trim())) return false;
+  return STATUS_SIGNAL_RE.test(t) && !DANGEROUS_ACTION_RE.test(t);
+}
+
+function normalizeTag(tag) {
+  if (!tag) return null;
+  const t = tag.trim();
+  if (t === "执行") return "execute";
+  if (t === "方案") return "plan";
+  if (t === "问询") return "question";
+  if (t === "信息") return "info";
+  return null;
+}
+
+export function extractTag(text) {
+  const m = String(text || "").match(TAG_RE);
+  return m ? m[1] : "";
+}
+
+function splitClauses(text) {
+  const raw = String(text || "").trim();
+  if (!raw) return [];
+
+  // 同行内多个编号（"1、A 2、B"）：在编号前（前导空白处）插入换行，统一按行切分。
+  // 修复 2026-08-24 实测缺陷：同行编号列表被并入单子句，"方案"等词导致整条误判 plan。
+  // 保守：仅切分“编号前为空白”的项（"执行第2、3条"中"2、"前是汉字 → 不切）。
+  const normalized = raw.replace(/(?:\s)(\d+[\)、.．)])/g, "\n$1");
+  const lines = normalized.split(/\r?\n/);
+  const hasNumbered = lines.some((line) => NUMBERED_ITEM_RE.test(line));
+  const hasTagLines = lines.filter((line) => TAG_RE.test(line)).length >= 2;
+
+  if (!hasNumbered) {
+    if (hasTagLines) {
+      return lines
+        .map((line, i) => ({ id: String(i + 1), raw: line.trim() }))
+        .filter((c) => c.raw);
+    }
+    // 标题 + 正文 拆分：非标准【标签】的「【标题】正文」结构拆为两个子句，
+    // 使标题含动作词（如"改进/优化"）即构成执行分点，正文的疑问/描述不再掩盖标题意图（规则 22 混合指令）
+    const tm = raw.match(/^【([^】]{2,})】\s*([\s\S]+)$/);
+    if (tm && !normalizeTag(tm[1])) {
+      return [
+        { id: "t", raw: tm[1].trim() },
+        { id: "b", raw: tm[2].trim() }
+      ];
+    }
+    return [{ id: "1", raw }];
+  }
+
+  const clauses = [];
+  let current = null;
+
+  const pushCurrent = () => {
+    if (current && current.raw.trim()) clauses.push(current);
+    current = null;
+  };
+
+  for (const line of lines) {
+    const m = line.match(NUMBERED_ITEM_RE);
+    if (m) {
+      pushCurrent();
+      current = {
+        id: m[1],
+        raw: line.replace(NUMBERED_ITEM_RE, "").trim()
+      };
+    } else if (!current) {
+      // 编号前的引言/说明，单独作为一个前置子句
+      current = { id: "0", raw: line.trim() };
+    } else {
+      current.raw += (current.raw ? "\n" : "") + line.trim();
+    }
+  }
+  pushCurrent();
+
+  // 只有单个编号时也返回单子句，避免把“1. 执行吧”切成无意义列表
+  if (clauses.length <= 1 && clauses[0]?.id === "1") {
+    return [{ id: "1", raw: raw }];
+  }
+  return clauses;
+}
+
+function classifyClause(clause) {
+  const text = String(clause.raw || "").trim();
+  const tag = extractTag(text);
+  const tagType = normalizeTag(tag);
+  const hasQuestion = QUESTION_RE.test(text);
+  const hasDefer = DEFER_RE.test(text);
+  const hasAction = ACTION_RE.test(text);
+  const hasPlan = PLAN_RE.test(text);
+  const hasStrongExec = STRONG_EXEC_RE.test(text);
+
+  let type = "info";
+  let ambiguous = false;
+
+  if (tagType) {
+    if (tagType === "execute" && hasQuestion) {
+      type = "ambiguous";
+      ambiguous = true;
+    } else {
+      type = tagType;
+    }
+  } else if (hasQuestion) {
+    type = "question";
+  } else if (isStatusSignal(text)) {
+    type = "status";
+  } else if (hasDefer && hasAction) {
+    type = "plan";
+  } else if (hasPlan && !hasStrongExec) {
+    type = "plan";
+  } else if (hasAction) {
+    type = "execute";
+  } else if (hasPlan) {
+    type = "plan";
+  }
+
+  return {
+    id: clause.id,
+    raw: text,
+    type,
+    tag: tag || null,
+    hasAction,
+    hasQuestion,
+    deferred: hasDefer,
+    ambiguous
+  };
+}
+
+/**
+ * 解析用户消息中的子句级意图。
+ * @param {string} text 用户消息纯文本
+ * @returns {object} turn.intents 兼容结构
+ */
+export function parseUserIntents(text) {
+  const clauses = splitClauses(text);
+  const parsed = clauses.map(classifyClause);
+
+  const hasExecute = parsed.some((c) => c.type === "execute");
+  const hasPlan = parsed.some((c) => c.type === "plan");
+  const hasQuestion = parsed.some((c) => c.type === "question");
+  const hasStatus = parsed.some((c) => c.type === "status");
+  const ambiguous = parsed.some((c) => c.ambiguous || c.type === "ambiguous");
+  const hasTag = parsed.some((c) => c.tag);
+  const numberedCount = (String(text || "").match(/(?:^|\n)\s*\(?\d+[\)、.．)]/g) || []).length;
+
+  let source = "single";
+  if (numberedCount >= 2 && hasTag) source = "mixed";
+  else if (numberedCount >= 2) source = "numbered-list";
+  else if (hasTag) source = "labels";
+
+  let confidence = "high";
+  if (ambiguous) confidence = "low";
+  else if (source === "single" && !hasTag) confidence = "medium";
+
+  return {
+    raw: String(text || ""),
+    source,
+    clauses: parsed,
+    hasExecute,
+    hasPlan,
+    hasQuestion,
+    hasStatus,
+    ambiguous,
+    confidence
+  };
+}
+
+/** 兼容旧判断：是否应禁止变更（无执行授权且存在问询语义） */
+export function shouldDenyMutation(intents, askSeen = false) {
+  if (askSeen) return false;
+  if (!intents) return true;
+  if (intents.hasStatus) return false; // 状态信号消息不触发规则 22 拦截（规则 22⑩，2026-08-24）
+  if (intents.ambiguous) return true;
+  return !intents.hasExecute;
+}