dsh-rule-engine 0.5.4 → 0.5.6

package/README.md

@@ -72,12 +72,19 @@ dsh plugin --profile web add dsh-rule-engine
 - 只读操作（read/grep/glob/read_image/str_replace_editor view）无条件放行，拦截只针对变更类操作
 - 插件自身配置/理解产物对模型只读：直接 `edit/write` 会被守卫拒绝，需 `/guard unlock`
 - AGENTS.md mtime 变化后自动重解析（`fs.watch` + stat 兜底），规则增删改无需重启
+- **修改插件 lib 代码后必须重启 DSH 生效**：bundle 装配下 `dev_reload_package` 热重载不可靠（报成功但行为仍旧代码，踩坑 65）；重启后以行为实测（如“请继续”放行）验证
+- LLM 意图兜底：对词表低置信/歧义的用户消息异步调用 `ctx.llm` 判定意图（sha256 缓存 + 会话每日限额），词表判拦且 LLM 高置信判执行时放行；失败自动降级词表（`rule-engine.json` 的 `llmIntent` 配置段可开关/调阈值）
+- 状态信号：用户“我已重启/已输入/完成”等就绪确认与无消息回合不做规则 22 拦截，敏感操作仍由 12A/13A 把关（规则 22⑩）
 - 低置信规则不参与硬拦，避免误伤；在 `/guard rules` 中标记人工复核
 - 授权证据按“操作类型 + 目标路径前缀”结构化匹配，区分“询问”与“授权”
 - 备份证据按“目标路径 → 备份路径”记录，删除/覆盖前必须存在对应路径且备份文件真实存在
 - 版本/手册类文件写后自检：版本号连续、append 不覆盖上一行，失败自动回滚并审计
 - 跨工具一致性：同一敏感操作经 `edit` / `write` / `str_replace_editor` / `pwsh` 必须得到相同拦截/放行结论
 - 命令输出静默错误检测：全 false/0/null 或与上一条完全一致时审计 + 注入提醒，不阻断
+- **注入提醒通道实测限制（2026-08-24，O1 实测——已修复，批次 6）：** 根因：`agent.inject` 在 `session/event` 观察回调内同步调用，命中 dsh-session 的 append 重入保护（`session append cannot reenter`，日志 `kind:inject` 可见）；2026-08-24 批次 6 已修复：投递延迟到 append 发布边界之后（宏任务），语义不变（inject 官方语义即“为下一 pre-step 排队、不唤醒”）；审计从 `注入异常` 变为 `注入已投递` 可对账（详见局限 6）
+- **消息注入判别（机制 A，2026-08-24）**：`user/message` 先判 `source.kind`（`user` 以外的官方/插件注入一律跳过：不覆盖回合状态、不产生授权），并用已知注入模板兜底（Current runtime context 快照 / Background subagent 通知 / vision-router 挂载提醒 / `[规则引擎]` 前缀），全部留 `source-skip` 审计——系统注入与插件挂载通知不再污染授权池
+- **工具分类制（机制 B，2026-08-24）**：工具按 analysis / artifact / mutating / unknown 四类判定；未归类工具（新装插件的工具）首次调用走 ask 确认（防“参数名猜不出就放行”的绕过），已归类只读命令（`npm test` / `git -C` / `node --check` / `gh auth status` 等，按命令链分段判定）无条件放行
+- **授权双轨 + revoke 全清（机制 C，2026-08-24）**：自动来源授权（执行分点/ask/指令）绝不写入全局池（全局仅显式白名单）；`/guard revoke` 全清 session + turn.scopes + global + askRejections；授权路径匹配带边界（`d:/a.txt` 不再误匹配 `d:/a.txt.bak`）
 - 技能目录实时联动：`ctx.skills` 目录变化后自动刷新，已禁用/不存在的技能不触发 12B
 - LLM 增量理解：对非 high 置信规则调用 `ctx.llm` 补全结构化理解，失败自动回退模式库；AGENTS.md 变化触发重载后会自动补一次增量理解（按规则+版本去重，不重复烧 token）
 - D 级自证泛化：按规则特征触发自证提示，每规则每会话限 3 次
