dsh-rule-engine 0.5.13 → 0.5.15

package/README.md

@@ -1,11 +1,11 @@
 # dsh-rule-engine
 
 ![npm](https://img.shields.io/npm/v/dsh-rule-engine)
-![version](https://img.shields.io/badge/version-0.5.13-blue)
+![version](https://img.shields.io/badge/version-0.5.15-blue)
 
 DSH 规则执行引擎 v3 的插件实现。它把 `~/.dsh/AGENTS.md` 当作唯一真相源，自动解析规则四要素与执行等级，再通过「工具守卫 + 文本检测 + 时序检查 + 审计台账」执行用户规则，而不是内置一套与用户无关的安全清单。
 
-> 当前版本 **0.5.12**（2026-08-30 已发布三通道：npm=0.5.12 / git 269ea91 / Release v0.5.12 带 tgz；上一版 0.5.11 = 2026-08-29，git 1de7eaf）。**工作区当前迭代 0.5.13**（2026-08-31：通用化——声明式绑定/禁用语义/会话寻址/验证通道/发布适用性门禁，发布待授权）。本插件面向"规则机器化执行"：规则写在 AGENTS.md 里，引擎负责让它们真的被遵守；所有规则动态解析，规则增删改后无需重写插件。
+> 当前版本 **0.5.14**（2026-09-01 已发布三通道：npm=0.5.14 / git 8105d3e / Release v0.5.14 带 tgz；上一版 0.5.13 = 2026-08-31，git 4c52982）。内容：分点三柱（条件句零授权/显式命名对象锚定/clauseId 隔离）+ skill 词收紧 + 规则 5 引证检测扩展（内部引用无依据提醒）+ 规则 31 查证纪律（B+D）+ README 版本四性对齐。本插件面向"规则机器化执行"：规则写在 AGENTS.md 里，引擎负责让它们真的被遵守；所有规则动态解析，规则增删改后无需重写插件。
 
 ## 项目背景
 
@@ -58,7 +58,7 @@ DSH 规则执行引擎 v3 的插件实现。它把 `~/.dsh/AGENTS.md` 当作唯
 - `node scripts/health-audit.mjs` —— 找茬清单：近 24h 失败/降级类统计（intent-llm 失败、judge-unavailable、verify-gap、inject-skip…）+ 关键导出接线交叉（疑似未接线 = 告警）——"失败可见化"，不再有静默躺 20 小时的降级；
 - 执行协议（本仓库自身交付纪律）：方案冻结单（范围/影响面/测试计划/失败预测）→ todo 化 → 小步闭环（每改动立即 `node --check`）→ 对账交付（计划×实际逐项 ✅/❌/跳过原因）。**验收五查（0.5.11 用户定稿：验收 = 改动关联产物全做一遍，不是只跑测试）**：① 本次改动的**全部**测试/用例在 run-all 或对应门禁中收录；② README/手册/版本记录与引擎语义成对（新增行为必写文档）；③ 调用点 grep：改公共函数签名/导出 → 全部调用点逐一核对；④ 相关测试断言同步（本例：consistency 死映射 17→16）；⑤ 误删/错改产物清理（错误版测试/脚本删除后无残留引用）。**⑥ 实弹验证（0.5.11 用户定稿）**：改动在运行态真实生效 = 重启 DSH 加载（profile 为 link: 时重启即生效）→ 运行态验证（行为/守卫/日志实拍）→ 通过后**才**允许进入发布——**发布必须以"重启生效+验证通过"为前提，未生效验证不得发布**（顺序：改 → 测试 → 重启生效 → 实弹验证 → 发布）。任一未做 = 交付不算完成。**⑦ 发布前置（2026-08-28 用户定稿）**：发布前必须先本地跑测试——本项目测试（test-service/npm test）+ 验证脚本 + 运行态实测（截图/输出证据），未全过不得发布；发布后核对三处成对——README 徽章=package.json 版本（release 脚本自动 bump，需验证）、三通道（npm/git/Release）逐个确认成功（含 Release 带正式 tgz asset）；发布后遗留（徽章/README 成对缺口）必须当场修。**发布流程三阶段（2026-08-29 用户定稿）**：阶段 A **内容验证（发布前，只读/本地）**——A1 测试全过（run-all+verify-all+loader+运行态实测）、A2 dry-run 推导正确（`release-plugin.mjs <pkg> --dry-run`：oldVer→nextVer+徽章变化）、A3 版本三处一致（徽章=package.json=发布目标号）、A4 Asset/tag 预检（tgz 已 pack；目标 tag 预检不存在——防 ㉙ 同 tag 占位）；阶段 A0 **授权**——展示改动清单+版本号 → ask_user_question 明确授权（规则 26⑤：先授权→运行脚本）；阶段 B **一键三通道**——`release-plugin.mjs`（publish→push→Release 带 tgz）；阶段 C **事后核对**——三通道确认（npm view/git tag/gh api asset）+ 徽章/README 成对复核 + 本机 link 不重装 + 沉淀（版本记录/engram）。**顺序铁律：A→A0→B→C，验证在发布前（A），不是发布后补（C）——发布内容经确认无误才允许三通道。**
 
-> **版本状态说明（2026-08-31 更新）**：0.5.11 与 0.5.12 均已独立发布（见上）。0.5.13 = 当前工作区迭代（发布前统一以对外号为准）。历史说明：0.5.11 发布时含 0.5.10 git 提交欠账 7 文件补齐（baseline/intent/judge/llm-intent/semantic/tool-catalog/whitelist.js——npm 包本已包含，git 通道缺失）。
+> **版本状态说明（2026-09-01 更新）**：0.5.11-0.5.14 均已独立发布（见上；0.5.14 = 2026-09-01 三通道，git 8105d3e）。历史说明：0.5.11 发布时含 0.5.10 git 提交欠账 7 文件补齐（baseline/intent/judge/llm-intent/semantic/tool-catalog/whitelist.js——npm 包本已包含，git 通道缺失）。
 
 ## 版本历史（摘要）
 
@@ -66,10 +66,11 @@ DSH 规则执行引擎 v3 的插件实现。它把 `~/.dsh/AGENTS.md` 当作唯
 
 | 版本 | 日期 | 要点 |
 |---|---|---|
-| **0.5.14** | 2026-08-28 | 注入文案去命令化（命令词守卫 + 历史文案改写）、注入投递降噪、注入授权断言真值驱动、规则 2 时序竞态（turn/end 复核）、verify-gap 词面收紧、回归集第 8 层 |
-| **0.5.13** | 2026-08-28 | 委派/子代理回合豁免（delegated-skip）、中文顿号路径提取（PATH_TOKEN_RE）、ask 节流区分"明确拒绝"与"未响应" |
-| **0.5.12** | 2026-08-28 | 意图优先级修正（动作词先于方案词）、LLM 意图兜底同步等待、@文件引用信号、只读判定三档（写特征/白名单/保守拒）、规则 22 粒度并入会话授权、ERR 码打标链路 |
-| **0.5.11** | 2026-08-28 | 判定内核第一轮：新建豁免补"新建"语义、分析通道移除脚本区语义豁免、12A 与 22-7 判据同源、后台判定模型 = 当前会话模型；词表唯一源（lexicon.js）、rule14 空转映射清理、规则 24 机器执行修正（守卫链覆盖测试） |
+| **0.5.14** | 2026-09-01 | 分点三柱（条件句零授权/显式命名对象锚定/clauseId 隔离）+ skill 词收紧 + 规则 5 引证检测扩展（内部引用无依据→审计注入）+ 规则 31 查证纪律（B+D）+ README 版本四性对齐 |
+| **0.5.15** | 2026-09-02 | 回合末裁决卡片（host 侧 turn/end 裁决摘要 + client 包 dsh-rule-engine-client：可交互 ✅/❌ 卡片；判例登记一次性（per-block）；多次裁决一卡逐条分组；卡片/判例落盘 rule-engine-turn-cards.json 重启不丢） |
+| **0.5.13** | 2026-08-31 | 通用化（声明式绑定/禁用语义/会话寻址/验证通道/发布适用性门禁）+ 阶段二·三（委派豁免/中文顿号路径/ask 节流区分/D1-D3 注入/F1 规则 2/F2 verify-gap） |
+| **0.5.12** | 2026-08-30 | 意图优先级修正（动作词先于方案词）、LLM 意图兜底同步等待、@文件引用信号、只读判定三档（写特征/白名单/保守拒）、规则 22 粒度并入会话授权、ERR 码打标链路、F2 打标指纹、F5 契约类别白名单 |
+| **0.5.11** | 2026-08-29 | 判定内核第一轮：新建豁免补"新建"语义、分析通道移除脚本区语义豁免、12A 与 22-7 判据同源、后台判定模型 = 当前会话模型；词表唯一源（lexicon.js）、rule14 空转映射清理、规则 24 机器执行修正（守卫链覆盖测试） |
 | **0.5.10** | 2026-08-27 | 分析通道（单真源 isAnalysisOp：严格只读 ∪ 分析临时区写）、写类判定单真源（isMutationCommand）、只读词表补全、统一入口加固（转义检测 + 写后校验）、误判打标闭环、已知坑错误码召回 |
 | **0.5.9** | 2026-08-27 | 工具分类单真源（tool-catalog.js）、官方 59 工具全集覆盖、前缀规则（mcp__/esr_/dev_ 等命名空间自动归类）、unknownPolicy（默认 deny）、白名单 v2 带元数据、/guard tools、工具箱覆盖门禁 |
 | **0.5.8** | 2026-08-26 | 白名单持久化（rule-engine-tools.json）、只读命令词表补全（Select-Object 等）、`npm run verify` 注册 |
@@ -208,7 +209,7 @@ bash scripts/build.sh
 
 交付前体检（0.5.7 起）：`node scripts/verify-all.mjs`（七层：语法/单元/组合冒烟/工具箱覆盖/守卫链覆盖/关联一致性/真实判例）与 `node scripts/health-audit.mjs`（找茬）——详见「质量与验证」。
 
-发布：`node ../../scripts/release-plugin.mjs <插件目录> <版本号>`（一键 npm + git + GitHub Release，见 `scripts/release-plugin.mjs` 注释）。
+发布：`node scripts/release-plugin.mjs <插件名> <版本号>`（一键 npm + git + GitHub Release；发布脚本随插件仓库管理——`scripts/release-plugin.mjs`；改发布脚本后须 `--dry-run` + 代码审查，注意 dry-run 不覆盖 git 段）。
 
 ## License
 

package/cordis.patch.yml

@@ -5,3 +5,5 @@
       name: 'dsh-rule-engine'
     - id: dsh-rule-engine-service
       name: 'dsh-rule-engine/lib/service.js'
+    - id: dsh-rule-engine-client
+      name: 'dsh-rule-engine-client'

package/lib/core/authorization.js

@@ -41,7 +41,10 @@ const TYPE_HINTS = [
   // 0.5.12（F1 重证）：command 规则补 ①引号包裹路径 ②无扩展名可执行文件（tsc/tsdown 等）
   // ③pnpm/yarn/bun 显式收录（此前靠 npm\s+ 子串巧合命中 pnpm，非设计保证）
   { re: /命令|运行|执行\s*(?:命令|脚本|以下|程序)|run|execute|pwsh|bash|node\s+(?!-e\b|-p\b|--eval\b|--print\b)(?:['"])?[\w./\\-]+(?:['"])?(?:\s|$)|(?:npm|pnpm|yarn|bun)\s+(?:run|exec|install|add)|(?:^|[^a-z])(?:tsc|tsdown|vite|webpack|rollup)\b/i, type: "command" },
-  { re: /技能|skill/i, type: "skill" },
+  // 2026-08-31（skill 词残留收紧）：12B 已禁用（技能调用流程），原 /技能|skill/i 把任意文本中的
+  // "Skill"名词（如 repo 描述）判成技能类→授权范围不匹配误拦（VCI2RX 实证）。
+  // 收紧为**真实技能操作**（skill 工具/技能目录管理上下文），名词性"Skill"不再命中。
+  { re: /(?:技能|skill)\s*(?:调用|目录|管理|列表|启用|禁用|安装|删除|加载|查询)|(?:启用|禁用|调用|安装|删除|加载|查询|打开|查看|管理)\s*技能|(?:启用|禁用|调用|安装|删除|加载|查询|打开|查看|管理)\s*skill\b|skill\s+(?:tools?|dir|enable|disable|list|install)\b|\/guard\s+skills?\b/i, type: "skill" },
   // 0.5.12（F1 重证）：network 词表由裸子串改词边界+上下文——`fetch` 出现在目录名/标识符中
   //（dsh-web-fetch-playwright）不再误判；真网络形态（URL/调用/下载动词）仍命中
   { re: /下载|网络|https?:\/\/\S*|(?:^|[^a-z])(?:curl|fetch|wget|iwr|Invoke-WebRequest|Invoke-RestMethod)\s*(?:\(|\.|[^\w]|$)/i, type: "network" },
@@ -231,7 +234,7 @@ export function pairActionScopes(raw, clauseId, strict = false) {
     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 });
+        scopes.push({ type, pathPrefix, source: "clause", clauseId, object: extractActionObjects(text) });
       }
     }
   }
@@ -242,7 +245,7 @@ export function pairActionScopes(raw, clauseId, strict = false) {
 export function describeScopes(scopes) {
   if (!Array.isArray(scopes) || scopes.length === 0) return "无";
   return scopes
-    .map((s) => `${s.type || "any"}｜路径 ${s.pathPrefix || "全局"}`)
+    .map((s) => `${s.type || "any"}｜路径 ${s.pathPrefix || "全局"}${Array.isArray(s.object) && s.object.length ? `｜对象 ${s.object.join(",")}` : ""}`)
     .join("；");
 }
 
@@ -297,7 +300,22 @@ export function operationOf(toolName, args) {
     pathPrefix = "";
   }
 
-  return { type, pathPrefix, pathPrefixes };
+  return { type, pathPrefix, pathPrefixes, commandText: cmd || "" };
+}
+
+/**
+ * 柱子 B（2026-08-31）：显式命名对象锚定——分点文本中"X 仓库/repo/目录/项目/包/文件"的
+ * **实体名 token**（含连字符/点/下划线/数字的命名形态；"skill 仓库"这类类别概念词不锚定——
+ * 防过度误拦）。锚定后授权仅覆盖该对象；未锚定（空）→ 不收紧（维持既有语义）。
+ */
+const NAMED_OBJECT_RE = /([A-Za-z0-9]+(?:[-_.][A-Za-z0-9]+)+|[\u4e00-\u9fff]{2,12}[A-Za-z0-9]*)(?:\s*)(?:远程|远端)?(?:仓库|repo(?:sitory)?|目录|项目|包|package|文件)/gi;
+export function extractActionObjects(text) {
+  const out = new Set();
+  for (const m of String(text || "").matchAll(NAMED_OBJECT_RE)) {
+    const token = m[1].trim();
+    if (token.length >= 3) out.add(token.toLowerCase());
+  }
+  return [...out];
 }
 
 /** 路径是否在授权边界内：相等，或为授权路径的子路径（子路径以 / 为边界，防止文件前缀误伤） */
@@ -320,6 +338,12 @@ export function authMatches(auth, op) {
     const authPath = normalizePath(auth.pathPrefix);
     if (!candidates.some((p) => pathUnderAuth(normalizePath(p), authPath))) return false;
   }
+  // 柱子 B（2026-08-31）：对象锚定——授权声明了显式命名对象 → 操作命令文本必须命中该对象
+  //（"推送 X 仓库"不覆盖"推送 Y 仓库"；未锚定对象=不收紧）
+  if (Array.isArray(auth.object) && auth.object.length > 0) {
+    const opText = String(op.commandText || "").toLowerCase();
+    if (!opText || !auth.object.some((o) => opText.includes(String(o).toLowerCase()))) return false;
+  }
   return true;
 }
 

package/lib/core/config.js

@@ -11,6 +11,8 @@ export const DEFAULT_CONFIG = {
   taskContractEnabled: false,
   askEnabled: false,
   taskContractMode: "observe",
+  // 0.5.15：回合末裁决卡片开关（默认关——面向大众；设置页开关与任务契约同组）
+  turnCard: { enabled: false },
   taskContractDefaults: {
     agentBudget: 0,
     hashPolicy: "deny",

package/lib/core/intent.js

@@ -37,6 +37,11 @@ export const TAG_RE = /【(执行|方案|问询|信息)】/;
 export const QUESTION_RE = QUESTION_WORDS_RE;
 
 const DEFER_RE = /待确认|确认后再|等我确认|先方案|先别|不要执行|之后再说|确认后|再确认|先确认|不要直接/;
+// 2026-08-31（柱子 C：条件句识别——"推送完成后…/等 X 了…/待…后…"型分点）：
+// 条件句分点 = 依赖前序分点完成后的后续动作，**本条不产生任何授权/scope**（安全方向：宁拦不放）。
+// 词面拒绝"推送/上传"等动作词被当作本条独立动作（3 号分点"推送完成后发地址"实证：引擎曾把
+// "推送"当本条动作致 git 全局授权弥漫——分点失效根因之一）。
+const CONDITIONAL_RE = /(?:完成|结束|做完|弄完|搞定|好了|恢复|重启?)\s*(?:了|之后|后|以后|再)|(?:等|待|等\s*[\u4e00-\u9fff]{0,6}?)\s*[\u4e00-\u9fff]{0,8}?(?:后|之后|了)\s*|(?:推送|上传|提交|发布|执行)\s*(?:完成|结束|完|好)\s*(?:了|之?后)?/;
 const ACTION_RE = ACTION_WORDS_RE;
 const PLAN_RE = /方案|建议|评估|分析|设计|规划|计划|给出|提供/;
 const STRONG_EXEC_RE = STRONG_EXEC_LEX;
@@ -221,6 +226,8 @@ function classifyClause(clause) {
   let type = "info";
   let ambiguous = false;
 
+  // 2026-08-31（柱子 C）：条件句优先判定——"推送完成后/等 X 后"=依赖型分点，不产生独立授权
+  //（必须在动作词判定之前：否则"完成后"被当执行分点，其 scope 污染授权池——分点失效根因）
   if (tagType) {
     if (tagType === "execute" && hasQuestion) {
       type = "ambiguous";
@@ -232,6 +239,10 @@ function classifyClause(clause) {
     type = "question";
   } else if (isStatusSignal(text)) {
     type = "status";
+  } else if (CONDITIONAL_RE.test(text)) {
+    // 2026-08-31（柱子 C）：条件句——"推送完成后/等 X 后"=依赖型分点，不产生独立授权/scope
+    //（若按动作词判 execute，其"推送"字眼将污染 git 授权池——分点失效根因；宁拦不放）
+    type = "conditional";
   } else if (hasDefer && hasAction) {
     type = "plan";
   } else if (hasAction && hasPlan && !SPECIFIC_ACTION_RE.test(text) && !(PLAN_EXECUTING_RE.test(text) && !PLAN_REQUEST_RE.test(text))) {

package/lib/core/lexicon.js

@@ -28,7 +28,7 @@ export const PLAN_ONLY_RE = /确认方案|确认理解|确认方向|确认无误
 // 注意：单一表同时服务"意图判定"（这句话是不是执行分点）与"ask 结果批准判定"（选择=批准），
 // 语义一致，不另分裂；新增动作词只改这里。
 export const ACTION_WORDS_RE =
-  /执行|跑|落|落盘|认可|开始|写入|写(?:下|好|完|成|作|文件)?|保存|另存为|删除|修改|改(?:为|成|动|一下|进|善)?|补(?:上|齐|全|充|写)?|修(?:改|复|一下)?|做(?:好|完|一下)?|创建|安装|发布|下载|提交|运行|修复|替换|重建|启动|重启|停止|卸载|开始改|开始写|改进|优化|增强|完善|升级|迁移|整理|调整|实现|实施|添加|增加|补充|重写|改造|调试|排查|处理|解决|继续|推进|更新|部署|核实|梳理|诊断|对齐|跟进|落实|设计并实现|调查|开工|动手|进行|完成|选择|采纳|选定|产出|编写|撰写|生成|审查|阅读|查看|核对|检查|审阅|复核|查阅|验证|对照|调研|研究|转化|转换|读取|读(?:出|一下|一遍|完|出来)?|展示|打开|提取|还原|导入|导出|清理|移除|清空|残留|合入|合并|并入|融合|整合|起草|开展|搭建|重构|兼容|投产|校验|核验|过一遍|跑一遍|复验/i;
+  /执行|跑|落|落盘|认可|开始|写入|写(?:下|好|完|成|作|文件)?|保存|另存为|删除|修改|改(?:为|成|动|一下|进|善)?|补(?:上|齐|全|充|写)?|修(?:改|复|一下)?|做(?:好|完|一下)?|创建|建(?:设|立|好|一下|个|一个)?|安装|发布|下载|提交|推送|push|运行|修复|替换|重建|启动|重启|停止|卸载|开始改|开始写|改进|优化|增强|完善|升级|迁移|整理|调整|实现|实施|添加|增加|补充|重写|改造|调试|排查|处理|解决|继续|推进|更新|部署|核实|梳理|诊断|对齐|跟进|落实|设计并实现|调查|开工|动手|进行|完成|选择|采纳|选定|产出|编写|撰写|生成|审查|阅读|查看|核对|检查|审阅|复核|查阅|验证|对照|调研|研究|转化|转换|读取|读(?:出|一下|一遍|完|出来)?|展示|打开|提取|还原|导入|导出|清理|移除|清空|残留|合入|合并|并入|融合|整合|起草|开展|搭建|重构|兼容|投产|校验|核验|过一遍|跑一遍|复验/i;
 
 // 强执行语（直接执行指令，不等授权确认——用于意图置信提升）
 export const STRONG_EXEC_RE =

package/lib/core/paths.js

@@ -43,3 +43,8 @@ export function verifyFilePath() {
 export function toolsWhitelistFilePath() {
   return join(dshHome(), "rule-engine-tools.json");
 }
+
+/** 0.5.15：回合末裁决卡片持久化文件（卡片 + 判例登记 → 重启不丢，历史按钮/判例恢复） */
+export function turnCardsFilePath() {
+  return join(dshHome(), "rule-engine-turn-cards.json");
+}

package/lib/core/state.js

@@ -1,8 +1,8 @@
 // state.js - 插件运行时状态（内存态）。
 // 所有会话级状态以 sessionId 为 key；turn 级状态在 turn/start 重置。
-import { readFileSync, statSync } from "node:fs";
+import { readFileSync, writeFileSync, statSync } from "node:fs";
 import { loadRules } from "./parser.js";
-import { agentsFilePath, disabledRulesFilePath } from "./paths.js";
+import { agentsFilePath, disabledRulesFilePath, turnCardsFilePath } from "./paths.js";
 import { understandAll } from "./understander.js";
 import { writeUnderstanding } from "./understanding-store.js";
 import { AUTH_TTL_MS } from "./authorization.js";
@@ -52,6 +52,10 @@ export function createState() {
     labels: new Map(),
     // 0.5.12（F2）：打标指纹台账持久化行（磁盘 ~/.dsh/rule-engine-labels.json；内存态副本）
     labelRows: loadLabelsFromDisk(join(dshHome(), "rule-engine-labels.json")),
+    // 0.5.15：回合末裁决卡片索引——closing assistant messageId → card 摘要
+    // （index.js 在 turn/end 时登记；service.getTurnCard 倒查供 client assistant-actions 拉取）
+    // 2026-09-02：持久化（从磁盘加载）——判例是教学数据，重启不丢（历史按钮/判例恢复）
+    cardByMessage: loadTurnCardsFromDisk(),
     askRejections: [], // { sessionId, at }（ask 被拒记录，弹窗消减/节流）
     llmIntentCache: new Map(), // sha256(text) → verdict（LRU 上限 cfg.cacheSize）
     llmIntentBudget: new Map(), // sessionId → 当日调用数（上限 cfg.dailyLimitPerSession）
@@ -147,6 +151,7 @@ export function getSessionState(state, sessionId) {
       id: key,
       ruleStats: {}, // C2：每规则 detected/suppressed/injected 统计（会话级，跨回合累计）
       manualReadSeen: false,
+      lastQueryTurn: -1, // 规则 5/31（2026-09-01）：最近一次查询类工具调用所在回合号（判定"近 3 回合有据"）
       lastUserText: "",
       selfCertCount: new Map(),
       authorizations: [],
@@ -254,6 +259,8 @@ export function freshTurn() {
     firstToolName: "",
     skillNames: [],
     toolNames: [],
+    cardHits: [], // 0.5.15：本回合 guard 命中缓冲（回合末裁决卡片数据源）
+    lastAssistantMessageId: "", // 0.5.15：本回合最后 assistant 消息 id（卡片索引锚点）
     commands: [],
     reasoningText: "",
     // 规则 22 粒度升级（2026-08-24）：本回合已获授权范围（execute 子句 + ask 授权）
@@ -322,3 +329,34 @@ export function reloadRules(state) {
 export function findConfig(state, ruleId) {
   return state.configs.find((c) => String(c.ruleId) === String(ruleId));
 }
+
+// ── 0.5.15：回合末裁决卡片持久化（判例=教学数据，重启不丢）─────────────
+/** 卡片索引磁盘上限（防膨胀：只保留最近 N 条） */
+export const TURN_CARDS_MAX = 200;
+
+/** 从磁盘加载卡片索引（损坏/缺文件 → 空 Map，容错不崩） */
+export function loadTurnCardsFromDisk() {
+  try {
+    const raw = readFileSync(turnCardsFilePath(), "utf8");
+    const arr = JSON.parse(raw);
+    if (!Array.isArray(arr)) return new Map();
+    const m = new Map();
+    for (const it of arr) {
+      if (it && typeof it.messageId === "string" && it.card) m.set(it.messageId, it.card);
+    }
+    return m;
+  } catch {
+    return new Map();
+  }
+}
+
+/** 保存卡片索引到磁盘（数组化 + 上限裁剪；失败静默——卡片是增强层） */
+export function saveTurnCardsToDisk(state, max = TURN_CARDS_MAX) {
+  try {
+    let entries = [...(state.cardByMessage || new Map()).entries()];
+    if (entries.length > max) entries = entries.slice(entries.length - max);
+    writeFileSync(turnCardsFilePath(), JSON.stringify(entries.map(([messageId, card]) => ({ messageId, card })), null, 2) + "\n", "utf8");
+  } catch {
+    // 持久化失败不阻断主流程（卡片是展示层增强）
+  }
+}

package/lib/core/text-detect.js

@@ -11,7 +11,8 @@ import {
   TERM_EXPLANATION_RE,
   SUGGEST_RE,
   isNegatingSuggestion,
-  isQuoteOrParaphraseContext
+  isQuoteOrParaphraseContext,
+  isReadOnlyTool
 } from "./patterns.js";
 import { detectOverengineeringText } from "./overengineering.js";
 
@@ -50,9 +51,16 @@ const SELF_CERT_HINTS = {
   "19": { re: /学到新.*DSH|踩到新坑|踩坑.*沉淀|手册有误|知识必沉淀/, reason: "请按规则 19 自证：按①-⑧沉淀并当次汇报正文同步位置" },
   "28": { re: /新建.*文件|放入.*目录|工作区.*归类/, reason: "请按规则 28 自证：新文件按工作区目录索引归类，不确定则查 README 或放 _inbox" },
   "29": { re: /依赖闭包|node_modules.*验证|动过.*node_modules/, reason: "请按规则 29 自证：重启前验证依赖闭包（关键包非空/顶层 junction 完整/无 dangling）" },
-  "30": { re: /变更验证|验证证据|不破坏.*依赖/, reason: "请按规则 30 自证：执行前证明不破坏依赖+已授权，完成后附验证证据" }
+  "30": { re: /变更验证|验证证据|不破坏.*依赖/, reason: "请按规则 30 自证：执行前证明不破坏依赖+已授权，完成后附验证证据" },
+  // 规则 31（2026-09-01 用户拍板）：提到"撞墙/盲试"类表述 → D 级自证：写明验证目标→撞了什么/为什么撞→结论来源
+  "31": { re: /撞(?:了)?南墙|撞墙|盲试|乱撞|连续盲试/, reason: "规则 31 自证：请写明「验证目标→撞了什么/为什么撞→结论来源（手册位置/源码行号）」；不连续盲试" }
 };
 
+// 规则 31（2026-09-01 用户拍板）：内部文档引用锚点词（"文档"仅在后随"写了/记载…"语境命中，防泛化误报）
+const INTERNAL_REF_RE = /(?:手册|踩坑\s*\d+|条款\s*\d+|第\s*\d+\s*章|SKILL\.md|AGENTS\.md|源码|README|文档[^\n]{0,12}(?:写了|记载|记录|写明|说明))/i;
+// 验证目标启发式：思维链含这些词 → 大概率是有序查证（防规则 31③误报）
+const VERIFY_INTENT_RE = /(?:验证|查证|核对|目标|交叉|对照|确认)/;
+
 /** 简单判断一段文本是否以英文为主 */
 function isMostlyEnglish(text) {
   if (!text) return false;
@@ -157,19 +165,56 @@ export function detectViolations({ configs, session, text, reasoningText = "", m
   }
 
   const sourceCfg = byId.get("5");
-  if (sourceCfg && URL_RE.test(text) && !SOURCE_MARK.test(text)) {
-    hits.push({
-      ruleId: "5",
-      title: sourceCfg.title,
-      kind: "correct",
-      reason: "回答包含 URL 但未标注出处/来源"
-    });
+  if (sourceCfg && !SOURCE_MARK.test(text)) {
+    if (URL_RE.test(text)) {
+      hits.push({
+        ruleId: "5",
+        title: sourceCfg.title,
+        kind: "correct",
+        reason: "回答包含 URL 但未标注出处/来源"
+      });
+    } else if (INTERNAL_REF_RE.test(text) && !isQuoteOrParaphraseContext(text, INTERNAL_REF_RE)) {
+      // 规则 5 扩展（2026-09-01 用户拍板）：内部文档引用（手册/踩坑/条款/源码…）须有依据——
+      // 近 3 回合无对应 read/grep 时提示（B 级：留痕+注入，不拦截）。
+      const curTurn = session.turn.number || 0;
+      const lastQuery = session.lastQueryTurn ?? -1;
+      if (lastQuery < 0 || curTurn - lastQuery > 3) {
+        hits.push({
+          ruleId: "5",
+          title: sourceCfg.title,
+          kind: "correct",
+          reason: "回答引用内部文档（手册/踩坑/条款/源码等）但近 3 回合无对应 read/grep——请标注手册位置或删去断言"
+        });
+      }
+    }
+  }
+
+  // 规则 31（2026-09-01 用户拍板）：同回合同一只读工具 ≥3 次且思维链无验证目标语 → 提示（B 级：留痕+注入）
+  const rule31Cfg = byId.get("31");
+  if (rule31Cfg) {
+    const counts = new Map();
+    const pending = session.turn?.pendingToolCalls;
+    if (pending && typeof pending.values === "function") {
+      for (const pc of pending.values()) {
+        if (pc && pc.name && isReadOnlyTool(pc.name, pc.args)) {
+          counts.set(pc.name, (counts.get(pc.name) || 0) + 1);
+        }
+      }
+    }
+    const repeated = [...counts.entries()].find(([, c]) => c >= 3);
+    if (repeated && !VERIFY_INTENT_RE.test(reasoningText)) {
+      hits.push({
+        ruleId: "31",
+        title: rule31Cfg.title,
+        kind: "correct",
+        reason: `规则 31：回合同一只读工具（${repeated[0]}）调用 ${repeated[1]} 次且思维链无验证目标语——有序交叉验证请忽略，连续盲试请先写明「要验证什么」`
+      });
+    }
   }
 
   const langCfg = byId.get("11");
   const visibleEnglish = isMostlyEnglish(text);
-  const reasoningEnglish = isMostlyEnglish(reasoningText);
-  if (langCfg && session.lastUserText && CJK_RE.test(session.lastUserText) && (visibleEnglish || reasoningEnglish)) {
+  const reasoningEnglish = isMostlyEnglish(reasoningText);  if (langCfg && session.lastUserText && CJK_RE.test(session.lastUserText) && (visibleEnglish || reasoningEnglish)) {
     hits.push({
       ruleId: "11",
       title: langCfg.title,

package/lib/core/turn-card.js

@@ -0,0 +1,49 @@
+// turn-card.js - 回合末裁决摘要（0.5.15 回合末裁决卡片的 host 半）。
+// 输入回合状态（turn），输出给 client 卡片的摘要 JSON。
+// 纯函数可独立测试；不 import 官方包。
+// 数据源：turn.cardHits（index.js 在 guardDecision 命中时缓冲）——本文件只做聚合与格式化。
+// 字段约定：
+//   card.verdict = "denied" | "clear"（引擎裁决语义，只读）
+//   card.label   = "correct" | "incorrect" | null（用户判例，rateTurnCardHost 写入；展示层据此显示 ✅/❌）
+
+/** 摘要一个工具调用（命令/路径截断，替白空格） */
+function summarizeArg(s) {
+  return String(s || "").replace(/\s+/g, " ").slice(0, 80);
+}
+
+/** 卡片稳定键（client 判例登记定位用：回合号×块数×用户文本片段） */
+export function cardKey(card) {
+  if (!card) return "";
+  return `t${card.turn}@${(card.blocks || []).length}@${String(card.userText || "").slice(0, 16)}`;
+}
+
+/**
+ * 构建回合裁决摘要。
+ * @param {object} turn 回合状态（freshTurn 产物；cardHits 由 index.js 写入）
+ * @returns {{turn:number, userText:string, verdict:string, blocks:Array, after:string, key:string, label:null}}
+ */
+export function buildTurnCard(turn) {
+  const hits = Array.isArray(turn?.cardHits) ? turn.cardHits : [];
+  const blocks = hits.map((h, i) => ({
+    i,
+    tool: String(h?.tool || ""),
+    args: summarizeArg(h?.args),
+    ruleId: String(h?.ruleId || ""),
+    title: String(h?.title || ""),
+    reason: String(h?.reason || "").slice(0, 160),
+    errId: String(h?.errId || "")
+  }));
+  const rules = [...new Set(blocks.map((b) => b.ruleId).filter(Boolean))];
+  const card = {
+    turn: Number(turn?.number || 0),
+    userText: String(turn?.userText || "").slice(0, 200),
+    verdict: blocks.length > 0 ? "denied" : "clear",
+    blocks,
+    after: blocks.length > 0
+      ? `本回合 ${blocks.length} 次调用被拦（规则 ${rules.join("、")}）——已改为请示/修正而非继续执行`
+      : "本回合无裁决事件",
+    label: null
+  };
+  card.key = cardKey(card);
+  return card;
+}

package/lib/index.js

@@ -55,12 +55,14 @@ import {
   recordAuthorization,
   recordBackup,
   reloadRules,
-  resetTurn
+  resetTurn,
+  saveTurnCardsToDisk
 } from "./core/state.js";
 import { toolClass } from "./core/tool-catalog.js";
 import { parseWhitelist, mergeWhitelist, serializeWhitelist } from "./core/whitelist.js";
 import { state } from "./core/runtime.js";
 import { DELIVERY_RE, detectViolations, extractAssistantText } from "./core/text-detect.js";
+import { buildTurnCard } from "./core/turn-card.js";
 import { shouldDetectTurn, shouldDeliver } from "./core/semantic.js";
 import { judgeViolation, judgeViolationsBatch } from "./core/judge.js";
 import {
@@ -473,6 +475,24 @@ export function handleSessionEvent(ctx, session, event) {
       }
       s.turn.pendingRule2 = null;
     }
+    // 0.5.15：回合末裁决摘要（卡片后端；生成失败不影响主流程——卡片非硬依赖）
+    try {
+      s.lastCard = buildTurnCard(s.turn);
+      // 0.5.15：登记 closing assistant messageId → 卡片（client assistant-actions 按消息倒查）
+      // 2026-09-02：登记即落盘（判例是教学数据，重启不丢）
+      const mid = s.turn.lastAssistantMessageId;
+      if (mid && s.lastCard) {
+        state.cardByMessage.set(mid, { ...s.lastCard, messageId: mid, sessionId: sid });
+        if (state.cardByMessage.size > 500) {
+          // 防泄漏：仅保留最近 500 条索引（历史太久远的卡片回放无意义）
+          const oldest = state.cardByMessage.keys().next().value;
+          if (oldest !== undefined) state.cardByMessage.delete(oldest);
+        }
+        saveTurnCardsToDisk(state);
+      }
+    } catch {
+      // 摘要失败静默（卡片是展示层增强，不阻断回合主流程）
+    }
     return;
   }
   if (event.type === "user/message") {
@@ -639,6 +659,8 @@ export function handleSessionEvent(ctx, session, event) {
       }
     }
     if (isManualReadTool(toolName, args)) s.manualReadSeen = true;
+    // 规则 5/31 扩展（2026-09-01）：查询类工具调用记下回合号（"近 3 回合有据"判定）
+    if (isReadOnlyTool(toolName, args)) s.lastQueryTurn = s.turn.number;
     if (toolName === "skill" && args?.name) s.turn.skillNames.push(args.name);
     s.turn.toolNames.push(toolName);
     if (state.taskContract?.taskContractEnabled) {
@@ -993,6 +1015,11 @@ export function handleSessionEvent(ctx, session, event) {
   }
   if (event.type === "assistant/message") {
     const text = extractAssistantText(d.message);
+    // 0.5.15：记录本回合最后一条 assistant 消息 id（回合末卡片索引锚点；
+    // 对 turn/end 来说"最后一条"即 closing——无注入轮干扰，注入轮无卡片需求）
+    if (typeof d.message?.id === "string" && d.message.id) {
+      s.turn.lastAssistantMessageId = d.message.id;
+    }
     // v0.5.7 第 0 站：注入轮（无真实用户消息）不检测不投递——这是乒乓循环的根治：
     // 引擎自己的注入 → 我的回复 → 再检测 的燃料被掐断（实测 2026-08-26 12:37 六圈即此循环）。
     if (!shouldDetectTurn({ realUserSeen: s.turn.realUserSeen })) return;
@@ -1570,6 +1597,18 @@ export function apply(ctx) {
             errId: hit.errId,
             session: sessionIdOfExec(exec) // P0-4：deny 审计补 session（2026-08-24 事故复盘：归属会话靠猜）
           });
+          // 0.5.15：本回合 guard 命中缓冲（回合末裁决卡片数据源——全量记，含 __ 内部拦截）
+          (() => {
+            const sCard = getSessionState(state, sessionIdOfExec(exec));
+            (sCard.turn.cardHits ||= []).push({
+              tool: exec?.name || "",
+              args: summarizeArgs(exec?.arguments || {}),
+              ruleId: hit.ruleId,
+              title: hit.title,
+              reason: hit.reason,
+              errId: hit.errId || ""
+            });
+          })();
           state.lastActive = [{ ruleId: hit.ruleId, title: hit.title, reason: hit.reason }];
           // 规则 1 计数解耦（2026-08-24，P1-7）：引擎 deny 不计入“同工具连续失败”
           const dkey = `${exec?.name}:${JSON.stringify(exec?.arguments || {})}`;

package/lib/service.js

@@ -4,10 +4,11 @@
 import { readFileSync } from "node:fs";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { state } from "./core/runtime.js";
-import { readAuditLog } from "./core/audit.js";
+import { readAuditLog, audit } from "./core/audit.js";
 import { loadPluginConfig, savePluginConfig } from "./core/config.js";
-import { applyTaskContractConfig } from "./core/state.js";
-import { agentsFilePath, auditFilePath } from "./core/paths.js";
+import { applyTaskContractConfig, saveTurnCardsToDisk } from "./core/state.js";
+import { agentsFilePath, auditFilePath, dshHome } from "./core/paths.js";
+import { labelFingerprint, labelEntry, labelsFilePath, saveLabelsToDisk, upsertLabel } from "./core/label-fingerprint.js";
 
 const REMOTE_METHODS = [
   "getStatus",
@@ -17,7 +18,9 @@ const REMOTE_METHODS = [
   "getUnderstanding",
   "getTaskContractConfig",
   "setTaskContractConfig",
-  "getRuleStats"
+  "getRuleStats",
+  "getTurnCard",
+  "rateTurnCard"
 ];
 
 function currentVersion() {
@@ -200,7 +203,8 @@ class RuleEngineService extends TypertRemoteService {
           taskContractEnabled: conf.taskContractEnabled === true,
           askEnabled: conf.askEnabled === true,
           taskContractMode: conf.taskContractMode === "armed" ? "armed" : "observe",
-          taskContractDefaults: conf.taskContractDefaults || {}
+          taskContractDefaults: conf.taskContractDefaults || {},
+          turnCard: { enabled: conf.turnCard?.enabled === true }
         }
       };
     } catch (error) {
@@ -219,7 +223,8 @@ class RuleEngineService extends TypertRemoteService {
           taskContractEnabled: conf.taskContractEnabled === true,
           askEnabled: conf.askEnabled === true,
           taskContractMode: conf.taskContractMode === "armed" ? "armed" : "observe",
-          taskContractDefaults: conf.taskContractDefaults || {}
+          taskContractDefaults: conf.taskContractDefaults || {},
+          turnCard: { enabled: conf.turnCard?.enabled === true }
         }
       };
     } catch (error) {
@@ -245,6 +250,38 @@ class RuleEngineService extends TypertRemoteService {
       return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
   }
+
+  /**
+   * 0.5.15：按 assistant messageId 取回合末裁决卡片。
+   * client 端 assistant-actions 挂载时传当前消息 id；host 用
+   * state.cardByMessage 倒查（index.js 在 turn/end 时登记 closing 消息 → 卡片）。
+   * 开关 turnCard.enabled=false 时恒返回 null（默认关——面向大众）。
+   */
+  async getTurnCard(messageId) {
+    try {
+      const conf = loadPluginConfig();
+      if (conf.turnCard?.enabled !== true) return { ok: true, card: null };
+      const card = state.cardByMessage?.get?.(String(messageId || ""));
+      if (!card) return { ok: true, card: null };
+      return { ok: true, card };
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+
+  /**
+   * 0.5.15：判例登记（✅=correct 留档 / ❌=incorrect 学习+指纹放行）。
+   * 与 /guard label incorrect 同链路：写 state.labels + 命令指纹台账（持久化）。
+   * expectedVerdict：卡片上已显示的打标状态（防重复点击/防旧卡回放误登记）。
+   * blockIndex：要登记的是卡片中第几条裁决（一回合多次裁决 → 每条独立判定）。
+   */
+  async rateTurnCard(messageId, verdict, expectedVerdict, blockIndex) {
+    try {
+      return rateTurnCardHost(String(messageId || ""), verdict, expectedVerdict, blockIndex);
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
 }
 
 /** 纯函数：聚合各会话 ruleStats（C2，可独立测试） */
@@ -261,4 +298,85 @@ export function aggregateRuleStats(sessions) {
   return Object.values(merged).sort((a, b) => b.detected - a.detected);
 }
 
+/**
+ * 0.5.15：回合末卡片判例登记（纯函数，可独立测试）。
+ * verdict: "correct"（拦对了，留档）/ "incorrect"（拦错了，学习+命令指纹放行）。
+ * blockIndex：要登记的是卡片中第几条裁决（一回合多次裁决 → 每条独立判定）。
+ * 与 /guard label incorrect 同链路：incorrect 时写命令指纹台账（持久化）；
+ * correct 只记审计留档（不产生指纹放行）。
+ * 一次性语义（2026-09-02 用户拍板）：每条裁决独立一次性锁定（per-block，
+ * 已登记且非同状态重复 → 拒绝改判；改判走 /guard label 命令行）。
+ */
+export function rateTurnCardHost(messageId, verdict, expectedVerdict, blockIndex) {
+  const idx = Number.isInteger(blockIndex) ? blockIndex : -1;
+  // blockIndex 为 -1 = 兼容旧调用（整卡打标），新 client 必传具体索引
+  const card = state.cardByMessage?.get?.(String(messageId || ""));
+  if (!card) return { ok: false, error: "未找到该消息对应的裁决卡片" };
+  if (!card.key) return { ok: false, error: "卡片不可打标（缺少稳定键）" };
+  const isLegacy = idx < 0;
+  const blocks = Array.isArray(card.blocks) ? card.blocks : [];
+  const block = isLegacy ? null : blocks[idx];
+  if (!isLegacy && !block) return { ok: false, error: `裁决块 #${idx} 不存在` };
+  if (typeof verdict !== "string" || (verdict !== "correct" && verdict !== "incorrect")) {
+    return { ok: false, error: "verdict 只能是 correct 或 incorrect" };
+  }
+  const label = verdict === "correct" ? "correct" : "incorrect";
+  // 当前块的已登记状态（legacy = 卡片级 card.label；block 级 = block.label）
+  const currentLabel = isLegacy ? (card.label || null) : (block?.label ?? null);
+  // 幂等确认（防重复点击）：提交与当前显示相同 → 直接成功，不重复审计/写台账
+  if (expectedVerdict && expectedVerdict !== "none" && expectedVerdict === verdict) {
+    return { ok: true, verdict: label, messageId, already: true };
+  }
+  // 一次性语义：已登记且非同状态重复 → 拒绝改判；改判应走 /guard label 命令行
+  if (currentLabel === "correct" || currentLabel === "incorrect") {
+    return { ok: false, error: `该${isLegacy ? "卡片" : "裁决块"}已登记为 ${currentLabel}（判例一次性，不再更改；如需改判请 /guard label ${currentLabel} 相关事件）` };
+  }
+  let fingerprintNote = "";
+  if (label === "incorrect") {
+    // 只对目标 block 的命令做指纹（一回合多次裁决：只学习被判错的那条）
+    const target = isLegacy ? blocks : [block];
+    for (const b of target || []) {
+      if ((b.tool === "pwsh" || b.tool === "bash") && b.args) {
+        try {
+          const cmd = (b.args.match(/\"command\":\s*\"([^\"]*)\"/) || [])[1] || b.args;
+          const fp = labelFingerprint(cmd);
+          if (fp) {
+            state.labelRows = upsertLabel(state.labelRows || [], labelEntry(fp, "incorrect", card.sessionId || ""));
+            fingerprintNote = `；命令指纹已记录：${fp.slice(0, 80)}`;
+          }
+        } catch {
+          // 指纹解析失败不阻断打标
+        }
+      }
+    }
+  }
+  if (fingerprintNote) {
+    saveLabelsToDisk(labelsFilePath(dshHome()), state.labelRows || []);
+  }
+  // 审计留档（correct/incorrect 均记录，供 /guard log 对质）
+  audit({
+    kind: "turn-card-verdict",
+    rule: "__turn-card",
+    name: "回合末卡片判例登记",
+    event: "remote",
+    reason: `${card.key}${isLegacy ? "" : `#${idx}`} = ${label}（messageId=${messageId}${fingerprintNote}）`,
+    session: card.sessionId || ""
+  });
+  if (isLegacy) {
+    card.label = label;
+  } else {
+    block.label = label;
+  }
+  card.verdictAt = Date.now();
+  // 2026-09-02：判例登记即落盘（判例=教学数据，重启不丢）
+  saveTurnCardsToDisk(state);
+  return {
+    ok: true,
+    verdict: label,
+    messageId,
+    blockIndex: isLegacy ? -1 : idx,
+    fingerprintNote
+  };
+}
+
 export { RuleEngineService, RuleEngineService as default };

package/package.json

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

package/scripts/release-plugin.mjs

@@ -0,0 +1,279 @@
+// release-plugin.mjs —— DSH 插件全渠道一键发布（npm + git + GitHub Release）
+// 用法：node release-plugin.mjs <插件名|插件目录> [版本号] [--sync-profile]
+//   - 插件名从 scripts/plugins.json 清单解析（规则 26 ⑤）；或直接给目录路径
+//   - 版本号省略时自动 patch+1（如 1.4.7 -> 1.4.8）
+//   - 自动同步 README 徽章 version-X.Y.Z
+//   - --sync-profile：发布成功后自动更新 profiles/<profile>/pnpm-workspace.yaml 豁免名单
+//     （备份原文件）+ 运行全量装配审计（写 .dsh 需以 danger-full-access 运行本脚本）
+// 前置：npm 已认证、gh 已认证、git 已配置。
+// 网络：默认直连（2026-08-27 实测 npm registry / github.com / api.github.com 直连可用，无需代理；
+//       代理挂掉时不再 ECONNREFUSED）。需要代理的环境设 DSH_RELEASE_PROXY=http://127.0.0.1:7890。
+// 步骤：版本 bump -> 测试 -> npm pack -> npm publish -> git commit+push -> gh release（带 tgz asset）
+// 安全：token 经环境变量注入，不在命令文本/日志中打印
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PROXY = process.env.DSH_RELEASE_PROXY || ""; // 默认直连；需要代理时显式设置
+/** 代理前缀（命令文本）：空 = 直连 */
+const proxyPrefix = () => (PROXY ? `set HTTPS_PROXY=${PROXY}&& set HTTP_PROXY=${PROXY}&& ` : "");
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const WORKSPACE = join(SCRIPT_DIR, "..");
+
+function run(cmd, opts = {}) {
+  console.log(`> ${cmd.slice(0, 120)}${cmd.length > 120 ? "..." : ""}`);
+  return execSync(cmd, { stdio: "inherit", encoding: "utf8", shell: true, ...opts });
+}
+function quiet(cmd) {
+  try {
+    return execSync(cmd, { encoding: "utf8", shell: true, stdio: "pipe" }).toString().trim();
+  } catch {
+    return "";
+  }
+}
+function fail(msg) {
+  console.error(`\n[发布中止] ${msg}`);
+  process.exit(1);
+}
+
+// ── 0. 解析目标（清单名 或 目录路径）────────────────────────────
+const args = process.argv.slice(2);
+const syncProfile = args.includes("--sync-profile");
+const dryRun = args.includes("--dry-run"); // 2026-08-29：发布前预览（只推导+打印，不改文件）
+const target = args.find((a) => !a.startsWith("--")) || "";
+let manifest = null;
+let entry = null;
+let dir = null;
+try {
+  manifest = JSON.parse(readFileSync(join(SCRIPT_DIR, "plugins.json"), "utf8"));
+  entry = manifest.plugins.find((p) => p.name === target) || null;
+} catch {
+  // 清单缺失时仅支持目录路径
+}
+if (entry) {
+  dir = resolve(WORKSPACE, entry.dir);
+} else if (target) {
+  dir = resolve(target);
+} else {
+  fail("用法：node release-plugin.mjs <插件名|插件目录> [版本号] [--sync-profile]");
+}
+if (!existsSync(join(dir, "package.json"))) fail(`目录不存在或不是插件包：${dir}`);
+
+// ── 0. 读取包信息 ────────────────────────────────────────────────
+const pkgPath = join(dir, "package.json");
+const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+const name = pkg.name;
+const oldVer = pkg.version;
+// 版本号 = 非 -- 开头的参数（排除目标名本身），位置任意
+// 2026-08-29 修复（0.5.11-pre 体系）：oldVer 为 -pre/-rc 等预发布后缀时——
+// ① 发布语义 = 剥后缀发正式版（0.5.11-pre → 发布 0.5.11，不是 +1）；
+// ② 自动推导不再 split(".") 直接 Number（"11-pre" 会得 NaN——旧 bug）。
+// 显式传参优先；且显式传参如果是 -pre 形态（意外），本发布不剥（警告留痕）。
+const nextVer = args.find((a) => !a.startsWith("--") && a !== target) || (() => {
+  // 预发布后缀（-pre/-rc）→ 剥后缀发正式版（0.5.11-pre → 0.5.11）
+  if (/-(?:pre|rc|beta|alpha)(?:[.\d]*)$/i.test(oldVer)) return oldVer.replace(/-.*$/, "");
+  // 纯数字 → +1（历史行为）
+  const [maj, min, pat] = oldVer.split(".").map(Number);
+  if (Number.isNaN(pat)) fail(`无法解析版本号：${oldVer}`);
+  return `${maj}.${min}.${pat + 1}`;
+})();
+const repoOverride = entry?.repo || null;
+console.log(`\n=== 发布 ${name}: ${oldVer} -> ${nextVer} ===\n`);
+
+// ── 0.5 本地配套包版本一致性（防止 host/client 版本错位）──────────
+function checkDependencyPair() {
+  if (!entry?.dependsOn || !manifest) return;
+  for (const depName of entry.dependsOn) {
+    const depEntry = manifest.plugins.find((p) => p.name === depName);
+    const depDir = depEntry ? resolve(WORKSPACE, depEntry.dir) : null;
+    if (!depDir || !existsSync(join(depDir, "package.json"))) {
+      console.log(`（未找到依赖 ${depName} 的本地包，跳过版本一致性检查）`);
+      continue;
+    }
+    const depPkg = JSON.parse(readFileSync(join(depDir, "package.json"), "utf8"));
+    const range = pkg.dependencies?.[depName];
+    if (!range) continue;
+    const m = range.match(/^\^(\d+)\.(\d+)\.(\d+)/);
+    if (!m) {
+      console.log(`（依赖 ${depName} 范围 ${range} 不是简单 ^x.y.z，跳过自动校验）`);
+      continue;
+    }
+    const v = depPkg.version.split(".").map(Number);
+    const ok = v[0] === +m[1] && (v[1] > +m[2] || (v[1] === +m[2] && v[2] >= +m[3]));
+    if (!ok) fail(`${name} 声明依赖 ${depName}@${range}，但本地 ${depName} 是 ${depPkg.version}`);
+    console.log(`[依赖一致性] ${name} -> ${depName} ${depPkg.version} ✓`);
+  }
+}
+checkDependencyPair();
+
+// ── 1. 前置检查 ──────────────────────────────────────────────────
+if (!/^\d+\.\d+\.\d+$/.test(nextVer)) fail(`版本号格式错误：${nextVer}`);
+// 2026-09-02 修复：gh auth status 的 "Logged in" 输出在 stderr（新版 gh），stdout 可能为空空
+// → 2>&1 合并 stderr，避免已认证被误判"gh 未认证"（实测 jilian-dsh keyring 已登录却判失败）
+if (!quiet("gh auth status 2>&1").includes("Logged in")) fail("gh 未认证");
+const whoami = quiet("npm whoami 2>&1");
+if (!whoami) fail("npm 未认证（npm whoami 失败）");
+
+// ── 1.5 DSH 兼容预检（发布前防“升级后插件不兼容”）──────────────
+const compatScript = join(SCRIPT_DIR, "check-dsh-compat.mjs");
+if (existsSync(compatScript)) {
+  console.log("\n=== DSH 兼容预检 ===");
+  run(`node "${compatScript}" "${dir}"`);
+}
+
+// ── 1.6 profile dump-config 冒烟（确认 DSH 可导出当前 profile 配置）──
+function findDshBin() {
+  const candidates = [process.env.DSH_BIN, "D:/npm-global/dsh.cmd", "D:/npm-global/dsh", "dsh"].filter(Boolean);
+  for (const c of candidates) {
+    if (quiet(`where ${c}`)) return c;
+  }
+  return "";
+}
+const dshCmd = findDshBin();
+if (dshCmd) {
+  const dump = quiet(`"${dshCmd}" --profile ${manifest?.profile || "web"} --dump-config`);
+  if (dump && !/error|Error|ENOENT/i.test(dump)) {
+    console.log("（profile dump-config 冒烟通过：DSH 配置可正常导出）");
+  } else {
+    console.log("（profile dump-config 冒烟未通过：请人工确认 DSH 可用后发布）");
+  }
+} else {
+  console.log("（未找到 dsh 命令，跳过 profile dump-config 冒烟）");
+}
+
+// ── 2. 版本 bump（package.json + README 徽章）────────────────────
+if (dryRun) {
+  console.log(`[DRY-RUN] 不修改任何文件。`);
+  console.log(`[DRY-RUN] oldVer=${oldVer} → nextVer=${nextVer}`);
+  const rd = join(dir, "README.md");
+  if (existsSync(rd)) {
+    const t = readFileSync(rd, "utf8");
+    const oldBadgeVer = `version-${oldVer}`;
+    const oldBadgeUrl = `version-${oldVer.replace(/-/g, "--")}`;
+    const nextUrl = `version-${nextVer}`;
+    const replaced = t.replaceAll(oldBadgeVer, nextUrl).replaceAll(oldBadgeUrl, nextUrl);
+    console.log(`[DRY-RUN] README 徽章将变为: ${replaced.match(/version-[^\s]+/)?.[0] || "(未命中，检查徽章形态)"}`);
+  }
+  process.exit(0);
+}
+writeFileSync(pkgPath, readFileSync(pkgPath, "utf8").replace(`"version": "${oldVer}"`, `"version": "${nextVer}"`));
+for (const readme of ["README.md", "README.en.md"]) {
+  const rp = join(dir, readme);
+  if (existsSync(rp)) {
+    const text = readFileSync(rp, "utf8");
+    // 2026-08-29 修复：徽章 URL 编码把 `0.5.11-pre` 转成 `0.5.11--pre`（`-` 被 shields 双横线），
+    // 旧正则 `version-0.5.11-pre` 匹配不到 `version-0.5.11--pre` → 徽章漏改（㉙ 机器根因之一）。
+    // replaceAll 用字面串（非正则），无需转义。
+    const oldBadgeVer = `version-${oldVer}`;                       // JSON 形态：version-0.5.11-pre
+    const oldBadgeUrl = `version-${oldVer.replace(/-/g, "--")}`;   // URL 形态：version-0.5.11--pre
+    const nextUrl = `version-${nextVer}`;
+    const replaced = text
+      .replaceAll(oldBadgeVer, nextUrl)
+      .replaceAll(oldBadgeUrl, nextUrl);
+    if (replaced !== text) writeFileSync(rp, replaced);
+  }
+}
+console.log("版本已 bump（package.json + README 徽章）");
+
+// ── 3. 测试（规则 23：发布前运行时验证）─────────────────────────
+if (pkg.scripts && pkg.scripts.test) {
+  console.log("\n=== 运行测试 ===");
+  run(`cd /d "${dir}" && npm test --prefix "${dir}"`);
+} else {
+  console.log("（无 test 脚本，跳过）");
+}
+
+// ── 4. pack + publish ────────────────────────────────────────────
+console.log("\n=== npm pack ===");
+run(`cd /d "${dir}" && npm pack --pack-destination .`);
+const tgz = `${name}-${nextVer}.tgz`;
+if (!existsSync(join(dir, tgz))) fail(`打包产物缺失：${tgz}`);
+
+console.log("\n=== npm publish ===");
+run(`cd /d "${dir}" && ${proxyPrefix()}npm publish ${tgz}`);
+
+// ── 5. git commit + push（token 经环境变量注入 URL，命令文本不含密钥明文）─────
+console.log("\n=== git commit + push ===");
+// 2026-08-25 修复 pushUrl 双重拼接：origin 可能是 ssh（git@github.com:）、https（https://github.com/）
+// 或裸路径（user/repo）三种形态——统一归一化为 "owner/repo" 路径再拼 token URL（此前 https origin 未剥前缀
+// 导致 "https://github.com/https://github.com/..." 双重 URL，push 404）
+const repo = (repoOverride || quiet(`cd /d "${dir}" && git remote get-url origin`))
+  .replace(/^git@github\.com:/, "")
+  .replace(/^https?:\/\/github\.com\//, "")
+  .replace(/\.git$/, "");
+const token = quiet("gh auth token");
+if (!token) fail("无法获取 gh token");
+// 与 v3.72 同款通道：token 拼进 HTTPS URL 直推（避开沙箱下 msys 凭据管道的 EPERM）
+const pushUrl = `https://jilian-dsh:${token}@github.com/${repo}.git`;
+// 2026-08-31 修复：repoRoot 实测 git 仓库根（插件目录可能只是子目录，如 rules-manager 在 oss 仓库内）；
+// stageSpec = 插件目录相对仓库根路径（防 git add -A 误带仓库内无关改动/未跟踪物）
+const repoRoot = quiet(`cd /d "${dir}" && git rev-parse --show-toplevel`).trim();
+const relDir = relative(repoRoot, dir).split(/[\\/]/).join("/");
+const stageSpec = relDir && relDir !== "." ? relDir : "";
+// 2026-08-29 防漏机检（0.5.10 git 欠账事故：git add -u 只更新已跟踪文件，未跟踪新文件
+// （npm pack 按目录打包、天然包含）会漏进 git 提交 → git 与 npm 内容不一致）。
+// 现在：提交前检测未跟踪文件并打印名单，改用 add -A 一并提交（.gitignore 已排除杂质）。
+const untrackedList = quiet(`cd /d "${repoRoot}" && git status --porcelain -- ${stageSpec}`)
+  .split("\n").filter((l) => l.startsWith("??")).map((l) => l.slice(3));
+if (untrackedList.length > 0) {
+  console.log(`（未跟踪文件 ${untrackedList.length} 个将一并提交：${untrackedList.slice(0, 6).join(", ")}${untrackedList.length > 6 ? " 等" : ""}）`);
+}
+run(`cd /d "${repoRoot}" && ${proxyPrefix()}git add -A -- ${stageSpec} && git -c core.autocrlf=false commit -m "release: ${name} v${nextVer}" || exit 0`);
+run(`cd /d "${repoRoot}" && ${proxyPrefix()}git push "${pushUrl}" HEAD`);
+
+// ── 6. GitHub Release（带正式 tgz asset，规则 26；清单标记 skipRelease 的包不建）─────
+if (entry?.skipRelease) {
+  console.log("（清单标记 skipRelease，跳过 GitHub Release）");
+} else {
+  console.log("\n=== GitHub Release ===");
+  const notesFile = join(process.env.TEMP || ".", `notes-${name}-${nextVer}.md`);
+  writeFileSync(notesFile, `## v${nextVer}\n\nRelease generated by scripts/release-plugin.mjs\n`);
+  // 必须在插件目录（git 仓库）内运行：gh release 内部会做 git 检查
+  run(`cd /d "${dir}" && ${proxyPrefix()}gh release create v${nextVer} "${join(dir, tgz)}" --title "${name} v${nextVer}" --notes-file "${notesFile}"`);
+}
+
+// ── 7. 本机 profile 同步（--sync-profile：豁免名单 + 装配审计；需 danger-full-access 运行）──
+if (syncProfile) {
+  console.log("\n=== 本机 profile 同步 ===");
+  let manifest = null;
+  try {
+    manifest = JSON.parse(readFileSync(join(SCRIPT_DIR, "plugins.json"), "utf8"));
+  } catch {
+    manifest = { profile: "web" };
+  }
+  const profileDir = resolve(WORKSPACE, "..", ".dsh", "profiles", manifest.profile || "web");
+  const wsYaml = join(profileDir, "pnpm-workspace.yaml");
+  if (existsSync(wsYaml)) {
+    const raw = readFileSync(wsYaml, "utf8");
+    const lineRe = new RegExp(`^(  - ${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}@[^\\n]*)$`, "m");
+    const m = raw.match(lineRe);
+    if (m && !m[1].includes(nextVer)) {
+      const bakDir = join(profileDir, "..", ".backups");
+      mkdirSync(bakDir, { recursive: true });
+      const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const bak = join(bakDir, `pnpm-workspace-${stamp}.yaml`);
+      copyFileSync(wsYaml, bak);
+      const updated = raw.replace(lineRe, `${m[1]} || ${nextVer}`);
+      writeFileSync(wsYaml, updated);
+      console.log(`豁免名单已追加 ${name}@${nextVer}（备份 ${bak}）`);
+    } else if (!m) {
+      console.log(`（豁免名单无 ${name} 条目，跳过）`);
+    } else {
+      console.log(`（豁免名单已含 ${nextVer}，跳过）`);
+    }
+  }
+  // 全量装配审计（规则 27）
+  const auditScript = join(SCRIPT_DIR, "..", "projects", "oss", "dsh-rule-engine", "scripts", "audit-mount-consistency.mjs");
+  if (existsSync(auditScript)) {
+    const out = quiet(`node "${auditScript}" --profile ${manifest.profile || "web"}`);
+    const pass = /MOUNT CONSISTENT/.test(out);
+    console.log(out.split("\n").filter((l) => /RESULT|DUPLICATES|MOUNT|summary/.test(l)).join("\n"));
+    if (!pass) fail("装配审计未通过（MOUNT CONSISTENT 未出现），请先处理再重启 DSH");
+    console.log("装配审计 MOUNT CONSISTENT ✓");
+  }
+}
+
+console.log(`\n=== 发布完成：${name} v${nextVer} ===`);
+console.log(`npm: ${name}@${nextVer}`);
+console.log(`release: https://github.com/${repo}/releases/tag/v${nextVer}`);