dsh-rule-engine 0.6.3 → 0.6.4

package/README.md

@@ -1,11 +1,13 @@
 # dsh-rule-engine
 
 ![npm](https://img.shields.io/npm/v/dsh-rule-engine)
-![version](https://img.shields.io/badge/version-0.6.3-blue)
+![version](https://img.shields.io/badge/version-0.6.4-blue)
 
-DSH 规则执行引擎 v3 的插件实现。它把 `~/.dsh/AGENTS.md` 当作唯一真相源，自动解析规则四要素与执行等级，再通过「工具守卫 + 文本检测 + 时序检查 + 审计台账」执行用户规则，而不是内置一套与用户无关的安全清单。
+DSH 规则执行引擎 v3 的插件实现。它把 `~/.dsh/AGENTS.md` 当作唯一真相源，自动解析规则四要素与执行等级，再通过「工具守卫 + 文本检测 + 时序检查 + 审计台账」执行用户规则，而不是内置一套与用户无关的安全清单。**当前版本 0.6.4**（**适用环境：DSH `0.1.5-rc.2`**——本机实测：装配成功 + 冷加载探针 PASS + `npm test` ALL TESTS PASSED + `npm run verify` 13 层全绿；兼容声明面见 `package.json` 的 `dshCompat`：`>=0.1.0-rc.3 <0.2.0`，覆盖 0.1.5 线）。本版三项修复：**D2**（待决 ask 提升为会话级——修复"用户消息与 ask 答复并发"致授权全部未登记）+ **B1/C1**（规则 24 官方 bundle 豁免兑现；装配不一致的收敛豁免）+ **A2**（ask 授权登记改复数路径、`authMatches` 支持多路径匹配）。
 
 > 当前版本 **0.6.3**（0.1.2-rc.1 适配：Remote 新合同（typert-protocol `Remote(undefined, …)` 形态，typeof-null 陷阱修复）+ peer 锚扩 `>=0.1.2-rc.0`；白名单 3 轮扩充（gh 只读态 / `gh api` 只读 / `git ls-remote` / `cmdkey /list` + Do- 结构词回归修复）；E7 豁免预插（release-plugin bump 后自动追加 pnpm minimumReleaseAgeExclude——⑬ 口径防发布后红灯窗口，单源 `scripts/lib/pnpm-exempt.mjs`））。本插件面向"规则机器化执行"：规则写在 AGENTS.md 里，引擎负责让它们真的被遵守；所有规则动态解析，规则增删改后无需重写插件。
+>
+> **0.6.4（最新；取代上行版本号）**——**适用环境验证：DSH `0.1.5-rc.2`**（本机实测：装配成功 + 冷加载探针 PASS + `npm test` ALL TESTS PASSED + `npm run verify` 13 层全绿；兼容声明面见 `package.json` 的 `dshCompat`：`>=0.1.0-rc.3 <0.2.0`，覆盖 0.1.5 线）。本版三项修复：**D2**（待决 ask 提升为会话级——修复"用户消息与 ask 答复并发"致授权全部未登记）+ **B1/C1**（规则 24 官方 bundle 豁免兑现；装配不一致的收敛豁免——守卫不再拦下唯一能收敛的动作）+ **A2**（ask 授权登记改复数路径、`authMatches` 支持多路径匹配——修复"多路径只取一个、取最长取到次要路径"）。
 
 ## 项目背景
 
@@ -23,7 +25,7 @@ DSH 规则执行引擎 v3 的插件实现。它把 `~/.dsh/AGENTS.md` 当作唯
 本插件定位：**通用规则执行引擎**——任何用户的 AGENTS.md 规则集均可使用；本机工作流偏好仅作默认兜底（配置层），不含任何强制绑定。
 
 - **声明式绑定**：规则正文可写 `<!-- handler: xxx -->`（或经插件配置 `handlerOverrides: {规则编号: 执行器名}`）显式绑定引擎执行器；未声明的规则按"纯自证"处理（参与匹配/自证提示，不参与机器硬拦）；
-- **执行器语义名**：声明/配置可写语义名（`approval`/`backup`/`inline-command`…），自动映射到内部执行器；直接写内部名（`rule12a-approval` 等）同样兼容；
+- **措施类型（kind）**：声明/配置写 kind 名（`approval`/`backup`/`inline-command`…）即绑定对应执行器；历史内部名（`rule12a-approval` 等）经兼容别名表归一为同一 kind，**旧配置与旧规则正文无需改动**；
 - **禁用语义**：管理器禁用的规则以"禁用占位"存在——`/guard rules` 显示"（已禁用）"，不参与硬拦/纠察；恢复启用后自动重新生效（禁用 ≠ 删除，不再"消失"）；
 - **无 AGENTS.md 也可用**：无规则文件时引擎零错加载、零规则、零误拦（发布门禁验证）；
 - **本机偏好表下沉配置**：内置默认偏好表已从代码移除——通用部署=空表（代码零本机编号）；本机偏好经 `rule-engine.json` 的 `handlerDefaultMap` 提供（可整体替换/清空，引擎升级不丢）；
@@ -241,7 +243,9 @@ console.log(qualityTrend(sig).summary);   // 方向：rework 改善 / 持平 /
 > 更早版本（0.1.0-0.5.5）与本机历史要点见 git 历史；各版本内部"用户定稿"等决策细节不再随发布物携带。
 
 | 版本 | 日期 | 要点 |
-| **0.6.3** | 2026-09-09 | docs(readme): 词表配置章节补齐 dualtrack（markers/whitelist/加载优先级/空表 REFUSED） |
+|---|---|---|
+| **0.6.4** | 2026-09-10 | **本版**：**D2**（待决 ask 提升为会话级——修复"用户消息与 ask 答复并发"致授权全部未登记）+ **B1/C1**（规则 24 官方 bundle 豁免兑现；装配不一致的收敛豁免——守卫不再拦下唯一能收敛的动作）+ **A2**（ask 授权登记改复数路径、`authMatches` 支持多路径匹配）。**适用环境验证 = DSH `0.1.5-rc.2`**（装配 + 冷加载探针 + `npm test` + `verify` 13 层全绿） |
+| **0.6.3** | 2026-09-09 | docs(readme): 词表配置章节补齐 dualtrack（markers/whitelist/加载优先级/空表 REFUSED） |
 | **0.6.2** | 2026-09-08 | fix(0.6.2): whitelist 3-round + 0.1.2 adaptation + peer-anchor 0.1.2 + E7 pre-plug wiring  |
 |---|---|---|
 | **0.6.1+（本地增强，未发版）** | 2026-09-07 | 只读豁免清单扩充（用户定调"纯只读顺畅"）：`gh api` 只读态（无 -X/--method/graphql/-F/-f 的段）、`gh release/issue/pr/run view`、`cmdkey /list`、`git ls-remote` 显式；写形态（gh api -F/graphql、git fetch、curl 下载、重定向落盘）保持拦截；26 用例全绿 + 语法体检 + 热重载生效（发版需 bump 0.6.2） |
@@ -260,11 +264,11 @@ console.log(qualityTrend(sig).summary);   // 方向：rework 改善 / 持平 /
 | **0.5.7** | 2026-08-26 | 注入噪音治理（词表只产嫌疑 + LLM 裁决 + fail-closed + 投递资格闸 + 审计完整性）、注入通道重入修复（宏任务投递）、语义层（awaitingJudge/judge-pass/false/unavailable） |
 | **0.5.6** | 2026-08-26 | 同回复聚合注入、已自证规则不重复触发、C2 规则统计（detected/suppressed/injected） |
 
-## 发行固定源
-
-<!-- fixed-source: 待发布回填 -->
+## 发行固定源
+
+> **0.6.4（当前）** —— 本版三项修复：**D2**（待决 ask 提升为会话级）/ **B1/C1**（规则 24 官方 bundle 豁免兑现 + 装配不一致的收敛豁免）/ **A2**（ask 授权登记改复数路径 + `authMatches` 多路径匹配）。**适用环境验证 = DSH `0.1.5-rc.2`**（装配 + 冷加载探针 + `npm test` + `verify` 13 层全绿）。**发布 commit 待三通道完成后回填**（届时 `git checkout <hash>` 可复现 npm `dsh-rule-engine@0.6.4` 与 GitHub Release v0.6.4 同源代码）。
 
-- **0.6.3（当前）** 固定于 main Commit `68c1e7d`（`git checkout 68c1e7d` + 发布 bump 可复现 npm `dsh-rule-engine@0.6.3` 与 GitHub Release v0.6.3 同源代码——0.6.3 = 分层残留闸 `dualtrack-check`（判据 A：中文≠个人化）+ 词表全量配置化（lexicons / patterns / criticismPersonal / dualtrack 走 `rule-engine.json`）+ 第三批第 1 批文案层 + 三项门禁修复（`--init` 覆盖保护 / loader-smoke 中文夹具 / 中文目录顿号兼容）。**注：发布后回填真实 release 提交 hash。**
+- **0.6.3（当前）** 固定于 main Commit `3e87f9d`（`git checkout 3e87f9d` 可复现 npm `dsh-rule-engine@0.6.3` 与 GitHub Release v0.6.3 同源代码——0.6.3 = 分层残留闸 `dualtrack-check`（判据 A：中文≠个人化）+ 词表全量配置化（lexicons / patterns / criticismPersonal / dualtrack 走 `rule-engine.json`）+ 第三批第 1 批文案层 + 三项门禁修复（`--init` 覆盖保护 / loader-smoke 中文夹具 / 中文目录顿号兼容）。
 - **0.6.2** 固定于 main Commit `92da194538fce2f56fa7c6712c70711865772686`（`git checkout 92da194538fce2f56fa7c6712c70711865772686` 可复现 npm `dsh-rule-engine@0.6.2` 与 GitHub Release v0.6.2 同源代码——0.6.2 = 0.1.2-rc.1 适配（Remote 新合同 `Remote(undefined, …)` / peer 锚扩 `>=0.1.2-rc.0`）+ 白名单 3 轮扩充 + Do- 结构词回归修复 + E7 豁免预插机制上线）。
 - **0.6.1** 固定于 main Commit `051e2da`（`git checkout 051e2da` 可复现 npm `dsh-rule-engine@0.6.1` 与 GitHub Release v0.6.1 同源代码——0.6.1 = 豁免预插（release-plugin bump 后自动追加 pnpm minimumReleaseAgeExclude，⑬ 绝对口径防发布后红灯窗口——踩坑 18 镜像）+ 豁免判定单源化（scripts/lib/pnpm-exempt.mjs 与 verify-all ⑬ 共享，4 单测锁定）+ viewFails 发布语境 STRICT 计 ❌ + ⑬ 块头注释绝对口径（E1/E2/E3 收尾批）。
 - **0.6.0** 固定于 main Commit `be5b8c93`（可复现 `dsh-rule-engine@0.6.0` 与 Release v0.6.0——0.6.0 = 本机集成层（localIntegrations 四键）+ 本机痕迹消号 + li-skipped/entry-script-missing 启动审计 + 发布门禁 B1/B2（readme-version-check / local-residue-scan，挂 verify-all/release-plugin/check:meta）+ check-tool-coverage 素材 fail-closed；词表文件 `scripts/local-residue-markers.txt` 为本机门禁工具，不入库、不进发布物（见 .gitignore / package.json files 排除）。固定源之后的提交仅限 README 指针文本）。
@@ -397,10 +401,22 @@ dsh plugin --profile web add dsh-rule-engine
   - dsh-visualize（Nagi-ovo）
   - dsh-rules-manager（jilian-dsh）
   - dsh-vision-router、dsh-example-injector 等未列出的作者
+- **设计思想与机制来源（本项目直接内化/借鉴）**：
+  - stop-that-shit（lennney）：任务边界、反过度工程、预算与四类越界——任务契约模块的设计源头。
+  - dsh-agi-harness（yjh051108）：闸=最小决策单元、Wilson 下界、拒因即指路、自由面/盲区显式声明、任务签名+质量趋势（quality-ledger）、变异测试+棘轮。
+  - Claude Code 权限范式（Anthropic 官方文档）：默认询问、deny 永远赢、通配符规则只加不放。
+  - mattpocock/skills「writing-for-agents」：写给 agent 的文档方法论。
+  - dsh-zvec-grep（sugarforever）：后台任务型插件写法。
+- **升级与审查工具链**：
+  - oh-my-dsh / dsh-plugin-upgrade-skill（社区）：0.1.2 升级卡库与对策集。
+  - build-dsh-plugin（AI-Scarlett）：插件完备性审计。
+  - cordis-plugin-thinking-loop-guard（argszero）：纯思考空转的源码级判读。
 - **学习参考的社区文档/库作者**：
   - dsh-handbook（Electricitysheep）
   - SandBase deepseek-harness-handbook（sandbaseai）
+  - awesome-dsh-plugin / Oh! dsh（生态目录）
   - 以及 DSH 官方文档镜像与源码维护者
+- **贡献建议与实证的个人**：TheBuilderJR、Reximmortal1021、AI-Scarlett、ckcfcc、goatliamia 等。
 
 ## 免责声明
 

package/lib/core/authorization.js

@@ -374,13 +374,17 @@ function pathUnderAuth(p, authPath) {
 export function authMatches(auth, op) {
   if (!auth || !op) return false;
   if (auth.type !== "any" && op.type !== "any" && auth.type !== op.type) return false;
-  if (auth.pathPrefix) {
+  // A2（2026-09-10）：授权侧支持多路径——ask 多路径问题文本经 index.js L1029 记入 pathPrefixes。
+  // 语义：任一授权路径覆盖任一操作候选路径即匹配（此前只认单一 auth.pathPrefix，ask 侧只记一条 → 其余路径的授权形同虚设）。
+  const authPaths = Array.isArray(auth.pathPrefixes) && auth.pathPrefixes.length > 0
+    ? auth.pathPrefixes.map(normalizePath).filter(Boolean)
+    : (auth.pathPrefix ? [normalizePath(auth.pathPrefix)] : []);
+  if (authPaths.length > 0) {
     const candidates = Array.isArray(op.pathPrefixes) && op.pathPrefixes.length > 0
       ? op.pathPrefixes
       : (op.pathPrefix ? [op.pathPrefix] : []);
     if (candidates.length === 0) return false;
-    const authPath = normalizePath(auth.pathPrefix);
-    if (!candidates.some((p) => pathUnderAuth(normalizePath(p), authPath))) return false;
+    if (!candidates.some((p) => authPaths.some((a) => pathUnderAuth(normalizePath(p), a)))) return false;
   }
   // 柱子 B（2026-08-31）：对象锚定——授权声明了显式命名对象 → 操作命令文本必须命中该对象
   //（"推送 X 仓库"不覆盖"推送 Y 仓库"；未锚定对象=不收紧）
@@ -402,7 +406,11 @@ export function findMatchingAuth(auths, op, now = Date.now()) {
 export function describeAuth(auth) {
   if (!auth) return "无";
   const type = auth.type || "any";
-  const path = auth.pathPrefix ? `路径 ${auth.pathPrefix}` : "全局";
+  // A2（2026-09-10）：多路径授权逐条显示（ask 多路径问题文本）；单路径/全局维持原措辞。
+  const paths = Array.isArray(auth.pathPrefixes) && auth.pathPrefixes.length > 0
+    ? auth.pathPrefixes
+    : (auth.pathPrefix ? [auth.pathPrefix] : []);
+  const path = paths.length === 0 ? "全局" : paths.length === 1 ? `路径 ${paths[0]}` : `路径 ${paths.join(" / ")}`;
   const expires = auth.expiresAt ? `｜到期 ${new Date(auth.expiresAt).toISOString()}` : "";
   return `${type}｜${path}｜${new Date(auth.at || 0).toISOString()}${expires}｜仅本次运行有效`;
 }

package/lib/core/guard-core.js

@@ -37,6 +37,7 @@ import { computeMountSignature, profileNameFromArgs } from "./mount-signature.js
 import { findBackupForPath, getSessionState, maybeReloadIfChanged } from "./state.js";
 import { isVersionedFile, validateEditedFile } from "./version-guard.js";
 import { decideContractAction, defaultContract, isArmed } from "./contract.js";
+import { kindOf } from "./measure-kinds.js";
 import { classifyAction } from "./overengineering.js";
 import { labelFingerprint, labelsAllowFingerprint } from "./label-fingerprint.js";
 
@@ -286,23 +287,26 @@ function resolveLocalDependencyPkgPath(bundleName, profilePkgPath, parsed) {
   return existsSync(pkgPath) ? pkgPath : null;
 }
 
-/** 若本次文件变更会写入 profile package.json 的 dsh.profile.bundles，返回其中非 bundle/无法确认的项 */
-export function nonBundleInProfileBundles(name, args) {
-  const p = pathTarget(args);
-  if (!isProfilePackageJson(p)) return null;
-  const content = resultingFileContent(name, args);
-  if (!content) return null;
+/** 官方 bundle 白名单（B1 修复，2026-09-10）：规则 24 自己的豁免条款原文即「官方 bundle 由官方机制管理，
+ *  模型不主动修改」——引擎此前未在代码里兑现。这两个包**永远**位于 DSH 本体或 profiles 共享层，
+ *  独立 DSH_HOME 的新 profile 两者都可能尚未建立 → 校验必然失败并**卡死 profile 声明编辑**（试点主要阻塞点）。 */
+const OFFICIAL_BUNDLES = new Set(["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-web-app"]);
+
+/** 解析给定 profile package.json **内容**中非 bundle / 无法确认的项（内容级纯函数，供 B1 与 C1 复用） */
+export function nonBundleInContent(content, profilePkgPath) {
   let parsed;
   try { parsed = JSON.parse(content); } catch { return null; }
   const bundles = parsed?.dsh?.profile?.bundles;
   if (!Array.isArray(bundles)) return null;
   const bad = [];
   for (const b of bundles) {
-    const pkgPath = resolveBundlePkgPath(b, p) || resolveLocalDependencyPkgPath(b, p, parsed);
+    if (OFFICIAL_BUNDLES.has(b)) continue; // B1：官方 bundle 直接放行（规则 24 豁免条款）
+    const pkgPath = resolveBundlePkgPath(b, profilePkgPath) || resolveLocalDependencyPkgPath(b, profilePkgPath, parsed);
     if (!pkgPath) {
       const dep = parsed?.dependencies?.[b] ?? parsed?.devDependencies?.[b] ?? parsed?.optionalDependencies?.[b];
       const depDesc = typeof dep === "string" ? `dependencies 为 ${dep}` : "dependencies 中无此包";
-      bad.push(`${b}（找不到 package.json，无法确认类型；${depDesc}。请先用 dev_install_package 或先安装依赖再写 bundles）`);
+      // B1 建议 3：给出可执行的排查方向（独立 DSH_HOME 场景最常见的成因）
+      bad.push(`${b}（找不到 package.json，无法确认类型；${depDesc}。请先用 dev_install_package 或先安装依赖再写 bundles；若为独立 DSH_HOME，请确认 profiles/node_modules 共享层存在——该层由 DSH 真实启动时的 healProfilesModuleFallback 自动建立）`);
       continue;
     }
     try {
@@ -315,6 +319,31 @@ export function nonBundleInProfileBundles(name, args) {
   return bad.length ? bad : null;
 }
 
+/** 若本次文件变更会写入 profile package.json 的 dsh.profile.bundles，返回其中非 bundle/无法确认的项 */
+export function nonBundleInProfileBundles(name, args) {
+  const p = pathTarget(args);
+  if (!isProfilePackageJson(p)) return null;
+  const content = resultingFileContent(name, args);
+  if (!content) return null;
+  return nonBundleInContent(content, p);
+}
+
+/** C1 修复（2026-09-10）：判定本次变更是否为「使装配声明趋于自洽」的修复动作。
+ *  判据：变更**前** profile package.json 的 bundles 不自洽（存在解析不到的项），变更**后**自洽。
+ *  用途：mount-audit 守卫的**收敛豁免**——解除「不一致态只能靠被拦动作修复」的死循环。
+ *  保守边界：读不到原文件、或变更后仍不自洽 → 不豁免。 */
+export function isConvergingBundleFix(name, args) {
+  const p = pathTarget(args);
+  if (!isProfilePackageJson(p)) return false;
+  const after = resultingFileContent(name, args);
+  if (!after) return false;
+  let before = null;
+  try { before = readFileSync(p, "utf8"); } catch { return false; }
+  const beforeBad = nonBundleInContent(before, p);
+  const afterBad = nonBundleInContent(after, p);
+  return Array.isArray(beforeBad) && beforeBad.length > 0 && (!afterBad || afterBad.length === 0);
+}
+
 /** 任务契约守卫：仅在总开关开启且会话 armed 时硬拦；ask 场景交给 tools/pre-execute */
 function taskContractGuardDecision(state, exec, session) {
   if (!state.taskContract?.taskContractEnabled) return null;
@@ -499,7 +528,7 @@ function matchRule(cfg, ctx) {
 
   // 规则 22 机器化：无执行分点/存在歧义 → 本回合禁止变更类工具调用
   //（"你的执行方案难道没问题吗？"虽含"执行"仍是疑问句——同形词不构成指令，不豁免）
-  if (cfg.handler === "rule22-7-direct") {
+  if (kindOf(cfg.handler) === "intent-direct") {
     // B2（2026-08-28 阶段二）：委派/子代理回合不做"无执行分点"判定（规则 22④ 的识别层落地）——
     // 子代理任务书以 source.kind="user" 注入，会被当用户消息判"无执行分点"而误拦（ERR-L8QAXS 实弹）。
     if (isDelegatedSession(exec)) {
@@ -588,7 +617,7 @@ function matchRule(cfg, ctx) {
   }
 
   // 规则 1：同工具同参数连续失败 ≥2 次后拦第 3 次（失败计数由 tool/result 更新）
-  if (cfg.handler === "rule1-retry") {
+  if (kindOf(cfg.handler) === "retry") {
     const key = `${name}:${JSON.stringify(args || {})}`;
     const count = state.retryCounts.get(key) || 0;
     const userText = session.turn.userText || session.lastUserText || "";
@@ -602,7 +631,7 @@ function matchRule(cfg, ctx) {
   }
 
   // 规则 9：内联命令 / BOM 写配置（PS7 语义：仅拦显式 utf8BOM）
-  if (cfg.handler === "rule9-inline-bom") {
+  if (kindOf(cfg.handler) === "inline-command") {
     if ((name === "pwsh" || name === "bash") && cmd) {
       if (INLINE_CMD.test(cmd)) {
         return makeHit(cfg, "【硬拦截】禁止内联命令（node -e / pwsh -c / node -p 等），请先写脚本文件再执行");
@@ -615,7 +644,7 @@ function matchRule(cfg, ctx) {
   }
 
   // 规则 18：DSH 任务首次工具调用前必须已读手册
-  if (cfg.handler === "rule18-manual-first") {
+  if (kindOf(cfg.handler) === "manual-first") {
     const userText = session.turn.userText || session.lastUserText || "";
     const firstTool = session.turn.toolCount === 0;
     if (firstTool && !session.manualReadSeen && dshKeywordsRe().test(userText) && !isManualReadTool(name, args, state.localIntegrations?.manualExempt?.paths || [])) {
@@ -625,7 +654,7 @@ function matchRule(cfg, ctx) {
   }
 
   // 规则 13A：删除/覆盖/高风险写前需有“目标路径对应备份”证据
-  if (cfg.handler === "rule13a-backup") {
+  if (kindOf(cfg.handler) === "backup") {
     // 统一入口命令豁免：入口脚本每次写入前自身执行备份（backup() 保留 5 份），
     // 引擎静态扫描看不到脚本内部动作（已知盲区）；入口命令也已被 __self-protect 限定为唯一写通道。
     if ((name === "pwsh" || name === "bash") && isEntryChannelCommand(cmd, state.localIntegrations?.entryScript)) return null;
@@ -668,7 +697,7 @@ function matchRule(cfg, ctx) {
   // 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 (kindOf(cfg.handler) === "skill-auth") {
     if (name === "skill") {
       const skillName = typeof args?.name === "string" ? args.name : "";
       if ((state.localIntegrations?.manualExempt?.skills || []).includes(skillName)) return null;
@@ -703,7 +732,7 @@ function matchRule(cfg, ctx) {
   }
 
   // 规则 12A：敏感操作需要匹配授权证据
-  if (cfg.handler === "rule12a-approval") {
+  if (kindOf(cfg.handler) === "approval") {
     if (isSensitiveToolCall(name, args, sessionIdOf(exec))) {
       // 0.5.11（用户定稿）：12A 与 22-7 判据同源——分析通道/低风险新建豁免在两条分支
       // 使用同一组判据（isAnalysisOp/isLowRiskWorkspaceNew），不再各写一套（此前 22-7 放行、
@@ -742,7 +771,7 @@ function matchRule(cfg, ctx) {
   }
 
   // 规则 21：规则/配置文件变更需 unlock（元规则）
-  if (cfg.handler === "rule21-meta") {
+  if (kindOf(cfg.handler) === "meta") {
     if ((name === "edit" || name === "write" || (name === "str_replace_editor" && args?.command !== "view")) && isProtectedConfigPath(p) && !unlock) {
       return makeHit(cfg, "【硬拦截】规则/配置文件受保护：修改需用户先执行 /guard unlock");
     }
@@ -750,7 +779,7 @@ function matchRule(cfg, ctx) {
   }
 
   // 规则 24：插件装配类型确认（A 硬拦）+ 变更类工具统一覆盖（原规则 25 语义，检查④）
-  if (cfg.handler === "rule24-assembly-type") {
+  if (kindOf(cfg.handler) === "assembly") {
     if (name === "dev_install_package") {
       const dir = args?.dir;
       if (dir) {
@@ -782,7 +811,7 @@ function matchRule(cfg, ctx) {
   }
 
   // 规则 27：装配变更后必须先通过全量审计，才能继续装配（C 时序；全局变更 + 本会话审计证据）
-  if (cfg.handler === "rule27-mount-audit") {
+  if (kindOf(cfg.handler) === "mount-audit") {
     if (isAssemblyMutationTool(name, args)) {
       const currentSig = computeMountSignature(profileNameFromArgs(args));
       state.mountSignature = currentSig;
@@ -791,6 +820,14 @@ function matchRule(cfg, ctx) {
         ? currentSig !== auditedSig
         : (state.mountRevision > (session.mountAuditRevision || 0));
       if (needsAudit) {
+        // C1 修复（2026-09-10）：**收敛豁免**——允许"使装配趋于自洽"的变更，解除不一致态的死循环。
+        //   背景（独立 DSH_HOME 试点）：改 dependencies → 通过；改 bundles 补齐 → 被拦；
+        //   试图回滚 dependencies → **同样被拦** → 审计失败项（bundles-missing）恰恰只能靠被拦的动作修复
+        //   → 无法收敛（试点靠用户手工写文件才解开）。
+        //   ① 回滚豁免：变更后签名回到"审计通过时的签名"
+        //   ② 修复豁免：变更前声明不自洽（bundles 有解析不到的项）而变更后自洽
+        if (auditedSig && currentSig === auditedSig) return null; // ① 回到已审计状态
+        if (isConvergingBundleFix(name, args)) return null;        // ② 修复审计点名的缺失/非法项
         const why = auditedSig
           ? `装配内容已变化（装配状态哈希 ${currentSig.slice(0, 8)} ≠ 审计通过时 ${auditedSig.slice(0, 8)}）`
           : `插件装配已变更（mountRevision=${state.mountRevision}）且本会话未通过全量审计`;

package/lib/core/matcher.js

@@ -10,19 +10,21 @@ import {
   activateTimeRe,
   dshKeywordsRe
 } from "./patterns.js";
+import { kindOf } from "./measure-kinds.js";
 
 export function activateForUserMessage(configs, userText) {
   const text = userText || "";
   return configs.filter((cfg) => {
-    if (cfg.handler === "rule18-manual-first" && dshKeywordsRe().test(text)) return true;
-    if (cfg.handler === "rule12b-skill" && activateSkillRe().test(text)) return true;
-    if (cfg.handler === "rule12a-approval" && activateApprovalRe().test(text)) return true;
-    if (cfg.handler === "rule12c-network" && activateNetworkRe().test(text)) return true;
-    if (cfg.handler === "rule13a-backup" && activateBackupRe().test(text)) return true;
-    if (cfg.handler === "rule2-time" && activateTimeRe().test(text)) return true;
-    if (cfg.handler === "rule7-promise" && activatePromiseRe().test(text)) return true;
-    if (cfg.handler === "rule5-source" && activateSourceRe().test(text)) return true;
-    if (cfg.handler === "rule11-language" && CJK_PRESENT.test(text)) return true;
+    const kind = kindOf(cfg.handler);
+    if (kind === "manual-first" && dshKeywordsRe().test(text)) return true;
+    if (kind === "skill-auth" && activateSkillRe().test(text)) return true;
+    if (kind === "approval" && activateApprovalRe().test(text)) return true;
+    if (kind === "network" && activateNetworkRe().test(text)) return true;
+    if (kind === "backup" && activateBackupRe().test(text)) return true;
+    if (kind === "time" && activateTimeRe().test(text)) return true;
+    if (kind === "promise" && activatePromiseRe().test(text)) return true;
+    if (kind === "source" && activateSourceRe().test(text)) return true;
+    if (kind === "language" && CJK_PRESENT.test(text)) return true;
     return false;
   });
 }
@@ -33,15 +35,16 @@ export function activateForToolCall(configs, toolName, args) {
   const name = String(toolName || "");
   const argText = JSON.stringify(args || {});
   return configs.filter((cfg) => {
-    if (cfg.handler === "rule9-inline-bom" && (name === "pwsh" || name === "bash")) return true;
-    if (cfg.handler === "rule1-retry") return true;
-    if (cfg.handler === "rule18-manual-first") return true;
-    if (cfg.handler === "rule13a-backup" && (name === "pwsh" || name === "bash" || name === "edit" || name === "write")) return true;
-    if (cfg.handler === "rule12b-skill" && name === "skill") return true;
-    if (cfg.handler === "rule12a-approval" || cfg.handler === "rule12d-sensitive") {
+    const kind = kindOf(cfg.handler);
+    if (kind === "inline-command" && (name === "pwsh" || name === "bash")) return true;
+    if (kind === "retry") return true;
+    if (kind === "manual-first") return true;
+    if (kind === "backup" && (name === "pwsh" || name === "bash" || name === "edit" || name === "write")) return true;
+    if (kind === "skill-auth" && name === "skill") return true;
+    if (kind === "approval" || kind === "sensitive") {
       if (name === "pwsh" || name === "bash" || name === "edit" || name === "write" || name === "ask_user_question") return true;
     }
-    if (cfg.handler === "rule21-meta" && (name === "edit" || name === "write")) return true;
+    if (kind === "meta" && (name === "edit" || name === "write")) return true;
     if (argText) {
       const low = argText.toLowerCase();
       if (cfg.triggerKeywords.some((k) => low.includes(k.toLowerCase()))) return true;

package/lib/core/measure-kinds.js

@@ -0,0 +1,127 @@
+// measure-kinds.js - 措施类型注册表（架构 v3 §三 L1：通用层，零规则号）
+//
+// 依据：reports/2026-09-10-引擎分层架构-通用层零规则内容-v1.md
+//   §三 L1「措施类型注册表（measure kinds）：每型一个通用解释器，命名去规则号」；
+//   §八 P1「措施类型注册表 + 解释器骨架；guard-core/matcher 改 kind → interpreter；内部名去规则号」。
+//
+// 三层分工（P1）：
+//   ① MEASURE_KINDS —— 通用层的 kind 清单（**零规则号**，随包发布）；
+//   ② LEGACY_HANDLER_ALIASES —— 历史内部名（带规则号）→ kind 的**兼容映射**
+//      （P4 清淤时迁个人层配置；保留在此是为了不破坏既有配置与规则正文声明）；
+//   ③ kindOf() —— 唯一归一入口，接受 旧名 / kind 名 / 未知名 三种输入。
+//
+// 兼容面（P1 行为等价的前提）：本机 rule-engine.json 的 handlerDefaultMap/handlerOverrides、
+//   规则正文 `<!-- handler: … -->`、以及测试夹具，**仍可写旧内部名**——经 kindOf 归一后
+//   与 kind 名完全等价。新用户/新规则写 kind 名即可，无需知道任何规则号。
+export const MEASURE_KINDS = {
+  retry: "连续失败重试闸（第 3 次拒绝）",
+  time: "时间表述取证",
+  source: "引用出处标注",
+  promise: "承诺保守",
+  "inline-command": "禁止内联命令",
+  language: "语言与表达",
+  approval: "敏感操作授权确认",
+  "skill-auth": "技能调用授权",
+  network: "下载与网络",
+  backup: "写入前备份",
+  "manual-first": "先查手册再动手",
+  meta: "元规则管理",
+  "intent-direct": "无执行分点直拦",
+  "runtime-verify": "交付验证证据",
+  assembly: "插件装配类型守卫",
+  "release-asset": "发布资产规范",
+  "mount-audit": "挂载唯一性审计",
+  sensitive: "敏感操作（注入面）"
+};
+
+/** 历史内部名 → kind（兼容层；键含规则号，P4 迁个人层配置） */
+export const LEGACY_HANDLER_ALIASES = {
+  "rule1-retry": "retry",
+  "rule2-time": "time",
+  "rule5-source": "source",
+  "rule7-promise": "promise",
+  "rule9-inline-bom": "inline-command",
+  "rule11-language": "language",
+  "rule12a-approval": "approval",
+  "rule12b-skill": "skill-auth",
+  "rule12c-network": "network",
+  "rule12d-sensitive": "sensitive",
+  "rule13a-backup": "backup",
+  "rule18-manual-first": "manual-first",
+  "rule21-meta": "meta",
+  "rule22-7-direct": "intent-direct",
+  "rule23-runtime-verify": "runtime-verify",
+  "rule24-assembly-type": "assembly",
+  "rule26-release-asset": "release-asset",
+  "rule27-mount-audit": "mount-audit"
+};
+
+/**
+ * 归一为 kind 名。
+ *   旧内部名 → kind；kind 名 → 原样（幂等）；未知名 → 原样（由覆盖自省提示未覆盖）。
+ * @param {string} name
+ * @returns {string}
+ */
+export function kindOf(name) {
+  const s = String(name || "").trim();
+  if (!s) return "";
+  return LEGACY_HANDLER_ALIASES[s] || s;
+}
+
+/** 兼容旧调用名（understander 对外导出同义函数） */
+export function normalizeHandlerName(name) {
+  return kindOf(name);
+}
+
+// ── P2（2026-09-10）：个人层「措施声明」解析 + 校验（架构正本 §三 L2/L3）──
+
+/** 规则正文内联声明：`<!-- handler: <kind> -->` 或 `<!-- handler: <kind> {json} -->`
+ *  设计（方案 A，用户 2026-09-10 拍板）：**扩展既有 handler 声明**而非新增独立块——
+ *  向后兼容（旧声明零影响）、单点解析入口。正则捕获 `-->` 之前的**全部内容**，之后再拆分，
+ *  避免用嵌套正则直接匹配 JSON（`}` 截断风险）。 */
+const HANDLER_DECL_RE = /<!--\s*handler\s*:\s*([\s\S]*?)-->/i;
+
+/**
+ * 解析个人层措施声明。
+ * @param {string} body 规则正文
+ * @returns {null | {kind: string, params: object} | {error: string}}
+ *   null = 无声明；{kind, params} = 解析成功；{error} = 声明非法（调用方须 fail-closed）
+ */
+export function parseHandlerDecl(body) {
+  const m = String(body || "").match(HANDLER_DECL_RE);
+  if (!m) return null;
+  const raw = String(m[1] || "").trim();
+  if (!raw) return { error: "声明为空（`<!-- handler: -->`）" };
+  const km = /^([A-Za-z0-9][A-Za-z0-9-]*)\s*([\s\S]*)$/.exec(raw);
+  if (!km) return { error: `声明格式非法：${raw.slice(0, 60)}` };
+  const kind = kindOf(km[1]);
+  const rest = String(km[2] || "").trim();
+  let params = {};
+  if (rest) {
+    let parsed;
+    try {
+      parsed = JSON.parse(rest);
+    } catch {
+      return { error: `参数不是合法 JSON：${rest.slice(0, 60)}` };
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { error: `参数必须是 JSON 对象：${rest.slice(0, 60)}` };
+    }
+    params = parsed;
+  }
+  return { kind, params };
+}
+
+/**
+ * 校验措施声明（架构正本 §三 L3：**kind 未注册即拒绝并明确报错，fail-closed**）。
+ * @param {null | {kind: string} | {error: string}} decl parseHandlerDecl 的输出
+ * @returns {null | string} null = 通过（或无声明）；字符串 = 明确错误原因
+ */
+export function validateMeasure(decl) {
+  if (!decl) return null;
+  if (decl.error) return decl.error;
+  if (!Object.prototype.hasOwnProperty.call(MEASURE_KINDS, decl.kind)) {
+    return `kind 未注册：${decl.kind}（已注册：${Object.keys(MEASURE_KINDS).join(" / ")}）`;
+  }
+  return null;
+}

package/lib/core/patterns.js

@@ -303,6 +303,12 @@ const ALLOW_SEG_RE =
 // 0.5.12（F4）：纯字符串/纯输出段（整段是引号包裹字符串或 $() 子表达式）——不是命令，放行。
 // 保守边界：只匹配"整段即字符串"（^...$ 锚定），不让 node -e "..." / curl -o "..." 借道。
 const PURE_STRING_SEG_RE = /^(?:"[^"\r\n]*"|'[^'\r\n]*'|`[^`\r\n]*`|\$\(\s*[^()\r\n]*\s*\))+$/;
+// F5（2026-09-10 修复，第三方实测）：`Remove-Item Env:NAME` 的**操作对象是进程环境变量，不是文件**，
+// 此前被 MUTATING_CMD_RE 的 Remove-Item 命中判写（ERR-JCSE3O 的类判定来源）。
+// 边界（保守）：仅当整段目标都是 Env:/$env: 形式时豁免；`Remove-Item <路径>`、混合目标、
+// 选项在目标之前（如 `Remove-Item -Force Env:X`）一律不豁免——宁可误拦不可放行真删除。
+const ENV_SCOPE_REMOVE_SEG_RE =
+  /^\s*Remove-Item\s+(?:\$env:|Env:)[\w()]+\s*(?:-[\w]+\s+(?:"[^"]*"|'[^']*'|[^\s;|]+)\s*)*$/i;
 // 剥离 try/catch/finally 控制块：块内语句与主语句同样接受只读判定（Try-* 不是 cmdlet）。
 // 注意：不做全量 [{}] 替换——if/else 子表达式（$(if(...){...}else{...})）会被切碎误判。
 function stripControlBlocks(command) {
@@ -319,12 +325,38 @@ export function isMutationCommand(command) {
   return typeof command === "string" && MUTATING_CMD_RE.test(command);
 }
 
-/** 只读命令链按分隔符折段（机制 B，2026-08-24）：`; 换行 && || |`（管道前后是命令链；`2>&1`/`2>$null` 的 stderr 重定向不拆分） */
+/** 只读命令链按分隔符折段（机制 B，2026-08-24）：`; 换行 && || |`（管道前后是命令链；`2>&1`/`2>$null` 的 stderr 重定向不拆分）
+ *  F5（2026-09-10 修复，第三方实测）：**引号感知**——此前裸拆 `|` 会把**引号内的 `|`** 当分隔符
+ *  （正则 alternation `-Pattern 'a|b'`、格式串 `"{0} | x"`、`-notmatch 'x|y'`）→ 切出无法识别的残段
+ *  → L354 保守判非只读 → 整条只读命令被规则 22 按 write 拦（ERR-4WOAKG / 9T886X / Z8M7YC / IKXLU8）。
+ *  现：`'…'` / `"…"` / `` `…` `` 内的分隔符不拆。转义语义按 PS：`'` 内不转义（`''` 表一个单引号）；
+ *  `"` 与 `` ` `` 内 `\` / `` ` `` 转义下一字符（兼容跨语言写法）。 */
 function splitCommandSegments(command) {
-  return String(command)
-    .split(/\r?\n|;|&&|\|\||(?<!\d)\|/)
-    .map((s) => s.trim())
-    .filter(Boolean);
+  const s = String(command);
+  const out = [];
+  let buf = "";
+  let quote = null;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (quote) {
+      buf += c;
+      if (quote !== "'" && (c === "\\" || c === "`")) { buf += s[i + 1] ?? ""; i++; continue; }
+      if (c === quote) quote = null;
+      continue;
+    }
+    if (c === "'" || c === '"' || c === "`") { quote = c; buf += c; continue; }
+    if (c === "\r") continue;
+    if (c === "\n" || c === ";") { out.push(buf); buf = ""; continue; }
+    if (c === "&" && s[i + 1] === "&") { out.push(buf); buf = ""; i++; continue; }
+    if (c === "|") {
+      if (s[i + 1] === "|") { out.push(buf); buf = ""; i++; continue; }
+      if (i > 0 && /\d/.test(s[i - 1])) { buf += c; continue; } // 保留原 (?<!\d) 语义
+      out.push(buf); buf = ""; continue;
+    }
+    buf += c;
+  }
+  out.push(buf);
+  return out.map((x) => x.trim()).filter(Boolean);
 }
 
 /** 判断命令文本是否只读（读文件/查询类，无写入/删除/提交副作用）。
@@ -345,6 +377,7 @@ export function isReadOnlyCommand(command) {
     const s = String(seg).trim();
     if (!s) return true; // 剥离残留的空段放行
     if (s.startsWith("#")) return true;
+    if (ENV_SCOPE_REMOVE_SEG_RE.test(s)) return true; // F5：环境变量操作非文件删除（须在 MUTATING 之前）
     if (MUTATING_CMD_RE.test(s)) return false;
     if (MUTATING_METHOD_RE.test(s)) return false;
     if (COM_CONTENT_ASSIGN_RE.test(s)) return false; // $doc.Text=... 是写文档

package/lib/core/state.js

@@ -156,6 +156,12 @@ export function getSessionState(state, sessionId) {
       selfCertCount: new Map(),
       authorizations: [],
       backups: [],
+      // D2 修复（2026-09-10，独立 DSH_HOME 试点反馈）：待决 ask 提升为**会话级**。
+      // 此前放在 turn 级：用户先发新消息 → turn/start → resetTurn 整体替换 s.turn
+      // → pendingAsk 被刷成 null → 随后到达的 ask 答复走不进登记分支，
+      // 实测「用户消息与 ask 答复并发」时一次 ask 的授权**全部未登记**（ERR-M9Z47H）。
+      // 语义依据：pendingAsk 描述的是「一次工具调用的待决状态」，跨回合有效，不属回合文本状态。
+      pendingAsk: null,
       mountAuditRevision: 0,
       mountAuditSignature: "",
       lastCommandOutput: "",
@@ -252,7 +258,8 @@ export function freshTurn() {
     intents: null,
     intentState: "lexicon", // lexicon | llm-pending | llm-ready（LLM 意图兜底状态）
     llmIntent: null, // { raw, verdict, reason, confidence, at }（LLM 裁决，非高置信时词表兜底）
-    pendingAsk: null,
+    // pendingAsk 已迁至**会话级**（见 getSessionState）——D2 修复，2026-09-10。
+    // 此处不再定义回合级 pendingAsk：避免两处同名状态互相遮蔽。
     pendingToolCalls: new Map(),
     getDateSeen: false,
     backupSeen: false,

package/lib/core/tool-catalog.js

@@ -36,7 +36,10 @@ const ANALYSIS_TOOLS = new Set([
   "cordis_inspect_list", "cordis_inspect_query", "cordis_inspect_self",
   "ask_user_question",
   // ESR 状态查询（读工作区记忆状态，无持久副作用）
-  "esr_status", "esr_ready", "esr_model"
+  "esr_status", "esr_ready", "esr_model",
+  // univer-office 只读族（2026-09-09 补录：规则 24④ 实测 univer_execute 被硬拦——该族未分类；
+  // 逐工具分类而非前缀一刀切：只读/查询类 → analysis）
+  "univer_status", "univer_inspect", "univer_lint", "univer_api", "univer_resources"
 ]);
 
 // 产物类：工具自然行为会写文件（artifact/工作区/会话存储），低风险——放行 + 审计。
@@ -59,7 +62,9 @@ const ARTIFACT_TOOLS = new Set([
   // （12A isSensitiveToolCall / 13A / 24 装配判定）链上覆盖，不再各自归类。
   "dev_stage_add", "dev_stage_call", "dev_stage_promote", "dev_stage_demote",
   // ESR 工程状态写操作（写工作区记忆存储，engram_store 同族）
-  "esr_task", "esr_node", "esr_link", "esr_claim", "esr_close", "esr_unclaim", "esr_dep", "esr_gc"
+  "esr_task", "esr_node", "esr_link", "esr_claim", "esr_close", "esr_unclaim", "esr_dep", "esr_gc",
+  // univer-office 产物族（2026-09-09 补录）：截图写 artifact；univer_new 只新建不覆盖
+  "univer_screenshot", "univer_new"
 ]);
 
 // 变更类：维持现有严格授权（规则 22 粒度比对 / 12A 敏感授权 / 13A 备份）
@@ -77,7 +82,10 @@ const MUTATING_TOOLS = new Set([
   "followup_task", "spawn_teammate", "team_task_create", "team_task_get",
   "team_task_list", "team_task_update", "wait_agent",
   // 本机命名空间兜底（dev_ 前缀 = 开发侧工具，行为可写可管理；具体已枚举，前缀兜底未来新增）
-  "dev_router_status"
+  "dev_router_status",
+  // univer-office 变更族（2026-09-09 补录，规则 24④：未分类 + 疑似写 → 硬拦；逐工具分类纳入守卫链）
+  "univer_execute", "univer_import", "univer_unit", "univer_worktree",
+  "univer_compile_svg", "univer_export", "univer_print_pdf"
 ]);
 
 // 前缀规则：生态命名空间的工具自动归类（0.5.9 新）——将来的新插件遵循惯例即被覆盖。

package/lib/core/understander.js

@@ -13,6 +13,7 @@ import {
   URL_RE,
   sourceMarkRe
 } from "./patterns.js";
+import { normalizeHandlerName, parseHandlerDecl, validateMeasure } from "./measure-kinds.js";
 
 // 2026-08-31（残余1 剥离，用户定稿）：本机默认偏好表从代码下沉到本机配置——
 // rule-engine.json 的 handlerDefaultMap（可选键，可整体替换/清空）。代码层默认表为空
@@ -87,40 +88,21 @@ function hintPatterns(checkText) {
   return [...new Set(hints)];
 }
 
-/** 规则正文内联 handler 声明（T3）：`<!-- handler: rule22-7-direct -->` */
-const HANDLER_DECL_RE = /<!--\s*handler\s*:\s*([a-z0-9][a-z0-9-]*)\s*-->/i;
-
 /**
- * 执行器语义别名（残余3 通用化，2026-08-31）：
- * 内部执行器名（rule12a-approval 等）带规则编号影子——陌生用户声明时不应见到。
- * 语义名 → 内部名映射：声明/配置写语义名即归一；直接写内部名不受影响（别名表无该键）。
- * 归一发生在 resolveHandler 末端；guard-core 分支（按内部名）零改动。
+ * 措施类型归一 + 声明解析（架构 v3 P1/P2，2026-09-10）：
+ *   注册表（MEASURE_KINDS）+ 兼容别名表（LEGACY_HANDLER_ALIASES）+ 归一入口（kindOf）
+ *   + 声明解析（parseHandlerDecl）+ 校验（validateMeasure）均在 ./measure-kinds.js
+ *   —— 本文件不含任何规则号字面量。
+ *   归一语义：历史内部名 → kind；kind 名 → 原样（幂等）；未知名 → 原样（覆盖自省提示未覆盖）。
  */
-const HANDLER_ALIASES = {
-  retry: "rule1-retry",
-  time: "rule2-time",
-  source: "rule5-source",
-  promise: "rule7-promise",
-  "inline-command": "rule9-inline-bom",
-  language: "rule11-language",
-  approval: "rule12a-approval",
-  "skill-auth": "rule12b-skill",
-  network: "rule12c-network",
-  backup: "rule13a-backup",
-  "manual-first": "rule18-manual-first",
-  meta: "rule21-meta",
-  "intent-direct": "rule22-7-direct",
-  "runtime-verify": "rule23-runtime-verify",
-  assembly: "rule24-assembly-type",
-  "release-asset": "rule26-release-asset",
-  "mount-audit": "rule27-mount-audit"
-};
-
-/** 语义名归一（内部名原样返回；未知名保持原样——由覆盖自省提示未覆盖） */
-export function normalizeHandlerName(name) {
-  const s = String(name || "");
-  return HANDLER_ALIASES[s] || s;
-}
+export {
+  normalizeHandlerName,
+  kindOf,
+  MEASURE_KINDS,
+  LEGACY_HANDLER_ALIASES,
+  parseHandlerDecl,
+  validateMeasure
+} from "./measure-kinds.js";
 
 /**
  * handler 绑定解析（T3 通用化，2026-08-31）——优先级：
@@ -135,8 +117,10 @@ export function resolveHandler(rule, opts = {}) {
   const overrides = opts?.handlerOverrides;
   if (overrides && typeof overrides === "object" && overrides[id] !== undefined) return normalizeHandlerName(overrides[id]);
   const body = String(rule?.body || "");
-  const decl = body.match(HANDLER_DECL_RE);
-  if (decl) return normalizeHandlerName(decl[1]);
+  const decl = parseHandlerDecl(body);
+  // P2（架构正本 §三 L3）：声明非法（JSON 坏 / 空声明）**或 kind 未注册** → fail-closed（不执行）；
+  // 错误详情由 understandRule 写入 config.measureError（此处只保证不产出可执行的 handler）。
+  if (decl) return validateMeasure(decl) ? "" : normalizeHandlerName(decl.kind);
   // 剥离后（2026-08-31）：代码层无默认表；defaultMap 由调用方注入（本机=配置 handlerDefaultMap）
   const map = opts?.defaultMap || {};
   return normalizeHandlerName(map[rule?.index] || "");
@@ -156,6 +140,9 @@ export function understandRule(rule, opts = {}) {
   const triggerKeywords = splitKeywords(elems.trigger);
   const confidence = level && elems.trigger && elems.check && (elems.action || level.toUpperCase().includes("D")) ? "high" : level ? "medium" : "low";
   const handler = resolveHandler(rule, opts);
+  // P2（2026-09-10）：个人层措施声明 → 措施实例 {kind, params}；kind 未注册 / 声明非法 → fail-closed
+  const decl = parseHandlerDecl(rule.body || "");
+  const measureError = validateMeasure(decl);
   const config = {
     ruleId: rule.index,
     title: rule.title,
@@ -164,6 +151,8 @@ export function understandRule(rule, opts = {}) {
     actions,
     confidence,
     handler,
+    measure: decl && !measureError ? decl : null,
+    measureError: measureError || "",
     triggerKeywords,
     hints,
     elements: elems,

package/lib/index.js

@@ -39,6 +39,7 @@ import {
   askResultSelectedText,
   classifyAskScopeType,
   inferPathPrefixFromText,
+  inferPathPrefixesFromText,
   inferTypeFromText,
   isAuthMessage,
   isDirectiveMessage,
@@ -710,7 +711,8 @@ export function handleSessionEvent(ctx, session, event) {
     if (s.turn.toolCount === 1) s.turn.firstToolName = toolName;
     if (toolName === "ask_user_question") {
       s.turn.askSeen = true;
-      s.turn.pendingAsk = { callId: d.callId, questions: args?.questions || [] };
+      // D2 修复（2026-09-10）：写**会话级**（不随 turn/start 清空）；at 供陈旧值保护
+      s.pendingAsk = { callId: d.callId, questions: args?.questions || [], at: Date.now() };
     }
     const pendingCall = { name: toolName, args };
     const targetPath = args?.file_path ?? args?.path;
@@ -1013,8 +1015,9 @@ export function handleSessionEvent(ctx, session, event) {
       if (output) s.lastCommandOutput = output;
     }
 
-    const pending = s.turn.pendingAsk;
-    if (pending) {
+    const pending = s.pendingAsk;
+    // D2 修复（2026-09-10）：会话级待决 ask + 陈旧值保护（30 分钟未答视为作废，防跨回合误登记）
+    if (pending && (!pending.at || Date.now() - pending.at <= 30 * 60 * 1000)) {
       const result = d.result ?? d.value ?? d;
       if (askResultApproved(result)) {
         s.turn.realUserSeen = true; // v0.5.7：ask 弹窗答复也算"真实用户在场"
@@ -1024,7 +1027,12 @@ export function handleSessionEvent(ctx, session, event) {
         // 授权范围只取“问题核心 + 用户实际选择”，不再把全部选项描述纳入；
         // 避免“仅会话内说明/不跨会话保留”等选项说明把一次小授权放大成全局 12h（2026-08-24 修复）
         const scopeText = `${askQuestionCoreText(pending.questions)} ${selectedText}`.trim();
-        const pathPrefix = inferPathPrefixFromText(scopeText || qText);
+        // A2 修复（2026-09-10）：原用单数版 inferPathPrefixFromText——只记一个路径且取"最长"。
+        // 探针实测：多路径问题文本下"最长"往往是次要路径（如"去向 .backups/trash-x"）而非主路径，
+        // 主操作路径丢失 → 授权匹配必然失败。改为复数版：pathPrefix 取首个（按文本出现顺序=主路径，
+        // 与用户消息侧 scopesFromIntents 的复数口径对齐），全部路径记入 pathPrefixes 供 authMatches 任一匹配。
+        const pathPrefixes = inferPathPrefixesFromText(scopeText || qText);
+        const pathPrefix = pathPrefixes[0] || "";
         // 0.5.10 建议1①：ask 答复结构化——操作类型从答复文本推断（write/command/any），不再一律 any
         // （修复"弹窗答复接不住真想操作"的粒度问题——V476AL 同族）
         const authRecord = {
@@ -1032,6 +1040,7 @@ export function handleSessionEvent(ctx, session, event) {
           pathPrefix,
           source: "ask"
         };
+        if (pathPrefixes.length > 1) authRecord.pathPrefixes = pathPrefixes;
         const sessionWide = isSessionWideAskText(scopeText) || isSessionWideAskText(selectedText);
         if (sessionWide) authRecord.expiresAt = Date.now() + 12 * 60 * 60 * 1000;
         else if (!pathPrefix) authRecord.expiresAt = Date.now() + 2 * 60 * 1000;
@@ -1098,7 +1107,7 @@ export function handleSessionEvent(ctx, session, event) {
           session: sid
         });
       }
-      s.turn.pendingAsk = null;
+      s.pendingAsk = null; // D2 修复（2026-09-10）：清理**会话级**待决 ask
     }
     return;
   }

package/package.json

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

package/scripts/dualtrack-check.mjs

@@ -11,11 +11,20 @@
 //   —— 通用中文文案（字符串字面量内的 CJK）**不计入**：第三方判据明示「中文≠个人化，
 //      通用功能词/提示语是产品能力」。runtime 计数仍在 --report 里显示，供参考。
 //
+// 扫描判据 D（2026-09-10 分层架构 v3 · P0 追加）：规则号字面量
+//   依据：reports/2026-09-10-引擎分层架构-通用层零规则内容-v1.md §七。
+//   模式：rule\d+[A-Za-z]?-  /  byId\.get\("\d+"\)  /  \[guardian:rule\d+\]  /  rule-hint\.\d+
+//         /  ruleId\s*[=!]==?\s*"<N>"（2026-09-10 用户拍板纳入；§七 原列四条，此条据 §二 现状证据补入）
+//   为何单列一判据：「机制以规则号为骨架」比「文案含编号」更根本，且与判据 A 不同维度
+//   （A 抓本机私有词/映射键；D 抓通用层住着规则体系），故各自独立棘轮。
+//   口径：去注释后扫描（注释属开发溯源，非机制骨架）；不设白名单——代码层零规则号。
+//
 // 棘轮（ratchet）：基线记录各文件计数，只许降不许升。
 //   node scripts/dualtrack-check.mjs            # 比对基线（CI/发布门禁用）
 //   node scripts/dualtrack-check.mjs --init     # 首次生成基线
 //   node scripts/dualtrack-check.mjs --update   # 手动更新基线（须在提交说明里写清改了什么）
 //   node scripts/dualtrack-check.mjs --report   # 只打印各文件计数
+//   node scripts/dualtrack-check.mjs --root <dir>  # 改扫描根（仅测试隔离用；非默认根会显著提示）
 //
 // 白名单（scripts/dualtrack-whitelist.json）：
 //   files   —— 整文件豁免（如 lib/lang/**，第 3 批语言包）
@@ -26,7 +35,14 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadMarkers } from "../lib/core/dualtrack-markers.js";
 
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+// ── 命令行参数（提前解析：--root 必须在下面的路径常量之前生效）──
+const ARGV = process.argv.slice(2);
+const args = new Set(ARGV);
+const rootIdx = ARGV.indexOf("--root");
+const IS_CUSTOM_ROOT = rootIdx >= 0;
+const ROOT = IS_CUSTOM_ROOT && ARGV[rootIdx + 1]
+  ? path.resolve(ARGV[rootIdx + 1])
+  : path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const LIB = path.join(ROOT, "lib");
 const BASELINE_FILE = path.join(ROOT, "scripts", "dualtrack-baseline.json");
 const WHITELIST_FILE = path.join(ROOT, "scripts", "dualtrack-whitelist.json");
@@ -35,6 +51,15 @@ const RESIDUE_FILE = path.join(ROOT, "scripts", "local-residue-markers.txt");
 const CJK = /[\u4e00-\u9fff]/;
 const MAP_KEY_RE = /^\d+[A-Z]?$/;
 
+// ── 判据 D：规则号字面量（§七；口径=去注释后扫描，无白名单）──
+const RULE_LITERAL_PATTERNS = [
+  ["executor-name", /rule\d+[A-Za-z]?-/g, "内部执行器名 rule<N>[x]-"],
+  ["byid-get", /byId\.get\(\s*["'`]\d+["'`]\s*\)/g, '按规则号取规则 byId.get("<N>")'],
+  ["guardian-tag", /\[guardian:rule\d+\]/g, "对外文案 [guardian:rule<N>]"],
+  ["rule-hint", /rule-hint\.\d+/g, "rule-hint.<N>"],
+  ["ruleid-eq", /ruleId\s*[=!]==?\s*["'`]\d+[A-Za-z]?["'`]/g, '硬编码规则号比较 ruleId === "<N>"']
+];
+
 // ── 白名单 ──
 /** 白名单两层（2026-09-09）：包内通用白名单 + 本机 rule-engine.json 的 dualtrack.whitelist 合并。
  *  包内那份随包发布（如 lib/lang/**）；本机那份记录「我豁免我自己的某条」，不进包。 */
@@ -77,6 +102,73 @@ function fileExempt(relPath, patterns) {
   return false;
 }
 
+// ── 去注释（判据 D 用）：保留字符串/模板/正则原文，注释替换为空白（保持行结构） ──
+function stripComments(src) {
+  let out = "";
+  let i = 0;
+  const n = src.length;
+  let prevSig = "";
+  const push = (s) => { out += s; };
+  while (i < n) {
+    const c = src[i];
+    const c2 = src[i + 1];
+    if (c === "/" && c2 === "/") {
+      while (i < n && src[i] !== "\n") { push(" "); i++; }
+      continue;
+    }
+    if (c === "/" && c2 === "*") {
+      push("  "); i += 2;
+      while (i < n && !(src[i] === "*" && src[i + 1] === "/")) {
+        push(src[i] === "\n" ? "\n" : " ");
+        i++;
+      }
+      if (i < n) { push("  "); i += 2; }
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      const q = c;
+      push(c); i++;
+      while (i < n) {
+        if (src[i] === "\\") { push(src[i] + (src[i + 1] || "")); i += 2; continue; }
+        push(src[i]);
+        if (src[i] === q) { i++; break; }
+        i++;
+      }
+      prevSig = "str";
+      continue;
+    }
+    // 正则字面量：仅在可能的正则位置整体复制（否则 / 是除号）
+    if (c === "/" && prevSig !== "ident" && prevSig !== ")" && prevSig !== "]" && prevSig !== "str") {
+      let j = i + 1;
+      let inClass = false;
+      let closed = false;
+      while (j < n) {
+        const ch = src[j];
+        if (ch === "\\") { j += 2; continue; }
+        if (ch === "\n") break;
+        if (ch === "[") inClass = true;
+        else if (ch === "]") inClass = false;
+        else if (ch === "/" && !inClass) { closed = true; break; }
+        j++;
+      }
+      if (closed) {
+        push(src.slice(i, j + 1));
+        i = j + 1;
+        while (i < n && /[a-z]/i.test(src[i])) { push(src[i]); i++; }
+        prevSig = "regex";
+        continue;
+      }
+    }
+    push(c);
+    if (/[A-Za-z0-9_$]/.test(c)) prevSig = "ident";
+    else if (c === ")") prevSig = ")";
+    else if (c === "]") prevSig = "]";
+    else if (!/\s/.test(c)) prevSig = "other";
+    i++;
+  }
+  return out;
+}
+
 // ── 词法扫描：剔除注释，收集字符串字面量与对象键 ──
 /**
  * @returns {{strings: string[], mapKeys: string[]}}
@@ -203,6 +295,16 @@ function tokenize(src) {
 function scanFile(absPath, relPath, whitelist, residueMarks) {
   const src = fs.readFileSync(absPath, "utf8");
   const { strings, mapKeys } = tokenize(src);
+  // 判据 D：去注释后扫规则号字面量
+  const code = stripComments(src);
+  let ruleLiterals = 0;
+  const ruleLiteralHits = [];
+  for (const [id, re, desc] of RULE_LITERAL_PATTERNS) {
+    const m = code.match(re);
+    if (!m) continue;
+    ruleLiterals += m.length;
+    if (ruleLiteralHits.length < 3) ruleLiteralHits.push(`${id}×${m.length}（${desc}）如 ${m[0]}`);
+  }
   let runtime = 0;
   const runtimeHits = [];
   for (const s of strings) {
@@ -228,11 +330,13 @@ function scanFile(absPath, relPath, whitelist, residueMarks) {
     runtime,
     mapKeys: mapHits.length,
     local,
+    ruleLiterals,
     // 判据 A：total 只计「本机性」两类；通用中文文案（runtime）不计入闸
     total: mapHits.length + local,
     runtimeHits,
     mapHits: mapHits.slice(0, 5),
-    localHits
+    localHits,
+    ruleLiteralHits
   };
 }
 
@@ -247,7 +351,7 @@ function walk(dir, base = dir, out = []) {
 }
 
 // ── 主流程 ──
-const args = new Set(process.argv.slice(2));
+if (IS_CUSTOM_ROOT) console.log(`SCAN ROOT（非默认，仅测试隔离用）：${ROOT}\n`);
 const whitelist = loadWhitelist();
 // 本机标识词表：与 B2 扫描器共用唯一加载器（本机配置优先 → 环境变量 → 包内示例）
 const { markers: residueMarks, source: markersSource } = loadMarkers({ root: ROOT });
@@ -259,16 +363,22 @@ if (residueMarks.length === 0) {
 const files = walk(LIB).filter((rel) => !fileExempt(rel, whitelist.files));
 const results = files.map((rel) => scanFile(path.join(LIB, rel), rel, whitelist, residueMarks));
 const counts = {};
-for (const r of results) counts[`lib/${r.relPath}`] = r.total;
+const ruleCounts = {};
+for (const r of results) {
+  counts[`lib/${r.relPath}`] = r.total;
+  ruleCounts[`lib/${r.relPath}`] = r.ruleLiterals;
+}
 const grandTotal = results.reduce((a, r) => a + r.total, 0);
+const ruleGrandTotal = results.reduce((a, r) => a + r.ruleLiterals, 0);
 
 if (args.has("--report")) {
-  for (const r of results.sort((a, b) => b.total - a.total)) {
-    if (r.total === 0) continue;
-    console.log(`  ${String(r.total).padStart(4)}  lib/${r.relPath}  [映射键 ${r.mapKeys} / 本机标识 ${r.local} / 通用中文文案 ${r.runtime}（不计入闸）]`);
+  for (const r of results.sort((a, b) => (b.total + b.ruleLiterals) - (a.total + a.ruleLiterals))) {
+    if (r.total === 0 && r.ruleLiterals === 0) continue;
+    console.log(`  ${String(r.total).padStart(4)}  lib/${r.relPath}  [映射键 ${r.mapKeys} / 本机标识 ${r.local} / 通用中文文案 ${r.runtime}（不计入闸）] [规则号字面量 ${r.ruleLiterals}]`);
     if (r.mapHits.length) console.log(`        命中键：${r.mapHits.join(" / ")}`);
+    if (r.ruleLiteralHits.length) console.log(`        规则号字面量：${r.ruleLiteralHits.join("；")}`);
   }
-  console.log(`\nDUALTRACK REPORT：${results.length} 文件，合计 ${grandTotal}`);
+  console.log(`\nDUALTRACK REPORT：${results.length} 文件，判据 A（分层残留）合计 ${grandTotal}，判据 D（规则号字面量）合计 ${ruleGrandTotal}`);
   process.exit(0);
 }
 
@@ -287,13 +397,15 @@ if (args.has("--init") || args.has("--update")) {
   }
   const payload = {
     generatedAt: new Date().toISOString(),
-    note: "dualtrack 棘轮基线：各文件「分层残留」计数，只许降不许升。--init 首次生成，--update 手动更新（须在提交说明里写清改了什么）。",
+    note: "dualtrack 棘轮基线：各文件计数，只许降不许升。files/total=判据 A（分层残留）；ruleLiteralFiles/ruleLiteralsTotal=判据 D（规则号字面量）。--init 首次生成，--update 手动更新（须在提交说明里写清改了什么）。",
     total: grandTotal,
-    files: counts
+    files: counts,
+    ruleLiteralsTotal: ruleGrandTotal,
+    ruleLiteralFiles: ruleCounts
   };
   fs.writeFileSync(BASELINE_FILE, JSON.stringify(payload, null, 2) + "\n", "utf8");
   console.log(`${isUpdate ? "UPDATED" : "INITIALIZED"} ${BASELINE_FILE}`);
-  console.log(`基线合计：${grandTotal}（${Object.keys(counts).length} 个文件）`);
+  console.log(`基线：判据 A 合计 ${grandTotal}（${Object.keys(counts).length} 文件）／判据 D 合计 ${ruleGrandTotal}`);
   process.exit(0);
 }
 
@@ -324,12 +436,46 @@ for (const [file, b] of Object.entries(base)) {
   if (counts[file] === undefined && b > 0) improvements.push(`${file}: 文件已删除（基线 ${b}）`);
 }
 
-if (regressions.length > 0) {
-  console.error(`DUALTRACK FAIL：${regressions.length} 项超出基线（只许降不许升）`);
-  for (const r of regressions) console.error(`  ✗ ${r}`);
-  console.error("\n  处置：把新增内容迁个人层/配置层，或（确属通用功能词）登记 scripts/dualtrack-whitelist.json");
+// 判据 D 比对（独立棘轮；基线缺该维度 → fail-closed，提示 --update）
+const ruleBase = baseline.ruleLiteralFiles;
+const ruleRegressions = [];
+const ruleImprovements = [];
+if (!ruleBase || typeof ruleBase !== "object") {
+  ruleRegressions.push("基线缺「规则号字面量」维度（ruleLiteralFiles）——判据 D 于 2026-09-10 新增，请运行 --update 记录基线");
+} else {
+  for (const [file, count] of Object.entries(ruleCounts)) {
+    const b = ruleBase[file];
+    if (b === undefined) {
+      if (count > 0) ruleRegressions.push(`${file}: 新增文件含规则号字面量 ${count} 处（基线无此文件）`);
+      continue;
+    }
+    if (count > b) {
+      const r = results.find((x) => `lib/${x.relPath}` === file);
+      const detail = r ? r.ruleLiteralHits.slice(0, 2).join("；") : "";
+      ruleRegressions.push(`${file}: ${count} > 基线 ${b}${detail ? `（如：${detail}）` : ""}`);
+    } else if (count < b) {
+      ruleImprovements.push(`${file}: ${count} < 基线 ${b}`);
+    }
+  }
+  for (const [file, b] of Object.entries(ruleBase)) {
+    if (ruleCounts[file] === undefined && b > 0) ruleImprovements.push(`${file}: 文件已删除（基线 ${b}）`);
+  }
+}
+
+if (regressions.length > 0 || ruleRegressions.length > 0) {
+  if (regressions.length > 0) {
+    console.error(`DUALTRACK FAIL（判据 A 分层残留）：${regressions.length} 项超出基线（只许降不许升）`);
+    for (const r of regressions) console.error(`  ✗ ${r}`);
+  }
+  if (ruleRegressions.length > 0) {
+    console.error(`DUALTRACK FAIL（判据 D 规则号字面量）：${ruleRegressions.length} 项超出基线（只许降不许升）`);
+    for (const r of ruleRegressions) console.error(`  ✗ ${r}`);
+  }
+  console.error("\n  处置：分层残留 → 迁个人层/配置层，或（确属通用功能词）登记 scripts/dualtrack-whitelist.json");
+  console.error("        规则号字面量 → 改为通用 kind 名（架构 v3 §三 L1）；判据 D 不设白名单。");
   process.exit(1);
 }
-console.log(`DUALTRACK OK：合计 ${grandTotal}（基线 ${baseline.total ?? "?"}）${improvements.length ? `，${improvements.length} 个文件下降可 --update` : ""}`);
-for (const im of improvements.slice(0, 5)) console.log(`  ↓ ${im}`);
+const downCount = improvements.length + ruleImprovements.length;
+console.log(`DUALTRACK OK：判据 A 合计 ${grandTotal}（基线 ${baseline.total ?? "?"}）／判据 D 合计 ${ruleGrandTotal}（基线 ${baseline.ruleLiteralsTotal ?? "?"}）${downCount ? `，${downCount} 个文件下降可 --update` : ""}`);
+for (const im of [...improvements, ...ruleImprovements].slice(0, 5)) console.log(`  ↓ ${im}`);
 process.exit(0);

package/scripts/publish-aptitude-check.mjs

@@ -64,8 +64,11 @@ process.env.DSH_WORKSPACE = root;
   const plain = understandRule(arbitrary);
   check(plain.handler === "", "③ 任意编号 + 无声明：handler 为空（纯自证分流，不误绑定本机执行器）");
   check(plain.actions.includes("deny") && plain.actions.includes("self-certify"), "③ 任意编号：A+D 动作解析正确（deny+self-certify）");
-  const declared = understandRule({ ...arbitrary, body: arbitrary.body + "\n<!-- handler: rule12a-approval -->" });
-  check(declared.handler === "rule12a-approval", "③ 任意编号 + 声明：绑定指定执行器");
+  // 架构 v3 P1：声明值统一归一为 kind 名——kind 名（陌生用户视角）与历史内部名（兼容）都须绑定
+  const declaredKind = understandRule({ ...arbitrary, body: arbitrary.body + "\n<!-- handler: approval -->" });
+  check(declaredKind.handler === "approval", "③ 任意编号 + 声明（kind 名）：绑定指定执行器");
+  const declaredLegacy = understandRule({ ...arbitrary, body: arbitrary.body + "\n<!-- handler: rule12a-approval -->" });
+  check(declaredLegacy.handler === "approval", "③ 任意编号 + 声明（历史内部名）：归一为同一 kind");
   const covered = analyzeCoverage(understandAll([arbitrary]));
   check(covered.uncovered.some((u) => u.ruleId === "X-77"), "③ 任意编号 A 级无 handler：被标记未覆盖（提示正确）");
   // 通用化闭环：defaultMap 清空 → 陌生规则无兜底绑定（纯声明式世界，不借道本机偏好表）；

package/scripts/release-plugin.mjs

@@ -166,7 +166,8 @@ if (dryRun) {
   // §1.2（2026-09-08）dry-run 可观测项（单测锚点）
   console.log(`[DRY-RUN] plugins.json 条目: ${entry ? `${entry.name} (dir=${entry.dir})` : "(未命中——将回退目录路径参数)"}`);
   console.log(`[DRY-RUN] dist-tags 轮询: ${Math.max(30, Number(process.env.RELEASE_DIST_TAG_POLL_SEC) || 180)}s（RELEASE_DIST_TAG_POLL_SEC 可配）`);
-  console.log(`[DRY-RUN] README 四点同步: 徽章 / 正文当前版本 / 历史表新行 / 固定源占位注释`);
+  console.log(`[DRY-RUN] README 四点同步: 徽章 / 正文当前版本 / 历史表新行 / 固定源自动维护`);
+  console.log(`[DRY-RUN] 固定源将更新为: **${nextVer}（当前）** 锚点 ${quiet(`cd /d "${dir}" && git rev-parse HEAD`).trim().slice(0, 7)}（发布后自动回填 release 提交号）`);
   process.exit(0);
 }
 writeFileSync(pkgPath, readFileSync(pkgPath, "utf8").replace(`"version": "${oldVer}"`, `"version": "${nextVer}"`));
@@ -186,19 +187,32 @@ for (const readme of ["README.md", "README.en.md"]) {
     if (replaced !== text) writeFileSync(rp, replaced);
   }
 }
-// §1.2-②（2026-09-08 第二批）：README 正文"当前版本"行同步 + 固定源占位注释（发布后回填锚点，可 grep）
+// §1.2-②（2026-09-08 第二批）：README 正文"当前版本"行同步
+// 方案 A（2026-09-09，踩坑 140 根治）：固定源行**自动维护**——bump 时插入「（当前）」行（锚点=改号前 HEAD），
+//   发布提交后由 §5.5 回填真实 release 提交号；旧「（当前）」标记与遗留占位注释一并清理。
+//   旧做法只插占位注释，而 B1 门禁要求「固定源=package 版本」→ 每次发布必撞（0.6.3 首发实证）。
+const headBeforeShort = quiet(`cd /d "${dir}" && git rev-parse HEAD`).trim().slice(0, 7);
+let fixedSourceBumpLine = "";
 for (const readme of ["README.md", "README.en.md"]) {
   const rp = join(dir, readme);
   if (!existsSync(rp)) continue;
   let rtxt = readFileSync(rp, "utf8");
   const before = rtxt;
   rtxt = rtxt.replace(/(> 当前版本 \*\*)\d+\.\d+\.\d+(\*\*)/, `$1${nextVer}$2`);
-  if (readme === "README.md" && rtxt.includes("## 发行固定源") && !rtxt.includes("<!-- fixed-source:")) {
-    rtxt = rtxt.replace("## 发行固定源", "## 发行固定源\n\n<!-- fixed-source: 待发布回填 -->");
+  if (readme === "README.md" && rtxt.includes("## 发行固定源")) {
+    // ① 旧「（当前）」标记降级（只保留版本号加粗）
+    rtxt = rtxt.replace(/\*\*(\d+\.\d+\.\d+)（当前）\*\*/g, "**$1**");
+    // ② 清理遗留占位注释（方案 A 起不再产生）
+    rtxt = rtxt.replace(/\n<!-- fixed-source: [^>]*-->\n/g, "\n");
+    // ③ 插入新版本行（幂等：已存在则跳过）
+    if (!rtxt.includes(`- **${nextVer}（当前）**`)) {
+      fixedSourceBumpLine = `- **${nextVer}（当前）** 固定于 main Commit \`${headBeforeShort}\`（\`git checkout ${headBeforeShort}\` + 发布 bump 可复现 npm \`${name}@${nextVer}\` 与 GitHub Release v${nextVer} 同源代码）。**注：release 提交号由发布脚本自动回填。**`;
+      rtxt = rtxt.replace("## 发行固定源\n", `## 发行固定源\n\n${fixedSourceBumpLine}\n`);
+    }
   }
   if (rtxt !== before) writeFileSync(rp, rtxt);
 }
-console.log("版本已 bump（package.json + README 徽章 + 正文当前版本 + 固定源占位）");
+console.log(`版本已 bump（package.json + README 徽章 + 正文当前版本 + 固定源 ${nextVer}（锚点 ${headBeforeShort}））`);
 
 // B1（2026-09-03）：README 版本表行自动插入（阶段 C 人脑核对已失效的自动化；幂等：已存在 nextVer 行则跳过）
 // 位置：版本表（| 版本 | 日期 | 要点 |）表头后第一数据行之前（最新在上）；内容用调用方 notes 参数或 git log 最近提交信息
@@ -344,6 +358,23 @@ run(`cd /d "${repoRoot}" && ${proxyPrefix()}git add -A -- ${stageSpec}`);
 run(`cd /d "${repoRoot}" && git -c core.autocrlf=false commit -m "release: ${name} v${nextVer}" || exit 0`);
 run(`cd /d "${repoRoot}" && ${proxyPrefix()}git push "${pushUrl}" HEAD`);
 
+// ── 5.5 固定源回填（方案 A，2026-09-09）：用 release 提交号替换 bump 时的锚点 ──
+if (fixedSourceBumpLine) {
+  const relShort = quiet(`cd /d "${repoRoot}" && git rev-parse HEAD`).trim().slice(0, 7);
+  const rd = join(dir, "README.md");
+  const rtxt = existsSync(rd) ? readFileSync(rd, "utf8") : "";
+  const finalLine = `- **${nextVer}（当前）** 固定于 main Commit \`${relShort}\`（\`git checkout ${relShort}\` 可复现 npm \`${name}@${nextVer}\` 与 GitHub Release v${nextVer} 同源代码）。`;
+  if (rtxt.includes(fixedSourceBumpLine)) {
+    writeFileSync(rd, rtxt.replace(fixedSourceBumpLine, finalLine), "utf8");
+    console.log(`\n=== 固定源回填 ===\n${nextVer}：锚点 ${headBeforeShort} → release 提交 ${relShort}`);
+    run(`cd /d "${repoRoot}" && ${proxyPrefix()}git add -A -- ${stageSpec}`);
+    run(`cd /d "${repoRoot}" && git -c core.autocrlf=false commit -m "docs(readme): ${nextVer} 固定源回填 ${relShort}（发布后自动同步）" || exit 0`);
+    run(`cd /d "${repoRoot}" && ${proxyPrefix()}git push "${pushUrl}" HEAD`);
+  } else {
+    console.log("（固定源回填跳过：未匹配到 bump 行——可能已手工回填）");
+  }
+}
+
 // ── 6. GitHub Release（带正式 tgz asset，规则 26；清单标记 skipRelease 的包不建）─────
 if (entry?.skipRelease) {
   console.log("（清单标记 skipRelease，跳过 GitHub Release）");