@@ -112,6 +119,7 @@ dsh plugin --profile web add dsh-rule-engine
 
 6. **输出文本实时拦截**
    受 DSH 官方架构限制，`assistant/message` 无法“拦下不发”，只能事后审计 + 纠正注入；这是平台边界，不是插件能单独突破的。
+   另外（2026-08-24 实测 O1 → 批次 6 已修复）：纠正注入通道根因是引擎在 `session/event` 观察回调内同步调用 `agent.inject`，触发 dsh-session 的 append 同步重入保护（`session append cannot reenter while another append is being published`，`kind:inject` 审计全程可见——注入消息从未到达模型/界面）；修复为延迟到 append 发布边界后投递（宏任务 `setTimeout 0`），inject 官方语义本就是“为下一 pre-step 排队、不唤醒”，语义不变；审计 reason 从 `注入异常：session append cannot reenter...` 变为 `注入已投递（agent=...）`，可对账（测试 `test/phase1f-inject.test.mjs` 锁定）。
 
 ## 致谢
 

package/lib/core/authorization.js

@@ -1,23 +1,41 @@
 // authorization.js - 授权证据结构化匹配（P0：授权关联具体操作，区分询问与授权）
 // 纯函数，可独立测试。
 import { GENERIC_EXEC_TOOLS, pathTarget, commandText, writeTargetPathsFromCommand, extractCopyPaths } from "./patterns.js";
+import { QUESTION_RE } from "./intent.js";
 
 export const AUTH_TTL_MS = 10 * 60 * 1000;
 
 const AUTH_WORDS_RE = /(?:可以|同意|授权|去做|开始|执行吧|批准|允许|确认|好的|行|去吧|ok|yes)/i;
-const QUESTION_WORDS_RE = /(?:影响吗|可以吗|要不要|是否|能不能|行不行|需不需要|吗\s*$|？|\?)/i;
-const DIRECTIVE_RE = /(?:请\s*)?(?:删除|移除|修改|编辑|替换|写入|创建|复制|移动|执行|运行|下载|提交|推送|备份|安装|卸载|清理|启动|停止|重建|修复|保存)/i;
+// 疑问词表统一来自 intent.js（规则 22 意图判定与 12D 授权判定的唯一来源，2026-08-24 合并两套）
+const DIRECTIVE_RE = /(?:请\s*)?(?:删除|移除|修改|编辑|替换|写入|写(?:下|好|完|成|作|文件)?|保存|另存为|创建|复制|移动|执行|运行|下载|提交|推送|备份|安装|卸载|清理|启动|停止|重建|修复|改(?:为|成|动|一下)?|补(?:上|齐|全|充|写)?|修(?:改|复|一下)?|做(?:好|完|一下)?|实施|推进|继续|处理|解决)/i;
 const APPROVAL_RE = /(?:允许|同意|可以|是|好|确认|授权|执行|批准|去吧|开始|ok|yes)/i;
 const REJECTION_RE = /(?:不允许|拒绝|不要|否|取消|不同意|no|No)/i;
 
