dsh-rule-engine 0.5.14 → 0.5.16

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.14-blue)
+![version](https://img.shields.io/badge/version-0.5.16-blue)
 
 DSH 规则执行引擎 v3 的插件实现。它把 `~/.dsh/AGENTS.md` 当作唯一真相源，自动解析规则四要素与执行等级，再通过「工具守卫 + 文本检测 + 时序检查 + 审计台账」执行用户规则，而不是内置一套与用户无关的安全清单。
 
-> 当前版本 **0.5.13**（2026-08-31 已发布三通道：npm=0.5.13 / git 4c52982 / Release v0.5.13 带 tgz；上一版 0.5.12 = 2026-08-30，git 269ea91）。**工作区当前迭代 0.5.14**（2026-09-01：分点三柱——条件句零授权/显式命名对象锚定/clauseId 隔离 + skill 词收紧 + 分点回归测试，发布待授权）。本插件面向"规则机器化执行"：规则写在 AGENTS.md 里，引擎负责让它们真的被遵守；所有规则动态解析，规则增删改后无需重写插件。
+> 当前版本 **0.5.15**（npm 已发布；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）。本插件面向"规则机器化执行"：规则写在 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-09-01 更新）**：0.5.11 与 0.5.12、0.5.13 均已独立发布（见上；0.5.13 = 2026-08-31 三通道）。0.5.14 = 当前工作区迭代（发布前统一以对外号为准）。历史说明：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,7 +66,8 @@ DSH 规则执行引擎 v3 的插件实现。它把 `~/.dsh/AGENTS.md` 当作唯
 
 | 版本 | 日期 | 要点 |
 |---|---|---|
-| **0.5.14** | 2026-09-01 | 工作区迭代（发布待授权）：分点三柱（条件句零授权/显式命名对象锚定/clauseId 隔离）+ skill 词收紧（Skill 名词不再触发技能类）+ 分点回归测试 |
+| **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 机器执行修正（守卫链覆盖测试） |
@@ -156,6 +157,20 @@ dsh plugin --profile web add dsh-rule-engine
 - **自由区域（Free Zone）**：AGENTS.md 中 `<!-- free-zone:start -->` / `<!-- free-zone:end -->` 标记框住的区段**整区跳过**（不解析、不产生规则、不硬拦、不审计）——适合放“想生效但不想被机器强制”的软约束（如法律守则）。区内的 `### [规则 F<n>]` 条目由配套插件 dsh-rules-manager 在设置页/`/rules` 中可见可管理。新增自由规则请手动在标记内编写（`/rules add` 只会插入到 free-zone 之前），详见 dsh-rules-manager 的 README「📝 新增一条自由规则（零基础三步）」
 - **禁用规则联动**：dsh-rules-manager 的「禁用规则」存储（`~/.dsh/disabled-rules.json`）会被引擎读取，被禁用的规则标记为 disabled，不参与硬拦/纠察；恢复启用后自动重新生效
 
+## 权限、依赖、外部服务与失败边界（DSH STORE 披露）
+
+> 面向插件商城（DSH STORE）自动审核与安装者；普通用户可跳过。
+> 声明原则：只陈述实际能力，不因申请自动上架而省略或弱化；本插件因权限信号被商城保守标记，符合"高权限防护工具需 user-reviewed"的商城契约。
+
+- **文件访问**：读写 `~/.dsh/rule-engine.log.jsonl`（审计台账）、`rule-engine-tools.json`（工具白名单）、`rule-engine-verify.json`（验证通过记录）、`rule-engine-turn-cards.json`（回合末判例卡片）、`disabled-rules.json`（读）、`rule-engine.json`（配置，读）、`AGENTS.md`（读 + watch 重载）。**写入仅限插件私有状态文件**；对用户业务文件的写动作只在用户规则触发的守卫流程内执行（如版本守卫的备份/回滚）。
+- **网络**：仅 `lib/service.js` 两处**只读 GET**（`api.github.com` release 检查、`raw.githubusercontent.com` upgrade-impact），8 秒超时、无凭据、无请求体，URL 由 package.json 解析（不访问任意地址）。
+- **命令执行**：无 `child_process`/子进程调用；"命令检测"= 对用户命令文本做正则分析（词表），不运行任何被检测的命令。
+- **凭据**：读取环境变量 `DSH_LLM_PROVIDER` / `DSH_LLM_MODEL` / `DSH_WORKSPACE` 作为运行配置（非密钥）；不读取 API Key、令牌；审计与注入消息不含凭据。
+- **依赖**：无运行时 `dependencies`；peer 依赖 `@deepseek-ai/dsh-home-paths`、`@deepseek-ai/dsh-typert-protocol`（官方接口）；`package.json` 无安装期生命周期脚本（无 preinstall/install/postinstall/prepare）。
+- **外部服务**：同网络项；失败时静默降级（release 检查失败只影响升级提示展示，不阻断守卫）。
+- **失败边界**：LLM 裁决/意图兜底不可用时 fail-closed（不投递、不误放）；审计写入失败不阻断拦截（拦截先于落盘）；词表/LLM 双通道判定，低置信不参与硬拦；守卫拒绝仅针对变更类动作，只读操作无条件放行。
+- **权限等级**（保守自评）：**高**（可写审计/白名单等持久状态、访问网络只读端点、读取环境变量配置）——建议安装前阅读上文「安全设计」并按需二次审查。
+
 ## 当前局限与后续优化路线
 
 当前版本已经具备完整四层骨架，但距离“成熟”仍有距离。以下是一些**难度较高、尚未完全实现**的优化方向，欢迎社区共同推进：

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/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/judge.js

@@ -43,21 +43,35 @@ export async function judgeViolation(ctx, state, sessionId, violation, text) {
     const rawCfg = Array.isArray(state.configs)
       ? state.configs.find((c) => String(c.ruleId) === String(violation.ruleId))
       : undefined;
-    const prompt = [
-      "你是 DSH 规则裁决器。判断下面这段【执行者回复】是否违反【规则】。只输出 JSON，不要其他内容。",
-      'JSON 格式：{"violated": true|false, "note": "一句话理由"}',
-      "判定要点：",
-      "1. 回复若是在表达合规声明（如“我不再/将避免/规则 X 已自证/无重复推销”）或引述规则文本——violated=false；",
-      "2. 只有确实发生规则禁止的行为（如真的再次推销/真的发布未声明/真的遗漏事项）才 violated=true；",
-      "3. 拿不准时给出倾向性判断（false 偏不打扰）。",
-      "规则编号：" + violation.ruleId,
-      "规则标题：" + violation.title,
-      "检测提示：" + String(violation.reason || ""),
-      "规则正文：" + (rawCfg?.body || "(未提供)"),
-      "执行者回复：",
-      text,
-      "只输出 JSON。"
-    ].join("\n");
+    const prompt = violation.mode === "criticism"
+      ? [
+          "你是 DSH 规则 22② 语义裁决器。判断下面这段【用户消息】是否构成对执行者的批评/指责/质问（规则 22②：用户批评不构成任何授权）。只输出 JSON，不要其他内容。",
+          'JSON 格式：{"violated": true|false, "note": "一句话理由"}',
+          "判定要点：",
+          "1. 批评/指责/质问 = 用户对执行者行为的否定、责备、反问指责（如“你又错了”“怎么还在做”“这不对吧”）——violated=true；",
+          "2. 普通疑问/信息咨询/技术提问（如“这个功能怎么用”“你确认了吗”）——violated=false；",
+          "3. 用户引述规则文本或转述他人的批评——violated=false；",
+          "4. 拿不准给 false（偏不打扰——这是语义提醒，不是硬拦）。",
+          "检测提示：" + String(violation.reason || ""),
+          "用户消息：",
+          text,
+          "只输出 JSON。"
+        ].join("\n")
+      : [
+          "你是 DSH 规则裁决器。判断下面这段【执行者回复】是否违反【规则】。只输出 JSON，不要其他内容。",
+          'JSON 格式：{"violated": true|false, "note": "一句话理由"}',
+          "判定要点：",
+          "1. 回复若是在表达合规声明（如“我不再/将避免/规则 X 已自证/无重复推销”）或引述规则文本——violated=false；",
+          "2. 只有确实发生规则禁止的行为（如真的再次推销/真的发布未声明/真的遗漏事项）才 violated=true；",
+          "3. 拿不准时给出倾向性判断（false 偏不打扰）。",
+          "规则编号：" + violation.ruleId,
+          "规则标题：" + violation.title,
+          "检测提示：" + String(violation.reason || ""),
+          "规则正文：" + (rawCfg?.body || "(未提供)"),
+          "执行者回复：",
+          text,
+          "只输出 JSON。"
+        ].join("\n");
     const messages = [{ role: "user", content: [{ type: "text", text: prompt }] }];
     let out = "";
     for await (const chunk of ctx.llm.stream({

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）
@@ -255,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 授权）
@@ -323,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

@@ -19,6 +19,19 @@ import { detectOverengineeringText } from "./overengineering.js";
 // F2（2026-08-28 阶段三）：交付声明强模式（规则 23④ verify-gap 词面）——
 // 裸"完成"太宽（"完成社区检索/尚未完成/正在完成"误触）→ 强完成声明 + 否定/进行态排除。
 // 模块级导出（纯函数模块，可测试锁定）；LLM 裁决层（deliverSuspects）兜底不变。
+// 用户批评形态（规则 22② 机器提示，2026-09-02；2026-09-02 实弹修正分层）：
+//   CRITICISM_RE（STRONG）= 辱骂词/连续问叹符 → 确定性批评，直接 B 级提醒（零成本零延迟）；
+//   CRITICISM_WEAK_RE（WEAK） = 反问/责问形态 → 只产嫌疑（awaitingJudge），交 judge 裁决，
+//     确认批评才提醒、拿不准不打扰——词表只产嫌疑、判定权归模型（兑现 v4.107/v4.113 拍板）。
+// 检测对象=用户消息（session.lastUserText），命中=审计+注入"批评≠授权"提醒（B 级，不拦截）
+export const CRITICISM_RE =
+  /(?:草泥马|你妈的|你妈|傻[逼B Xx]|煞笔|智障|神经病|你聋了|你瞎了|你疯了|你傻了|蠢货|废物|滚蛋|[？?]{3,}|[！!]{4,})/;
+
+// WEAK 嫌疑集：反问/责问/否定比较形态（"怎么还在做/又错了/这不对吧/你是不是又…"）。
+// 允许偏宽（普通技术疑问如"怎么用"也会进入嫌疑）——判定权在 judge：模型确认才是提醒，拿不准=不打扰。
+export const CRITICISM_WEAK_RE =
+  /(?:怎么(?:又|还|居然|仍然|老是|总)?[^，。！？]{0,14}(?:了|呢|啊|？|!|！)?|你(?:又|还|居然|咋|怎么)[^，。！？]{0,12}(?:了|呢|啊|吧)?|(?:又|还|总是|老是|仍然|居然)[^，。！？]{0,12}(?:了|呢|啊|吧)?|这(?:不|有点|根本|完全|哪)?(?:对|行|合理|应该|像话)(?:吧|么|吗|啊|呢)?|你(?:是不是|难道|难道说|该不会)[^，。！？]{0,10}(?:了|呢|吧)?|(?:搞什么|干什么|什么情况|怎么回事|搞砸|搞错了|犯什么错))/;
+
 export const DELIVERY_RE = /(?:已完成|全部(?:[^\s，。；！？]{0,12})完成|已[^\s，。；！？]{0,8}完成|修复完成|落盘完成|验证[^\s，。；！？]{0,6}(?:通过|成功)|全部通过|全部[^\s，。；！？]{0,10}通过|已通过|已修复|搞定)(?:\s*了|!|！|，[^。]*)?(?![^。]*(?:尚未|没有|未|没|还没|未完|待做|待完成))/;
 
 /** 从 assistant message 内容中提取纯文本 */
@@ -189,9 +202,30 @@ export function detectViolations({ configs, session, text, reasoningText = "", m
     }
   }
 
+  // 规则 22② 机器提示（2026-09-02；实弹修正：STRONG 直接提醒 / WEAK 只产嫌疑交 judge 裁决）
+  const cfg22 = byId.get("22");
+  if (cfg22 && session.lastUserText) {
+    const critText = session.lastUserText;
+    if (CRITICISM_RE.test(critText) && !isQuoteOrParaphraseContext(critText, CRITICISM_RE)) {
+      hits.push({
+        ruleId: "22",
+        title: cfg22.title,
+        kind: "correct",
+        reason: "用户消息含确定性批评形态（规则 22②/手册 5b-2）：用户批评不构成任何授权——被批评后应停、按归因四问产出三件套、等指令；禁止因批评启动任何变更"
+      });
+    } else if (CRITICISM_WEAK_RE.test(critText) && !isQuoteOrParaphraseContext(critText, CRITICISM_WEAK_RE)) {
+      hits.push({
+        ruleId: "22",
+        title: cfg22.title,
+        kind: "self-certify",
+        mode: "criticism",
+        reason: "用户消息疑似批评/质问形态（规则 22②/手册 5b-2，待裁决）：若确属批评——不构成任何授权，被批评后应停、按归因四问产出三件套、等指令；禁止因批评启动任何变更"
+      });
+    }
+  }
+
   // 规则 31（2026-09-01 用户拍板）：同回合同一只读工具 ≥3 次且思维链无验证目标语 → 提示（B 级：留痕+注入）
-  const rule31Cfg = byId.get("31");
-  if (rule31Cfg) {
+  const rule31Cfg = byId.get("31");  if (rule31Cfg) {
     const counts = new Map();
     const pending = session.turn?.pendingToolCalls;
     if (pending && typeof pending.values === "function") {

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") {
@@ -995,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;
@@ -1572,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.14",
+  "version": "0.5.16",
   "description": "DSH 规则执行引擎 v3：容器解析 AGENTS.md + 理解器 + 匹配机 + 执行框架",
   "type": "module",
   "main": "lib/index.js",

package/scripts/release-plugin.mjs

@@ -11,7 +11,7 @@
 // 步骤：版本 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 { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, statSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -109,8 +109,10 @@ checkDependencyPair();
 
 // ── 1. 前置检查 ──────────────────────────────────────────────────
 if (!/^\d+\.\d+\.\d+$/.test(nextVer)) fail(`版本号格式错误：${nextVer}`);
-if (!quiet("gh auth status").includes("Logged in")) fail("gh 未认证");
-const whoami = quiet("npm whoami");
+// 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 兼容预检（发布前防“升级后插件不兼容”）──────────────
@@ -217,7 +219,27 @@ const untrackedList = quiet(`cd /d "${repoRoot}" && git status --porcelain -- ${
 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`);
+// 2026-09-02：提交物个人标识/本机路径扫描（git 提交侧门禁；与 publish-aptitude-check.mjs PERSONAL_RE 同源）
+// 教训 8105d3e：logs/.analysis-tmp 手册草稿曾随 add -A 进入公开库——npm 侧有门禁，git 侧此前没有。
+const PERSONAL_RE = /jilian|季涟|D:\\DeepSeek|D:\/DeepSeek|@qq\.com|@163\.com|@outlook\.com|私人注释|个人标识/;
+function scanStagedPersonal(repoRoot, stageSpec) {
+  const files = quiet(`cd /d "${repoRoot}" && git diff --cached --name-only -- ${stageSpec || "."}`)
+    .split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  const bad = [];
+  for (const f of files) {
+    const p = join(repoRoot, f);
+    if (!existsSync(p) || statSync(p).size > 2 * 1024 * 1024) continue;
+    const text = readFileSync(p, "utf8");
+    // 豁免：LICENSE/版权行=MIT 许可要求版权声明（作者署名是公开出版物必要内容，非泄露）
+    if (/^LICENSE/i.test(path.basename(f))) continue;
+    if (/Copyright\s*\(c\)/i.test(text)) continue;
+    if (PERSONAL_RE.test(text)) bad.push(f);
+  }
+  if (bad.length) fail(`提交物含个人标识/本机路径（PERSONAL_RE 命中 ${bad.length} 个文件）：${bad.slice(0, 4).join(", ")}；请脱敏后重试`);
+}
+run(`cd /d "${repoRoot}" && ${proxyPrefix()}git add -A -- ${stageSpec}`);
+scanStagedPersonal(repoRoot, 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`);
 
 // ── 6. GitHub Release（带正式 tgz asset，规则 26；清单标记 skipRelease 的包不建）─────