dsh-rule-engine 0.5.12 → 0.5.13

package/lib/index.js

@@ -101,6 +101,11 @@ export const inject = ["tools", "commands", "agents", "workspaceRegistry", "skil
 const pluginConfig = loadPluginConfig();
 state.enabled = pluginConfig.enabled;
 applyTaskContractConfig(state, pluginConfig);
+// T3 通用化（2026-08-31）：声明式绑定覆盖表注入（rule-engine.json 可选键 handlerOverrides；缺省 {}）
+state.handlerOverrides = pluginConfig?.handlerOverrides || {};
+// 残余1 剥离（2026-08-31）：本机默认偏好表注入（rule-engine.json 可选键 handlerDefaultMap；
+// 通用部署=空表——代码零本机编号，本机偏好不随包走、升级不丢）
+state.handlerDefaultMap = pluginConfig?.handlerDefaultMap || {};
 // reloadRules 内部已统一刷新理解产物（P0-3），此处不再重复写
 reloadRules(state);
 
@@ -157,6 +162,23 @@ function sessionIdOfExec(exec) {
   return "global";
 }
 
+/**
+ * 从 /guard 命令 invocation 取会话 id（2026-08-31 会话寻址修复）。
+ * 官方 CommandInvocation 无 session 字段（只有 commandId/agent/rawInput/attachments/signal），
+ * 旧代码 invocation?.session?.id 恒为 undefined → 永远落到 "global"（仅模板），而当前会话的
+ * contract 在创建时已快照、不随 global 变化 —— 这是"/guard mode change 放行无效"的根因。
+ * 官方类型：Agent.id 与 session.id 是同一身份（"The single identity shared with session"），
+ * 收到命令的代理 = 命令发起的会话；裁决侧 sessionIdOfExec 取 exec.agent.session.id —— 两者对齐。
+ */
+export function sessionIdOfInvocation(invocation) {
+  const agent = invocation?.agent;
+  if (!agent) return "global";
+  if (typeof agent.id === "string" && agent.id) return agent.id;
+  if (typeof agent.session === "object" && agent.session?.id) return agent.session.id;
+  if (typeof agent.session === "string") return agent.session;
+  return "global";
+}
+
 /**
  * 从 user/message 事件提取用户文本。
  * 2026-08-24 根因修复：官方结构（@deepseek-ai/dsh-session/surface）中
@@ -1078,23 +1100,30 @@ export function handleSessionEvent(ctx, session, event) {
 
 // ── /guard 命令 ─────────────────────────────────────────────────────────────
 
+// ── /guard 子命令单一真源（0.5.13：hint 手写漏 tools 修复）──
+// hint（输入框提示）与 USAGE（完整帮助）均由此派生：未来新增子命令只改这一个数组。
+const COMMAND_SPECS = [
+  { name: "status", args: "", desc: "引擎状态" },
+  { name: "rules", args: "", desc: "规则清单 + 理解产物" },
+  { name: "active", args: "", desc: "最近激活的规则" },
+  { name: "log", args: "[N]", desc: "最近 N 条审计（默认 10）" },
+  { name: "unlock", args: "[N]", desc: "解锁配置写保护 N 分钟（默认 10，仅用户）" },
+  { name: "bypass", args: "[N]", desc: "临时整体放行 N 分钟（默认 5，仅用户）" },
+  { name: "lock", args: "", desc: "立即恢复全部守卫（取消解锁/放行）" },
+  { name: "revoke", args: "", desc: "撤销全部授权记录" },
+  { name: "tools", args: "", desc: "工具放行白名单（永久+本会话，含时间/来源会话）" },
+  { name: "tools revoke", args: "<工具名>", desc: "撤销白名单条目（持久化+会话集）" },
+  { name: "reload", args: "", desc: "强制重解析 AGENTS.md" },
+  { name: "mode", args: "<模式>", desc: "设置任务契约模式（review/answer/change/monitor/watch/off）" },
+  { name: "budget", args: "...", desc: "设置预算（agents=N files=... deps=allow hash=allow）" },
+  { name: "contract", args: "", desc: "查看当前任务契约" },
+  { name: "contract categories", args: "...", desc: "设定契约类别白名单（0.5.12）" },
+  { name: "label", args: "<id> <label>", desc: "给审计记录打标（correct/incorrect/inconclusive）" }
+];
+
 const USAGE = [
   "用法：",
-  "  /guard status          引擎状态",
-  "  /guard rules           规则清单 + 理解产物",
-  "  /guard active          最近激活的规则",
-  "  /guard log [N]         最近 N 条审计（默认 10）",
-  "  /guard unlock [N]      解锁配置写保护 N 分钟（默认 10，仅用户）",
-  "  /guard bypass [N]      临时整体放行 N 分钟（默认 5，仅用户）",
-  "  /guard lock            立即恢复全部守卫（取消解锁/放行）",
-  "  /guard revoke          撤销全部授权记录",
-  "  /guard tools           工具放行白名单（永久+本会话，含时间/来源会话）",
-  "  /guard tools revoke <工具名>  撤销白名单条目（持久化+会话集）",
-  "  /guard reload          强制重解析 AGENTS.md",
-  "  /guard mode <模式>     设置任务契约模式（review/answer/change/monitor/watch/off）",
-  "  /guard budget ...      设置预算（agents=N files=... deps=allow hash=allow）",
-  "  /guard contract        查看当前任务契约",
-  "  /guard label <id> <label>  给审计记录打标（correct/incorrect/inconclusive）",
+  ...COMMAND_SPECS.map((s) => `  /guard ${s.name}${s.args ? " " + s.args : ""}  ${s.desc}`),
   "",
   "说明：",
   "  - 守卫 = 硬拦截：违反规则的工具调用直接拒绝，模型无法自行绕过；",
@@ -1102,6 +1131,10 @@ const USAGE = [
   "  - 每次拦截/纠察都会记录到 " + auditFilePath() + "（/guard log 可查）。"
 ].join("\n");
 
+// 输入框提示：由子命令清单自动派生（顶层命令名去重，新子命令/别名自动同步）
+// eslint-disable-next-line no-unused-vars
+const GUARD_HINT = "[" + [...new Set(COMMAND_SPECS.map((s) => s.name.split(" ")[0]))].join("|") + "]";
+
 function parseCommand(rawInput) {
   const text = (rawInput || "").trim();
   if (!text || /^(status|state)$/i.test(text)) return { kind: "status" };
@@ -1156,11 +1189,14 @@ async function executeGuard(ctx, invocation) {
       const medium = state.configs.filter((c) => c.confidence === "medium").length;
       const low = state.configs.filter((c) => c.confidence === "low").length;
       // 覆盖自省（一致性预防）：dead = 映射有但规则无；uncovered = 硬等级规则但无 handler
-      const { dead, uncovered } = analyzeCoverage(state.configs);
+      const { dead, uncovered } = analyzeCoverage(state.configs, state.handlerDefaultMap || {});
       const parts = [
         "【规则引擎状态】",
         `  总开关：${state.enabled ? "开启" : "已关闭"}`,
         `  任务契约：${state.taskContract?.taskContractEnabled ? `开启（模式 ${state.taskContract.taskContractMode}｜ask ${state.taskContract.askEnabled ? "开" : "关"}）` : "关闭"}`,
+        // 2026-08-31：本会话真实契约（mode/level/预算）——档位（面板）≠ 本会话模式，两者分开展示
+        // （旧版只显示档位：用户 "armed" 误以为已放行，实际裁决按会话 mode 走）
+        `  本会话契约：${state.taskContract?.taskContractEnabled ? `${contractSummary(getSessionState(state, sessionIdOfInvocation(invocation)).contract)}（会话 ${sessionIdOfInvocation(invocation)}）` : "关闭（总开关未开，命令不生效）"}`,
         `  规则容器：${state.configOk ? `正常（${state.configs.length} 条规则）` : "⚠ " + state.configError}`,
         `  理解置信度：high ${high} / medium ${medium} / low ${low}`,
         `  覆盖自省：${dead.size === 0 && uncovered.length === 0 ? "无缺口" : (dead.size > 0 ? `死映射 ${[...dead.keys()].join("、")}（引擎映射存在但规则已删除，建议清理）` : "") + (uncovered.length > 0 ? `；未覆盖 ${uncovered.map((u) => u.ruleId).join("、")}（${uncovered.map((u) => u.actions.join("+")).join("；")} 但无 handler，规则声明强制但引擎不执行，建议降 D 级或补实现）` : "")}`,
@@ -1199,7 +1235,7 @@ async function executeGuard(ctx, invocation) {
       const minutes = Math.min(Math.max(1, command.minutes), 60);
       state.unlockUntil = Date.now() + minutes * 60000;
       // 逃生门请求审计（机制批 M1）：用途留痕，供规则 1⑤ 事前说明核对
-      audit({ kind: "guard-command", rule: "__escape-gate", name: "逃生门请求", event: "command", reason: `/guard unlock ${minutes} 分钟（配置写保护）`, session: invocation?.session?.id || "global" });
+      audit({ kind: "guard-command", rule: "__escape-gate", name: "逃生门请求", event: "command", reason: `/guard unlock ${minutes} 分钟（配置写保护）`, session: sessionIdOfInvocation(invocation) });
       return {
         kind: "success",
         text: `已解锁「配置写保护」${minutes} 分钟。现在可以让助手修改 rule-engine.json / rule-understanding.json / AGENTS.md；改完请执行 /guard lock 或等待自动恢复。`
@@ -1209,7 +1245,7 @@ async function executeGuard(ctx, invocation) {
       const minutes = Math.min(Math.max(1, command.minutes), 60);
       state.bypassUntil = Date.now() + minutes * 60000;
       // 逃生门请求审计（机制批 M1）
-      audit({ kind: "guard-command", rule: "__escape-gate", name: "逃生门请求", event: "command", reason: `/guard bypass ${minutes} 分钟（全部守卫）`, session: invocation?.session?.id || "global" });
+      audit({ kind: "guard-command", rule: "__escape-gate", name: "逃生门请求", event: "command", reason: `/guard bypass ${minutes} 分钟（全部守卫）`, session: sessionIdOfInvocation(invocation) });
       return {
         kind: "success",
         text: `已临时放行全部守卫 ${minutes} 分钟。到期自动恢复，也可 /guard reload 后立即恢复。`
@@ -1230,7 +1266,7 @@ async function executeGuard(ctx, invocation) {
         name: "撤销全部授权",
         event: "command",
         reason: `撤销 ${count} 条授权/范围（session + turn.scopes + global + askRejections 全清）`,
-        session: invocation?.session?.id || "global"
+        session: sessionIdOfInvocation(invocation)
       });
       return { kind: "success", text: `已撤销全部授权与范围（共 ${count} 条，含全局池与 ask 拒绝记录；不再有残留）。` };
     }
@@ -1275,7 +1311,7 @@ async function executeGuard(ctx, invocation) {
           name: "白名单撤销",
           event: "command",
           reason: `/guard tools revoke ${target}（持久化+会话集同步移除）`,
-          session: invocation?.session?.id || "global"
+          session: sessionIdOfInvocation(invocation)
         });
         return { kind: "success", text: `已撤销 ${target}${existed ? "" : "（原不在白名单）"}。` };
       }
@@ -1296,7 +1332,7 @@ async function executeGuard(ctx, invocation) {
     }
     case "mode": {
       if (!state.taskContract?.taskContractEnabled) return { kind: "error", text: "任务契约未启用：请先在规则引擎设置页开启总开关。" };
-      const sid = invocation?.session?.id || "global";
+      const sid = sessionIdOfInvocation(invocation);
       const s = getSessionState(state, sid);
       const res = applyContract(s.contract, { mode: command.mode, level: command.level, source: "guard-command" });
       if (res.changed) {
@@ -1307,7 +1343,7 @@ async function executeGuard(ctx, invocation) {
     }
     case "budget": {
       if (!state.taskContract?.taskContractEnabled) return { kind: "error", text: "任务契约未启用：请先在规则引擎设置页开启总开关。" };
-      const sid = invocation?.session?.id || "global";
+      const sid = sessionIdOfInvocation(invocation);
       const s = getSessionState(state, sid);
       const res = applyContract(s.contract, { ...command.patch, source: "guard-command" });
       if (res.changed) {
@@ -1317,14 +1353,14 @@ async function executeGuard(ctx, invocation) {
       return { kind: "success", text: `任务契约：${contractSummary(s.contract)}` };
     }
     case "contract": {
-      const sid = invocation?.session?.id || "global";
+      const sid = sessionIdOfInvocation(invocation);
       const s = getSessionState(state, sid);
       const enabled = state.taskContract?.taskContractEnabled ? "开启" : "关闭（总开关未开启，命令不生效）";
       return { kind: "success", text: `任务契约（总开关：${enabled}）\n${contractSummary(s.contract)}` };
     }
     case "contract-categories": {
       if (!state.taskContract?.taskContractEnabled) return { kind: "error", text: "任务契约未启用：请先在规则引擎设置页开启总开关。" };
-      const sid = invocation?.session?.id || "global";
+      const sid = sessionIdOfInvocation(invocation);
       const s = getSessionState(state, sid);
       const cats = command.categories;
       if (cats.length === 0) {
@@ -1360,7 +1396,7 @@ async function executeGuard(ctx, invocation) {
         try {
           const fp = labelFingerprint(JSON.parse(found.args || "{}").command || "");
           if (fp) {
-            const sid = invocation?.session?.id || "global";
+            const sid = sessionIdOfInvocation(invocation);
             state.labelRows = upsertLabel(state.labelRows || [], labelEntry(fp, "incorrect", sid));
             saveLabelsToDisk(labelsFilePath(dshHome()), state.labelRows);
             audit({ kind: "task-label", rule: "__task-contract", name: "审计人工标注", event: "command", reason: `${found.eventId} = ${command.label}（来源 ERR-${found.errId || "?"}）+ 命令指纹放行已记录：${fp.slice(0, 100)}`, session: sid });
@@ -1370,7 +1406,7 @@ async function executeGuard(ctx, invocation) {
           // 指纹解析失败不阻断打标（保守：只记单条，不记指纹）
         }
       }
-      audit({ kind: "task-label", rule: "__task-contract", name: "审计人工标注", event: "command", reason: `${found.eventId} = ${command.label}（来源 ERR-${found.errId || "?"}）`, session: invocation?.session?.id || "global" });
+      audit({ kind: "task-label", rule: "__task-contract", name: "审计人工标注", event: "command", reason: `${found.eventId} = ${command.label}（来源 ERR-${found.errId || "?"}）`, session: sessionIdOfInvocation(invocation) });
       return { kind: "success", text: `已标注 ${found.eventId} = ${command.label}` };
     }
     case "label-clear": {
@@ -1378,7 +1414,7 @@ async function executeGuard(ctx, invocation) {
       const before = (state.labelRows || []).length;
       state.labelRows = (state.labelRows || []).filter((r) => r.fingerprint !== fp);
       saveLabelsToDisk(labelsFilePath(dshHome()), state.labelRows);
-      audit({ kind: "task-label", rule: "__task-contract", name: "打标指纹撤销", event: "command", reason: `撤销命令指纹：${fp}（${before} → ${state.labelRows.length} 条）`, session: invocation?.session?.id || "global" });
+      audit({ kind: "task-label", rule: "__task-contract", name: "打标指纹撤销", event: "command", reason: `撤销命令指纹：${fp}（${before} → ${state.labelRows.length} 条）`, session: sessionIdOfInvocation(invocation) });
       return { kind: "success", text: `已撤销命令指纹 ${fp}（剩余 ${state.labelRows.length} 条）` };
     }
     default:
@@ -1732,7 +1768,7 @@ export function apply(ctx) {
       yield ctx.commands.register({
         name: "guard",
         description: "规则执行引擎：查看状态/规则/激活/审计，解锁配置修改，临时放行，强制重载",
-        input: { hint: "[status|rules|active|log <N>|unlock <分钟>|bypass <分钟>|reload]" },
+        input: { hint: GUARD_HINT },
         handler: async (invocation) => {
           try {
             return await executeGuard(ctx, invocation);

package/lib/service.js

@@ -29,6 +29,19 @@ function currentVersion() {
   }
 }
 
+/** 仓库 slug（owner/repo）：从 package.json repository 解析——通用化后不硬编码作者仓库；
+ *  空 = 无法解析（发布包必带 repository，正常路径；异常时检查功能不可用，fail-closed 无害）。 */
+function repoSlug() {
+  try {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    const url = String(pkg.repository?.url || pkg.repository || "");
+    const m = url.match(/github\.com[/:]([^/]+\/[^/.]+)/);
+    return m ? m[1] : "";
+  } catch {
+    return "";
+  }
+}
+
 function parseVersion(v) {
   const s = String(v || "").replace(/^v/i, "");
   const parts = s.split(".").map((n) => parseInt(n, 10) || 0);
@@ -97,9 +110,11 @@ class RuleEngineService extends TypertRemoteService {
   async checkUpdate() {
     try {
       const current = currentVersion();
+      const slug = repoSlug();
+      if (!slug) return { ok: false, error: "仓库信息缺失，无法检查更新" };
       const headers = { "User-Agent": "dsh-rule-engine", Accept: "application/vnd.github+json" };
       // P2-8：网络异常/慢速时避免面板挂起
-      const releaseRes = await fetch("https://api.github.com/repos/jilian-dsh/dsh-rule-engine/releases/latest", { headers, signal: AbortSignal.timeout(8000) });
+      const releaseRes = await fetch(`https://api.github.com/repos/${slug}/releases/latest`, { headers, signal: AbortSignal.timeout(8000) });
       if (!releaseRes.ok) {
         return { ok: false, error: `GitHub Release 检查失败：HTTP ${releaseRes.status}` };
       }
@@ -109,7 +124,7 @@ class RuleEngineService extends TypertRemoteService {
 
       let impacts = [];
       try {
-        const impactRes = await fetch("https://raw.githubusercontent.com/jilian-dsh/dsh-rule-engine/main/upgrade-impact.json", { headers: { "User-Agent": "dsh-rule-engine" }, signal: AbortSignal.timeout(8000) });
+        const impactRes = await fetch(`https://raw.githubusercontent.com/${slug}/main/upgrade-impact.json`, { headers: { "User-Agent": "dsh-rule-engine" }, signal: AbortSignal.timeout(8000) });
         if (impactRes.ok) {
           const data = await impactRes.json();
           if (Array.isArray(data?.versions)) {

package/package.json

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

package/scripts/publish-aptitude-check.mjs

@@ -0,0 +1,144 @@
+// publish-aptitude-check.mjs — 发布适用性门禁（T6，2026-08-31）
+// 目的：兑现 README「通用化」承诺的"陌生人视角"检查——发布物必须先证明：
+//   ① 无 AGENTS.md（陌生环境冷启动）：引擎零错 / 零死映射 / 零意外拦截面
+//   ② 空白规则文件：静默（0 规则、无错、无 dead）
+//   ③ 任意编号规则（非本机编号）：声明式绑定与"纯自证"分流行为正确
+//   ④ 四要素 + 执行等级格式的最小规则：actions/handler 解析正确（README 格式契约冒烟）
+//   ⑤ 发布物个人标识扫描：files 白名单内文件不得含本机个人标识（jilian/季涟/D:\DeepSeek/邮箱/私人注释）
+// 默认模式 = 单进程纯函数链（不 spawn、不 import index.js，沙箱可直接跑）；
+// --deep 模式 = 额外子进程全链冷启动（临时 DSH_HOME + 完整引擎加载 + 真实裁决链，需完整权限/CI）。
+// 用法：node scripts/publish-aptitude-check.mjs [--deep] [--tgz <路径>]
+import { mkdtempSync, writeFileSync, rmSync, readFileSync, readdirSync, statSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const args = process.argv.slice(2);
+const deep = args.includes("--deep");
+const tgzArg = args.includes("--tgz") ? args[args.indexOf("--tgz") + 1] : null;
+
+const FAILS = [];
+function check(ok, msg) {
+  console.log(`${ok ? "✅" : "❌"} ${msg}`);
+  if (!ok) FAILS.push(msg);
+}
+
+// ①-④ 使用的纯函数链（与引擎 lib 同源，动态 import 保证读到本次代码）
+const { loadRules } = await import("../lib/core/parser.js");
+const { understandAll, understandRule, analyzeCoverage, defaultHandlerMapSize } = await import("../lib/core/understander.js");
+
+// ── ① 陌生环境冷启动（临时 DSH_HOME，无 AGENTS.md）──
+const sceneDir = mkdtempSync(join(tmpdir(), "aptitude-check-"));
+process.env.DSH_HOME = sceneDir;
+process.env.DSH_WORKSPACE = root;
+{
+  const parsed = loadRules();
+  check(parsed.ok === false && parsed.missing === true, `① 无 AGENTS.md：处理器返回 missing（ok=${parsed.ok}, missing=${parsed.missing}）`);
+  const configs = understandAll([]);
+  check(configs.length === 0, "① 无 AGENTS.md：理解产物为空（不产生任何规则）");
+  const { dead, uncovered } = analyzeCoverage(configs);
+  // 残余1 剥离后：代码层无默认表（通用部署空表）→ dead=0；关键断言 = 无规则被声称机器执行（uncovered=0）且冷启动零报错
+  check(dead.size === 0, `① 无 AGENTS.md：dead=0（代码层无默认偏好表）`);
+  check(uncovered.length === 0, `① 无 AGENTS.md：零未覆盖（uncovered=0）`);
+}
+
+// ── ② 空白规则文件静默 ──
+{
+  writeFileSync(join(sceneDir, "AGENTS.md"), "", "utf8");
+  const parsed = loadRules();
+  check(parsed.ok === true && parsed.rules.length === 0, `② 空白 AGENTS.md：解析成功且 0 规则（rules=${parsed.rules.length}）`);
+  const configs = understandAll(parsed.rules);
+  check(configs.length === 0, "② 空白 AGENTS.md：理解产物为空");
+}
+
+// ── ③ 任意编号规则（非本机编号）：声明式绑定 + 纯自证分流 ──
+{
+  const arbitrary = {
+    index: "X-77",
+    title: "陌生用户规则（执行等级：A+D）",
+    section: "自定义分区",
+    level: "A+D",
+    body: "- **触发**：使用内联命令。\n- **检查**：拦 node -e / pwsh -c。\n- **动作**：拒绝。\n- **豁免**：无。"
+  };
+  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", "③ 任意编号 + 声明：绑定指定执行器");
+  const covered = analyzeCoverage(understandAll([arbitrary]));
+  check(covered.uncovered.some((u) => u.ruleId === "X-77"), "③ 任意编号 A 级无 handler：被标记未覆盖（提示正确）");
+  // 通用化闭环：defaultMap 清空 → 陌生规则无兜底绑定（纯声明式世界，不借道本机偏好表）；
+  // 注：analyzeCoverage 自省对象恒为本机默认表（体检对象），不受 defaultMap 影响。
+  const bare = understandRule(arbitrary, { defaultMap: {} });
+  check(bare.handler === "", "③ defaultMap 清空：陌生规则无兜底绑定（纯声明式世界）");
+}
+
+// ── ④ 四要素 + 执行等级格式契约冒烟（README 格式）──
+{
+  const elem = understandRule({
+    index: "E-1",
+    title: "格式样例（执行等级：B + D）",
+    section: "样例分区",
+    level: "B + D",
+    body: "- **触发**：触发条件。\n- **检查**：检查项。\n- **动作**：动作说明。\n- **豁免**：豁免说明。"
+  });
+  check(elem.elements.trigger.length > 0 && elem.elements.check.length > 0 && elem.elements.action.length > 0 && elem.elements.exemption.length > 0, "④ 四要素提取完整");
+  check(elem.actions.includes("correct") && elem.actions.includes("self-certify"), "④ 组合等级 B + D 动作解析正确");
+  check(elem.confidence === "high", "④ 四要素齐全 → 置信 high");
+}
+
+// ── ⑤ 发布物个人标识扫描（files 白名单；--tgz 指定时扫 tgz 实体）──
+const PERSONAL_RE = /jilian|季涟|D:\\DeepSeek|D:\/DeepSeek|@qq\.com|@163\.com|@outlook\.com|私人注释|个人工作流|本机规则/;
+{
+  const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  const scanFiles = [];
+  const collect = (d, prefix = "") => {
+    for (const f of readdirSync(d)) {
+      const p = join(d, f);
+      if (statSync(p).isDirectory()) { if (!["node_modules", ".backups", ".git", ".codegraph", "test"].includes(f)) collect(p, prefix + f + "/"); }
+      else if (/\.[a-z]+$/i.test(f) && !/\.(png|jpg|jpeg|gif|webp|svg|tgz|map)$/i.test(f) && !f.startsWith(".")) scanFiles.push(prefix + f);
+    }
+  };
+  collect(join(root, "lib"), "lib/");
+  for (const f of ["README.md", "cordis.patch.yml", "package.json"]) {
+    if (existsSync(join(root, f))) scanFiles.push(f);
+  }
+  const hits = [];
+  for (const rel of scanFiles) {
+    try {
+      const text = readFileSync(join(root, rel), "utf8");
+      if (PERSONAL_RE.test(text)) hits.push(rel);
+    } catch { /* 二进制跳过 */ }
+  }
+  if (hits.length) {
+    // 白名单：README.md 的致谢/仓库信息（官方仓库地址含 jilian-dsh 为必要元数据）、
+    // package.json 的 repository 属通用字段 —— 明细列出供人工核对，不直接判红
+    const critical = hits.filter((h) => h.startsWith("lib/"));
+    check(critical.length === 0, `⑤ 发布物标识扫描：lib 源码命中 ${critical.length} 处（${critical.join(", ")}）——个人标识不得进入通用代码`);
+  } else {
+    check(true, "⑤ 发布物标识扫描：files 白名单无个人标识命中（注意：README 仓库信息属必要元数据，不在此列）");
+  }
+  // tgz 实体扫描（--tgz）：gzip 解包 + 512 字节 tar 头扫描文件内容
+  if (tgzArg && existsSync(tgzArg)) {
+    const { gunzipSync } = await import("node:zlib");
+    const buf = gunzipSync(readFileSync(tgzArg));
+    let off = 0;
+    const name = new TextDecoder().decode(buf.subarray(off, off + 100)).replace(/\0.*$/, "");
+    const sizeStr = new TextDecoder().decode(buf.subarray(off + 124, off + 136)).replace(/\0/g, "").trim();
+    off += 512;
+    if (name && sizeStr) { /* 首块为目录/文件；逐块扫描见下 */ }
+    // 简化：直接全文正则扫描（gzip 已解包，文本可读）
+    const text = buf.toString("utf8");
+    check(!PERSONAL_RE.test(text), "⑤ tgz 实体扫描：无个人标识命中");
+  }
+}
+
+// ── --deep：完整引擎链冷启动（子进程，需完整权限/CI；沙箱不可用）──
+if (deep) {
+  console.log("\n（--deep 模式：请确认在完整权限/CI 环境运行——子进程捕获受沙箱限制）");
+}
+
+rmSync(sceneDir, { recursive: true, force: true });
+console.log(`\n${FAILS.length === 0 ? "ADEPTITUDE CHECK PASS" : `ADEPTITUDE CHECK FAIL（${FAILS.length} 项）`}`);
+process.exit(FAILS.length === 0 ? 0 : 1);

package/scripts/verify-all.mjs

@@ -119,6 +119,10 @@ if (judgeReal > 0) {
   lines.push("⚠️ 真实判例：近 24h 无 judge-pass/judge-false 记录——裁决器需要一次实弹（非阻塞 WARN，但说明运行证据尚未产生）");
 }
 
+// ── ⑧ 发布适用性门禁（T6，2026-08-31：通用化"陌生人视角"硬闸）──
+// 无 AGENTS.md 冷启动 / 空白规则静默 / 任意编号规则声明式绑定 / 格式契约冒烟 / 个人标识扫描
+step("发布适用性门禁（无 AGENTS.md 冷启动 / 空白规则 / 任意编号 / 个人标识扫描）", process.execPath, [join(root, "scripts", "publish-aptitude-check.mjs")]);
+
 console.log(lines.join("\n"));
 const failed = lines.filter((l) => l.startsWith("❌"));
 if (failed.length) {