+// 2026-08-24（规则 22 粒度配套）：执行许可确认词。
+// 只有「确认/同意/批准/授权/可以 + 即可/现在/马上/继续/开始/执行/落盘/去做/实施/进行……」
+// 才构成执行许可；纯"确认方案/理解/方向"不构成。
+export const APPROVAL_EXEC_RE =
+  /(?:确认|同意|批准|授权|可以|允许|好|行|ok|yes)[^\n]{0,16}(?:即可|现在|马上|继续|开始|执行|落盘|去做|实施|进行|删除|修改|改|补|修|做|写入|创建|安装|发布|下载|提交|运行)/i;
+
+// 纯方案/理解/方向确认（不构成执行授权）
+const PLAN_ONLY_RE = /确认方案|确认理解|确认方向|确认无误|理解了|明白方向|了解|没问题|收到/i;
+
+// 选项/自由文本里的明确动作词（用于 ask 结果判定：选择"执行/调整/修复…"即视为批准）
+const EXEC_ACTION_RE = /执行|开始|做|改|补|修|实施|删除|修改|写入|创建|安装|发布|下载|提交|运行|升级|修复|补充|调整|推进|继续|落盘|保存|处理|解决/i;
+
 const TYPE_HINTS = [
   { re: /删除|移除|remove|delete/i, type: "delete" },
-  { re: /修改|编辑|替换|写入|写文件|edit|write|replace/i, type: "write" },
+  { re: /修改|编辑|替换|写入|写(?:入|文件|作|下|好|完|成)?|改(?:为|成)?|保存|另存为|edit|write|replace/i, type: "write" },
   { re: /备份|backup/i, type: "backup" },
   { re: /git\s+(push|commit)|提交|推送/i, type: "git" },
-  { re: /执行|命令|运行|run|execute|pwsh|bash/i, type: "command" },
+  // 命令类只在有明确命令上下文时推断；"执行/开始/做"等宽泛指令保持 any，避免把普通文件变更误限为 command
+  { re: /命令|运行|执行\s*(?:命令|脚本|以下|程序)|run|execute|pwsh|bash|node\s+[\w./\\-]+\.(?:m?js|cjs)|npm\s+(?:run|exec|install)/i, type: "command" },
   { re: /技能|skill/i, type: "skill" },
-  { re: /下载|网络|curl|fetch/i, type: "network" }
+  { re: /下载|网络|curl|fetch/i, type: "network" },
+  // 只读/审查类（置末位，2026-08-25 RB-05）：不覆盖在前类别的变更语义（“修改并审查”仍按 write/delete），
+  // 仅当无其它类型命中时给只读类型——配合 ACTION_RE 只读词（审查/阅读/验证等），使“审查文件”类执行分点
+  // 授权类型为 analysis（只读），不再落入 any 宽泛授权。
+  { re: /审查|阅读|查看|核对|检查|审阅|复核|查阅|验证|对照|评估|分析|研究|排查|核实|梳理|调查|诊断/i, type: "analysis" }
 ];
 
 const PATH_TOKEN_RE = /["'][A-Za-z]:[\\/](?!\/)[^"']+["']|[A-Za-z]:[\\/](?!\/)[^\s'"`，。；：！？（）【】《》、]+|(?:^|[\s"'`])\/(?:[^\s"'`，。；：！？（）【】《》、]+)/g;
@@ -27,7 +45,7 @@ export function normalizePath(p) {
   return p.replace(/\\/g, "/").toLowerCase();
 }
 
-/** 从文本推断操作类型 */
+/** 从文本推断操作类型（取第一个命中） */
 export function inferTypeFromText(text) {
   const s = String(text || "");
   for (const hint of TYPE_HINTS) {
@@ -36,6 +54,167 @@ export function inferTypeFromText(text) {
   return "any";
 }
 
+/** 从文本推断全部命中的操作类型（用于一条子句含多个操作，如“修改 A 并删除 B”） */
+export function inferTypesFromText(text) {
+  const s = String(text || "");
+  const types = [];
+  for (const hint of TYPE_HINTS) {
+    if (hint.re.test(s)) types.push(hint.type);
+  }
+  return types.length ? [...new Set(types)] : ["any"];
+}
+
+/**
+ * 从文本提取路径候选（批次 4 统一入口：pairActionScopes 与 inferPathPrefixesFromText 共用）。
+ * 处理两类噪声：
+ *  1. 前缀冗余：引号路径同时命中两分支 → 截断前缀（如 "d:/deepseek"）被更长匹配覆盖 → 丢弃；
+ *  2. 截断可疑：裸含空格路径（无引号）只能提取到空格前的半截（"D:\DeepSeek harness\..." → "d:/deepseek"）
+ *     ——匹配后紧跟空白且后随 token 是路径字符开头且非盘符/引号 → 判定为截断 → 丢弃（fail-closed：
+ *     宁缺授权，拦截后请用户给完整/引号路径，也不把半截前缀当成授权）。
+ * @returns {Array<{index:number,path:string}>} 去噪后的候选（保留原文索引供就近配对）
+ */
+function extractPathCandidates(text) {
+  const s = String(text || "");
+  const all = [...s.matchAll(PATH_TOKEN_RE)]
+    .map((m) => {
+      const rawTok = m[0];
+      const after = s.slice(m.index + rawTok.length);
+      const afterChar = after.charAt(0);
+      const afterWord = after.match(/^[ \t]+(\S+)/)?.[1] || "";
+      const truncated = !/["']$/.test(rawTok) // 引号包裹完整路径不可能是截断
+        && /\s/.test(afterChar)
+        && afterWord.length > 0
+        && !/^("|')?[A-Za-z]:[\\/]/i.test(afterWord) // 后随是新盘符路径 → 不是延续
+        && /^[A-Za-z0-9_.[\]\\/-]/i.test(afterWord); // 后随是路径字符（非中文标点/动词）
+      return { index: m.index, path: normalizePath(rawTok.replace(/^["']|["']$/g, "")), truncated };
+    })
+    .filter((p) => p.path && !p.truncated);
+  // 前缀冗余：完整匹配覆盖截断前缀（后一字符为空白/结束符）
+  return all.filter(
+    (p) => !all.some((q) => q !== p && q.path.startsWith(p.path) && /[\s"'`，。；：！？（）【】《》、]/.test(q.path.slice(p.path.length, p.path.length + 1) || ""))
+  );
+}
+
+/** 从文本提取全部绝对路径（用于一条子句含多个路径） */
+export function inferPathPrefixesFromText(text) {
+  const unique = [...new Set(extractPathCandidates(text).map((p) => p.path))];
+  return unique;
+}
+
+/**
+ * 委托任务书检测（批次 3，2026-08-24；R2④ 实测驱动）。
+ * 特征：≥2 步骤枚举 + 显式绝对路径 + 文本较长 + 委托框架词（任务/步骤/目录下/只允许…）。
+ * 命中 → strict 模式：无路径绑定的动作子句不产生全局 scope（委托最小 scope 收紧）。
+ * 普通用户消息（短/无步骤枚举/无框架词）不命中 → 保持现状（规则 22⑤ 宽泛指令语义）。
+ */
+const DELEGATION_MARKER_RE = /(?:任务|只允许|仅限|受限于|范围内|目录下|依次执行|执行以下|步骤)/;
+export function isDelegationText(text) {
+  const s = String(text || "");
+  const stepCount = (s.match(/(?:^|\n)\s*\d+[.、)．]\s*/g) || []).length;
+  if (stepCount < 2) return false;
+  if (s.length < 120) return false;
+  if (!/(["'][A-Za-z]:[\\/]|[A-Za-z]:[\\/](?!\/))/.test(s)) return false;
+  return DELEGATION_MARKER_RE.test(s);
+}
+
+/**
+ * 从本回合执行子句推导授权范围（规则 22 粒度升级，2026-08-24）。
+ * R6④ 分点级精确配对（2026-08-24）：每个 execute 子句按「动作词 → 就近路径」精确配对，
+ * 不再对 type×path 做笛卡尔积——"修改 A 并删除 B"只产生 {write,A} 与 {delete,B}，
+ * 绝不产生 {write,B}/{delete,A} 等用户没说的组合。
+ * 批次 3（2026-08-24）：委托任务书（isDelegationText）→ strict 模式，无路径子句跳过（最小 scope）。
+ * @param {object} intents parseUserIntents 返回值
+ * @returns {Array<{type:string,pathPrefix:string,source:string,clauseId?:string}>}
+ */
+export function scopesFromIntents(intents) {
+  if (!intents || !Array.isArray(intents.clauses)) return [];
+  const strict = isDelegationText(intents.raw || "");
+  const scopes = [];
+  for (const c of intents.clauses) {
+    if (c.type !== "execute") continue;
+    scopes.push(...pairActionScopes(c.raw || "", c.id, strict));
+  }
+  return scopes;
+}
+
+// 动作词 → 操作类型（精确配对用；"执行/运行"保持 any，避免把宽泛指令误限为 command）
+const VERB_TYPE_RE = [
+  [/删除|移除/i, "delete"],
+  [/备份/i, "backup"],
+  [/提交|推送/i, "git"],
+  [/下载/i, "network"],
+  [/执行|运行/i, "any"],
+  [/写|保存|另存为|创建|复制|移动|修改|编辑|替换|改|补|修|做|安装|卸载|清理|修复|重建|启动|停止|调整|改进|优化|升级|迁移|整理|添加|增加/i, "write"]
+];
+const VERB_RE =
+  /删除|移除|修改|编辑|替换|写入|写|保存|另存为|创建|复制|移动|备份|提交|推送|下载|执行|运行|安装|卸载|清理|修复|重建|启动|停止|调整|改进|优化|升级|迁移|整理|添加|增加|改|补|修|做|实施|推进|继续|处理|解决/g;
+
+function verbType(word, fullText) {
+  for (const [re, type] of VERB_TYPE_RE) {
+    if (re.test(word)) {
+      // 宽泛"执行/运行"在出现具体命令上下文时仍收窄为 command
+      if (type === "any" && /node\s+[\w./\\-]+\.(?:m?js|cjs)|npm\s+(?:run|exec|install)|run\s+|execute/i.test(fullText)) return "command";
+      return type;
+    }
+  }
+  return inferTypeFromText(fullText);
+}
+
+/** R6④：子句内动作-路径就近配对（纯函数）。strict（委托任务书）下无路径子句跳过，不产生全局。 */
+export function pairActionScopes(raw, clauseId, strict = false) {
+  const text = String(raw || "");
+  const verbs = [...text.matchAll(VERB_RE)].map((m) => ({ index: m.index, word: m[0] }));
+  // 批次 4：统一路径提取（去前缀冗余 + 截断可疑）——仅保留可靠 token 供就近配对
+  const paths = extractPathCandidates(text);
+  if (verbs.length === 0) {
+    // 无动词的 execute 子句（如【执行】标签正文无动作词）→ 回退整句推断（保持旧语义）
+    const types = inferTypesFromText(text);
+    const pathList = inferPathPrefixesFromText(text);
+    // 批次 3：strict（委托任务书）且无路径 → 跳过该子句（最小 scope：无明确路径不授权）
+    if (strict && pathList.length === 0) return out;
+    const list = pathList.length > 0 ? pathList : [""];
+    const out = [];
+    for (const type of types) {
+      for (const pathPrefix of list) {
+        if (!out.some((s) => s.type === type && s.pathPrefix === pathPrefix)) out.push({ type, pathPrefix, source: "clause", clauseId });
+      }
+    }
+    return out;
+  }
+  const scopes = [];
+  for (const v of verbs) {
+    // 绑定规则：该动词之后、中间无其他动词间隔的全部路径（"修改 A 和 B" → A、B 都绑）；
+    // 无后续路径时取动词之前同条件的全部路径（"把 X 和 Y 修改"）；再否则全局。
+    const between = (p) => verbs.some((v2) => v2.index !== v.index && v2.index > Math.min(p.index, v.index) && v2.index < Math.max(p.index, v.index));
+    const after = paths.filter((p) => p.index > v.index && !between(p));
+    let boundPaths = after.map((p) => p.path);
+    if (boundPaths.length === 0) {
+      const before = paths.filter((p) => p.index < v.index && !between(p));
+      boundPaths = before.map((p) => p.path);
+    }
+    if (boundPaths.length === 0) {
+      // 批次 3：strict（委托任务书）且无路径 → 跳过（最小 scope）；普通消息 → 全局兜底（规则 22⑤）
+      if (strict) continue;
+      boundPaths = [""];
+    }
+    const type = verbType(v.word, text);
+    for (const pathPrefix of boundPaths) {
+      if (!scopes.some((s) => s.type === type && s.pathPrefix === pathPrefix)) {
+        scopes.push({ type, pathPrefix, source: "clause", clauseId });
+      }
+    }
+  }
+  return scopes;
+}
+
+/** 格式化授权范围（用于规则 22 拒绝原因） */
+export function describeScopes(scopes) {
+  if (!Array.isArray(scopes) || scopes.length === 0) return "无";
+  return scopes
+    .map((s) => `${s.type || "any"}｜路径 ${s.pathPrefix || "全局"}`)
+    .join("；");
+}
+
 /** 从文本提取路径前缀（取最长的路径 token；支持引号包裹的含空格路径） */
 export function inferPathPrefixFromText(text) {
   const s = String(text || "");
@@ -90,7 +269,15 @@ export function operationOf(toolName, args) {
   return { type, pathPrefix, pathPrefixes };
 }
 
-/** 判断授权记录是否匹配本次操作（支持源/目标多路径任一匹配） */
+/** 路径是否在授权边界内：相等，或为授权路径的子路径（子路径以 / 为边界，防止文件前缀误伤） */
+function pathUnderAuth(p, authPath) {
+  if (p === authPath) return true;
+  return p.startsWith(authPath.endsWith("/") ? authPath : authPath + "/");
+}
+
+/** 判断授权记录是否匹配本次操作（支持源/目标多路径任一匹配）。
+ *  2026-08-24（R6.3）：纯 startsWith 改为边界匹配——授权 "d:/a.txt" 不再放行 "d:/a.txt.bak"（同前缀文件误伤），
+ *  目录前缀（含无尾斜杠的目录名）仍正确匹配子路径。 */
 export function authMatches(auth, op) {
   if (!auth || !op) return false;
   if (auth.type !== "any" && op.type !== "any" && auth.type !== op.type) return false;
@@ -100,7 +287,7 @@ export function authMatches(auth, op) {
       : (op.pathPrefix ? [op.pathPrefix] : []);
     if (candidates.length === 0) return false;
     const authPath = normalizePath(auth.pathPrefix);
-    if (!candidates.some((p) => normalizePath(p).startsWith(authPath))) return false;
+    if (!candidates.some((p) => pathUnderAuth(normalizePath(p), authPath))) return false;
   }
   return true;
 }
@@ -126,15 +313,15 @@ export function describeOp(op) {
   return `${op.type || "any"}｜路径 ${op.pathPrefix || "未指定"}`;
 }
 
-/** 用户消息是否为“询问影响”而非授权 */
+/** 用户消息是否为“询问影响”而非授权（词表与 intent.js 统一，2026-08-24） */
 export function isQuestionMessage(text) {
-  return QUESTION_WORDS_RE.test(String(text || ""));
+  return QUESTION_RE.test(String(text || ""));
 }
 
-/** 用户消息是否包含明确授权词（且不是询问句） */
+/** 用户消息是否包含明确执行许可（确认/同意/授权 + 执行语；且不是询问句） */
 export function isAuthMessage(text) {
   const s = String(text || "");
-  return AUTH_WORDS_RE.test(s) && !isQuestionMessage(s);
+  return APPROVAL_EXEC_RE.test(s) && !isQuestionMessage(s);
 }
 
 /** 用户消息是否为直接命令式指令（非询问，视为授权执行） */
@@ -143,9 +330,11 @@ export function isDirectiveMessage(text) {
   return DIRECTIVE_RE.test(s) && !isQuestionMessage(s);
 }
 
-/** 选项/自由文本是否表示批准 */
+/** 选项/自由文本是否表示批准（纯"确认方案/理解/方向"不算批准） */
 export function isApprovalText(text) {
-  return APPROVAL_RE.test(String(text || ""));
+  const s = String(text || "");
+  if (PLAN_ONLY_RE.test(s) && !EXEC_ACTION_RE.test(s) && !APPROVAL_EXEC_RE.test(s)) return false;
+  return APPROVAL_RE.test(s) || EXEC_ACTION_RE.test(s);
 }
 
 /** 选项/自由文本是否表示拒绝 */
@@ -179,6 +368,46 @@ export function askQuestionText(questions) {
   return parts.join(" ");
 }
 
+/**
+ * 仅取 ask 的问题/标题/说明，不含选项文本。
+ * 2026-08-24 修复：选项描述里的“仅会话内说明/不跨会话保留”等字样不得影响授权范围判定。
+ */
+export function askQuestionCoreText(questions) {
+  if (!Array.isArray(questions)) return "";
+  const parts = [];
+  for (const q of questions) {
+    if (q && typeof q === "object") {
+      if (q.question) parts.push(q.question);
+      if (q.header) parts.push(q.header);
+      if (q.detail) parts.push(q.detail);
+    } else if (typeof q === "string") {
+      parts.push(q);
+    }
+  }
+  return parts.join(" ");
+}
+
+/** 提取 ask 结果中用户实际选择的文本（selected 标签 + 自定义输入），用于授权范围判定 */
+export function askResultSelectedText(result) {
+  const answers = extractAnswers(result);
+  if (!answers || answers.length === 0) return "";
+  const parts = [];
+  for (const item of answers) {
+    const texts = [...(item.selected || []), item.custom || ""].filter(Boolean);
+    for (const t of texts) parts.push(t);
+  }
+  return parts.join(" ");
+}
+
+/**
+ * 判定 ask 授权是否应为“会话级/全局长时”授权。
+ * 只匹配明确的范围词，不再匹配裸“会话内”（避免“仅会话内说明”把一次小授权放大成 12h 全局）。
+ */
+const SESSION_WIDE_RE = /(?:全部|本会话|本次会话|整个会话|当前会话|会话内所有|会话内全部|所有后续|剩余所有|所有操作|整个profile|整个工作区|全部推进项|全部操作)/i;
+export function isSessionWideAskText(text) {
+  return SESSION_WIDE_RE.test(String(text || ""));
+}
+
 /** 从 ask_user_question 的结果中提取是否批准 */
 export function askResultApproved(result) {
   const answers = extractAnswers(result);

package/lib/core/baseline.js

@@ -0,0 +1,43 @@
+// baseline.js - 需求基线覆盖核查（2026-08-24 最小第一步）
+// 用途：交付/方案完成类声明时，核对需求基线（rule-engine-baseline.json）中是否仍有
+// planned 未落地需求；缺失/损坏按 fail-closed 处理（审计提示，绝不静默）。
+import { readFileSync } from "node:fs";
+import { baselineFilePath } from "./paths.js";
+
+/** 完成类声明的触发词（独立于规则 23④ 的通用完成正则，避免日常“完成”二字误报） */
+export const BASELINE_COMPLETE_RE =
+  /方案完成|重构完成|全部完成|整体完成|任务全部完成|彻底完成|收尾完成|全部落地|机制完成/;
+
+/**
+ * 纯函数判定：完成声明 ∧ 存在 planned 需求 → gap；否则 null。
+ * @param {string} text 声明文本
+ * @param {Array<{id: string, title?: string, status: string}>} items 基线需求
+ * @returns {{count: number, pending: string[]} | null}
+ */
+export function computeBaselineGap(text, items) {
+  if (!text || !BASELINE_COMPLETE_RE.test(text)) return null;
+  if (!Array.isArray(items) || items.length === 0) return null;
+  const pending = items
+    .filter((i) => i && i.status === "planned")
+    .map((i) => `${i.id}:${i.title || ""}`);
+  if (pending.length === 0) return null;
+  return { count: pending.length, pending };
+}
+
+/**
+ * 加载需求基线文件。缺失/损坏 → { ok:false }（调用方据此审计，不做静默判定）。
+ */
+export function loadBaselineFile(filePath = baselineFilePath()) {
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    const data = JSON.parse(raw);
+    const items = Array.isArray(data && data.requirements) ? data.requirements : [];
+    return { ok: true, items, raw: data };
+  } catch (error) {
+    return {
+      ok: false,
+      items: [],
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}

package/lib/core/config.js

@@ -16,6 +16,13 @@ export const DEFAULT_CONFIG = {
     hashPolicy: "deny",
     dependencyPolicy: "ask",
     allowedPaths: null
+  },
+  llmIntent: {
+    enabled: true,
+    dailyLimitPerSession: 50,
+    thresholdHigh: 0.8,
+    thresholdLow: 0.5,
+    cacheSize: 500
   }
 };
 

package/lib/core/contract.js

@@ -21,6 +21,60 @@ export function defaultContract() {
   };
 }
 
+/**
+ * 会话契约初始化（批次 4，阶段 3 默认武装）：
+ * 优先级：defaults 显式（用户配置）> global 模板（用户 /guard mode|budget 写入且非默认）> armed 推导 > 系统默认。
+ * 默认武装（用户拍板 A）：armed 且未见显式 mode/level → {mode:"change", level:"guard"}；
+ * agentBudget 0（系统默认/未显式设置）→ 2（日常可用，避免武装附带"子代理全拦"副作用）。
+ * @param {object} cfg config.js 的 taskContract 配置段（{taskContractMode, defaults})
+ * @param {object|null} globalContract 全局（模板）会话契约；首次/global 自身传 null
+ */
+export function initSessionContract(cfg = {}, globalContract = null) {
+  const defaults = (cfg && cfg.defaults) || {};
+  const base = { ...defaultContract(), ...defaults };
+  const globalUserSet = globalContract && globalContract.source && globalContract.source !== "default";
+  if (globalUserSet) {
+    if (globalContract.mode && globalContract.mode !== base.mode) base.mode = globalContract.mode;
+    if (globalContract.level && globalContract.level !== base.level) base.level = globalContract.level;
+    if (typeof globalContract.agentBudget === "number" && globalContract.agentBudget > 0 && base.agentBudget === 0) {
+      base.agentBudget = globalContract.agentBudget;
+    }
+    if (globalContract.hashPolicy && globalContract.hashPolicy !== base.hashPolicy) base.hashPolicy = globalContract.hashPolicy;
+    if (globalContract.dependencyPolicy && globalContract.dependencyPolicy !== base.dependencyPolicy) base.dependencyPolicy = globalContract.dependencyPolicy;
+    if (Array.isArray(globalContract.allowedPaths)) base.allowedPaths = globalContract.allowedPaths;
+  }
+  const armed = cfg && cfg.taskContractMode === "armed";
+  const explicitMode = "mode" in defaults || (globalUserSet && globalContract.mode && globalContract.mode !== "unconfirmed");
+  if (armed && base.agentBudget === 0) base.agentBudget = 2;
+  if (armed && !explicitMode) {
+    base.mode = "change";
+    base.level = "guard";
+  }
+  base.source = "session-init";
+  return base;
+}
+
+/** 契约裁决 → pre-execute 决策（批次 4：deny 真实物理拦截，不再仅审计放行）。allow/report → null。 */
+export function contractOutcomeToPreDecision(dec) {
+  if (!dec) return null;
+  if (dec.outcome === "deny") {
+    return { kind: "deny", reason: `${dec.reason}（任务契约｜${dec.nextStep || "请调整契约或停止该操作"}）` };
+  }
+  if (dec.outcome === "ask") {
+    return { kind: "ask", reason: `${dec.reason}（任务契约｜${dec.nextStep || "请确认或使用放行词"}）` };
+  }
+  return null;
+}
+
+/**
+ * 委托预算扣减（批次 5.5，2026-08-24；用户指示提前到发布前）：启动即计——纯函数，不污染原对象。
+ * 语义：调用即占额度（失败不退还，保守安全面）；配合 decideContractAction 的预算越限 deny。
+ */
+export function consumeDelegateBudget(contract, count = 1) {
+  const n = Math.max(0, Number(count) || 0);
+  return { ...contract, agentsUsed: (Number(contract?.agentsUsed) || 0) + n };
+}
+
 /** 从 /guard mode 指令解析契约模式；无法解析返回 null */
 export function parseModeCommand(text) {
   const m = /^mode\s+([a-z]+)(?:\s+(watch|guard|lock|off))?$/i.exec(String(text || "").trim());