progmune-runtime 3.7.63 → 3.7.64

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## [3.7.64] — 2026-10-10
+
+### 守卫沿调用链传播（修冤枉第五刀：授权族告警的「守卫在 controller 层」根因）
+
+**根因**：docmost 补标注 111 条授权族告警全 FP，其中 49 条（44%）是
+service/repo 层函数被误报「未认证/无归属检查」——守卫其实写在
+controller 层的 @UseGuards(JwtAuthGuard) 上，名字级检测器看不见。
+
+- **机制**：`computeGuardPropagatedSet`（protocol-detector.ts）——
+  「函数的**全部**调用方都已守卫 ⇒ 该函数视为守卫后」，守卫沿调用链
+  向下传播 ≤3 跳，只认 `__progmune_auth_machinery__` 一个标记通道
+  （E2 已在带 @UseGuards 装饰器的函数上注入）
+- **保守判据（R1-R4，fail-safe）**：全部调用方已守卫才豁免（任一
+  未守卫→照报）；裸名调用分层消歧——后缀唯一→同文件→同目录→类根
+  对齐（XController→XService→XRepo 惯例），唯一才解析、歧义给全部
+  候选挂未解析边；调用方自身排除（controller.create 调 "create" 时
+  同文件层自我捕获的坑）
+- **标记而非静默丢弃（R9）**：被压告警进 `overall.safeguardAlerts.
+  suppressed` 独立清单（带 suppressedByGuardPropagation 标记），
+  **不进 total/groups/topRanked 主计数**但完整保留可复核；
+  豁免仅作用于 authorization 类规则、且不作用于自身直接带标记的
+  函数（R5/R6，维持 E2 既有语义）
+- **同条件 A/B（docmost 双扫描）**：主告警流 865→748（−117 =
+  Unauthenticated Access 46 + Ownership Check 36 + Unauthenticated
+  Mutation 31 + Resource Ownership 4），suppressed 清单 117 条全带
+  标记，748+117=865 证据一条不少；**主路径 violations 9=9 /
+  score 85=85 完全一致**
+- **可压名单交叉核对**：117 条中 25 条在 174 标注队列（14 同规则
+  FP + 11 同函数不同规则 FP）；92 条未标注的逐条列调用链复核——全部
+  由直接守卫 controller 或传播守卫 service 调用（附件
+  blind-benchmark/auth-guard-crosscheck.ts 可复跑）
+- **回归锁定**：单元测试 12 例（protocol-detector-guard-propagation
+  .test.ts：全调用方守卫/歧义 fail-safe/同文件/同目录/类根消歧/深度
+  限制/自定义标记/种子语义）+ 引擎产品路径 2 例（tests/trust/engine
+  .test.ts：守卫后进 suppressed 不进主计数 + 无守卫对照组照常上报）；
+  引擎套件 25/25；TS 盲测零漂移（注：batch-scan 不经过引擎告警循环，
+  此门对本改动是空过——真实门=引擎测试+docmost A/B，如实记录）
+- 工具入册：`blind-benchmark/auth-guard-propagation-probe.ts`（量化
+  探针）+ `auth-guard-crosscheck.ts`（标注交叉核对）
+
 ## [3.7.63] — 2026-10-10
 
 ### No Input Sanitization 触发词收窄（修冤枉第四刀：删 insert/append/write 通用词）

package/dist/protocol-detector-guard-propagation.test.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const protocol_detector_1 = require("./protocol-detector");
+/**
+ * 守卫传播（修冤枉第五刀，2026-10-10）单元测试。
+ *
+ * 保守判据（R1-R4，fail-safe 方向）：全部调用方已守卫才豁免、
+ * ≤3 跳、只认 __progmune_auth_machinery__ 标记、歧义调用按未守卫处理。
+ * 消费方（engine）负责 R5/R6：只压 authorization 类、且不压直接标记函数。
+ */
+const M = "__progmune_auth_machinery__";
+(0, vitest_1.describe)("computeGuardPropagatedSet（守卫传播保守判据）", () => {
+    (0, vitest_1.it)("全部调用方已守卫 ⇒ 传播（controller→service）", () => {
+        const fns = [
+            { name: "PageController.create", file: "a.ts", calls: [M, "createPage"] },
+            { name: "PageService.createPage", file: "b.ts", calls: ["insertPage"] },
+            { name: "PageRepo.insertPage", file: "c.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageService.createPage")).toBe(true);
+    });
+    (0, vitest_1.it)("传递两跳（controller→service→repo）", () => {
+        const fns = [
+            { name: "PageController.create", file: "a.ts", calls: [M, "createPage"] },
+            { name: "PageService.createPage", file: "b.ts", calls: ["insertPage"] },
+            { name: "PageRepo.insertPage", file: "c.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageRepo.insertPage")).toBe(true);
+    });
+    (0, vitest_1.it)("任一调用方未守卫 ⇒ 不豁免（fail-safe）", () => {
+        const fns = [
+            { name: "PageController.create", file: "a.ts", calls: [M, "createPage"] },
+            { name: "ImportProcessor.run", file: "q.ts", calls: ["createPage"] },
+            { name: "PageService.createPage", file: "b.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageService.createPage")).toBe(false);
+    });
+    (0, vitest_1.it)("无调用方（入口函数）⇒ 不豁免", () => {
+        const fns = [{ name: "bootstrap", file: "m.ts", calls: [] }];
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("bootstrap")).toBe(false);
+    });
+    (0, vitest_1.it)("同名多处定义 ⇒ 歧义 fail-safe ⇒ 不豁免", () => {
+        const fns = [
+            { name: "AController.do", file: "a.ts", calls: [M, "update"] },
+            { name: "UserRepo.update", file: "r1.ts", calls: [] },
+            { name: "SpaceRepo.update", file: "r2.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+        // "update" 有两个候选，调用方 AController.do 的调用无法唯一解析
+        (0, vitest_1.expect)(g.has("UserRepo.update")).toBe(false);
+        (0, vitest_1.expect)(g.has("SpaceRepo.update")).toBe(false);
+    });
+    (0, vitest_1.it)("歧义时同文件唯一候选 ⇒ 消歧成立", () => {
+        const fns = [
+            { name: "AController.do", file: "a.ts", calls: [M, "update"] },
+            // UserRepo.update 与调用方同文件（helpers 场景）
+            { name: "UserRepo.update", file: "a.ts", calls: [] },
+            { name: "SpaceRepo.update", file: "r2.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("UserRepo.update")).toBe(true);
+        (0, vitest_1.expect)(g.has("SpaceRepo.update")).toBe(false);
+    });
+    (0, vitest_1.it)("歧义时同目录唯一候选 ⇒ 消歧成立", () => {
+        const fns = [
+            { name: "AController.do", file: "d1/x.ts", calls: [M, "update"] },
+            { name: "UserRepo.update", file: "d1/y.ts", calls: [] },
+            { name: "SpaceRepo.update", file: "d2/z.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("UserRepo.update")).toBe(true);
+        (0, vitest_1.expect)(g.has("SpaceRepo.update")).toBe(false);
+    });
+    (0, vitest_1.it)("歧义时类根对齐唯一候选 ⇒ 消歧成立（MVC 命名惯例）", () => {
+        const fns = [
+            { name: "PageController.create", file: "c/page.controller.ts", calls: [M, "create"] },
+            { name: "PageService.create", file: "s/page.service.ts", calls: [] },
+            { name: "SpaceService.create", file: "s/space.service.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageService.create")).toBe(true);
+        (0, vitest_1.expect)(g.has("SpaceService.create")).toBe(false);
+    });
+    (0, vitest_1.it)("类根不唯一 ⇒ 保持 fail-safe", () => {
+        const fns = [
+            { name: "PageController.create", file: "c.ts", calls: [M, "create"] },
+            { name: "PageService.create", file: "s1.ts", calls: [] },
+            { name: "PageRepo.create", file: "r1.ts", calls: [] },
+        ];
+        // 类根 "Page" 命中两个候选（Service+Repo）⇒ 不唯一 ⇒ 不解析
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageService.create")).toBe(false);
+        (0, vitest_1.expect)(g.has("PageRepo.create")).toBe(false);
+    });
+    (0, vitest_1.it)("深度限制：第 4 跳不传播", () => {
+        const fns = [
+            { name: "C0", file: "f.ts", calls: [M, "C1"] },
+            { name: "C1", file: "f.ts", calls: ["C2"] },
+            { name: "C2", file: "f.ts", calls: ["C3"] },
+            { name: "C3", file: "f.ts", calls: ["C4"] },
+            { name: "C4", file: "f.ts", calls: [] },
+        ];
+        // C1 = 跳1, C2 = 跳2, C3 = 跳3, C4 = 跳4（maxDepth=3 传播 3 轮：C1,C2,C3）
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns, { maxDepth: 3 });
+        (0, vitest_1.expect)(g.has("C1")).toBe(true);
+        (0, vitest_1.expect)(g.has("C2")).toBe(true);
+        (0, vitest_1.expect)(g.has("C3")).toBe(true);
+        (0, vitest_1.expect)(g.has("C4")).toBe(false);
+    });
+    (0, vitest_1.it)("自定义标记通道", () => {
+        const fns = [
+            { name: "A", file: "f.ts", calls: ["__custom_mark__", "B"] },
+            { name: "B", file: "f.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns, { marker: "__custom_mark__" });
+        (0, vitest_1.expect)(g.has("B")).toBe(true);
+        // 默认标记下不传播
+        const g2 = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+        (0, vitest_1.expect)(g2.has("B")).toBe(false);
+    });
+    (0, vitest_1.it)("直接标记函数在返回集合中（种子语义，R6 由消费方过滤）", () => {
+        const fns = [{ name: "AController.do", file: "a.ts", calls: [M] }];
+        const g = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("AController.do")).toBe(true);
+    });
+});

package/dist/protocol-detector.js

@@ -14,6 +14,7 @@ exports.isAuthFunctionName = isAuthFunctionName;
 exports.classifyParamType = classifyParamType;
 exports.detectSafeguardViolations = detectSafeguardViolations;
 exports.buildCallerMap = buildCallerMap;
+exports.computeGuardPropagatedSet = computeGuardPropagatedSet;
 exports.detectSafeguardViolationsV7 = detectSafeguardViolationsV7;
 exports.detectProtocolViolations = detectProtocolViolations;
 exports.validateProtocolState = validateProtocolState;
@@ -1623,6 +1624,130 @@ function buildCallerMap(funcs) {
     }
     return callerMap;
 }
+/**
+ * 修冤枉第五刀（2026-10-10）：守卫沿调用链传播——
+ * 授权族告警的「守卫在 controller 层、名字级看不见」根因的保守豁免。
+ *
+ * 语义：「函数的**全部**直接调用方都已守卫 ⇒ 该函数视为守卫后」。
+ * 证据：docmost 补标注 111 条授权族告警全 FP，其中 49 条（44%）是
+ * controller 已 @UseGuards、service/repo 层函数被误报。保守量化
+ * （blind-benchmark/auth-guard-propagation-probe.ts）：
+ *   docmost 745 条授权族告警可压 47 条（6.3%），TS 盲测可压 0 条。
+ *
+ * 保守规则（R1-R4，fail-safe 方向）：
+ *   R1 只有【全部】调用方已守卫才豁免；任一调用方无守卫证据 → 照报
+ *   R2 守卫沿调用链向下传播 ≤ maxDepth（默认 3）跳
+ *   R3 传播通道只认 `marker`（默认 __progmune_auth_machinery__）一个标记
+ *   R4 裸名调用解析分层消歧（唯一才解析，否则给全部候选挂未解析边）：
+ *      ① 名字后缀唯一 ② 同文件唯一 ③ 同目录唯一
+ *      ④ 类根对齐唯一（调用方 XController/Service → 候选类根同为 X）
+ *   R6 豁免只给【非直接标记】函数——自身带标记的维持既有 E2 语义
+ *      （只接受标记的规则由 detector 自身处理；不接受标记的规则照报）
+ *
+ * 返回集合含直接标记函数本身（消费方须自行应用 R6 过滤），
+ * 因为传递闭包的种子就是它们。
+ */
+function computeGuardPropagatedSet(funcs, opts) {
+    const marker = opts?.marker ?? "__progmune_auth_machinery__";
+    const maxDepth = opts?.maxDepth ?? 3;
+    const byName = new Map();
+    for (const f of funcs)
+        if (!byName.has(f.name))
+            byName.set(f.name, f);
+    // 后缀索引：裸名 → 候选全限定名（>1 ⇒ 歧义）
+    const bySuffix = new Map();
+    for (const f of funcs) {
+        const bare = f.name.split(".").pop() || f.name;
+        if (!bySuffix.has(bare))
+            bySuffix.set(bare, []);
+        bySuffix.get(bare).push(f.name);
+    }
+    // 反向调用图：被调【全限定名】→ 调用方列表（resolved=false = 歧义 fail-safe）。
+    // 边解析分层消歧（R4）：① 后缀唯一 ② 同文件唯一 ③ 同目录唯一
+    // ④ 类根对齐唯一（XController→XService→XRepo 的 MVC 命名惯例）；
+    // 全部失败 ⇒ 给全部同名候选挂未解析边（fail-safe）。
+    const dirOf = (p) => (p ? p.split("/").slice(0, -1).join("/") : "");
+    const rootOf = (n) => {
+        const cls = n.split(".")[0] || n;
+        return cls.replace(/(Controller|Service|Repo|Repository|Listener|Processor|Handler|Extension|Util|Utils|Helper|Driver|Provider)$/, "");
+    };
+    const calleeToCallers = new Map();
+    for (const f of funcs) {
+        for (const c of f.calls || []) {
+            if (!bySuffix.has(c))
+                continue; // 非项目函数名（外部库调用）→ 无守卫语义
+            // 排除调用方自身：controller.create 调 "create" 时，自己就是后缀
+            // 候选之一，同文件/同目录层会错误自我捕获（递归/自调不提供守卫证据）
+            const cands = bySuffix.get(c).filter((n) => n !== f.name);
+            if (cands.length === 0)
+                continue;
+            let targets = null;
+            if (cands.length === 1) {
+                targets = cands;
+            }
+            else {
+                const sameFile = cands.filter((n) => {
+                    const g = byName.get(n);
+                    return g && g.file && f.file && g.file === f.file;
+                });
+                if (sameFile.length === 1)
+                    targets = sameFile;
+                else {
+                    const sameDir = cands.filter((n) => {
+                        const g = byName.get(n);
+                        return g && g.file && f.file && dirOf(g.file) === dirOf(f.file);
+                    });
+                    if (sameDir.length === 1)
+                        targets = sameDir;
+                    else {
+                        const rootMatch = cands.filter((n) => rootOf(n) === rootOf(f.name));
+                        if (rootMatch.length === 1)
+                            targets = rootMatch;
+                    }
+                }
+            }
+            if (targets === null) {
+                for (const n of cands) {
+                    if (!calleeToCallers.has(n))
+                        calleeToCallers.set(n, []);
+                    calleeToCallers.get(n).push({ caller: f.name, resolved: false });
+                }
+            }
+            else {
+                for (const n of targets) {
+                    if (!calleeToCallers.has(n))
+                        calleeToCallers.set(n, []);
+                    calleeToCallers.get(n).push({ caller: f.name, resolved: true });
+                }
+            }
+        }
+    }
+    // 种子：直接带标记的函数
+    const guarded = new Set();
+    for (const f of funcs)
+        if ((f.calls || []).includes(marker))
+            guarded.add(f.name);
+    // 不动点传播（≤ maxDepth 轮）：被调方全部调用方已守卫 ⇒ 已守卫。
+    // 快照语义：每轮基于【轮初】守卫集计算、轮末统一应用——
+    // 轮内级联会让深度失去意义（同轮后半段函数借前半段的新增一步到位）。
+    for (let round = 0; round < maxDepth; round++) {
+        const toAdd = [];
+        for (const f of funcs) {
+            if (guarded.has(f.name))
+                continue;
+            const callers = calleeToCallers.get(f.name) || [];
+            if (callers.length === 0)
+                continue; // 无调用方（入口/未连通）→ 不豁免
+            if (callers.every((c) => c.resolved && guarded.has(c.caller)))
+                toAdd.push(f.name);
+        }
+        if (toAdd.length === 0)
+            break;
+        for (const n of toAdd)
+            guarded.add(n);
+    }
+    return guarded;
+}
 /**
  * v7: Build safeguard context — own → same-file → caller chain.
  *

package/dist/sdk.js

@@ -20,7 +20,7 @@ const risk_model_1 = require("./risk-model");
 const protocol_knowledge_1 = require("./protocol-knowledge");
 const evidence_repository_1 = require("./evidence-repository");
 /** Runtime version — stable public identifier. Internal layers evolve underneath. */
-exports.RUNTIME_VERSION = "3.7.63";
+exports.RUNTIME_VERSION = "3.7.64";
 function verify(filePath) {
     const cert = (0, certify_1.certify)(filePath);
     const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();

package/dist/trust/engine.js

@@ -1496,7 +1496,14 @@ async function collectProtocolViolations(ctx, callGraph) {
                 // 不改 decision/score——排序告警是给人工审查的入口（§49.16：
                 // 排序不删告警，一条不少；groupAlerts 分组防整族沉底）。
                 const safeguardAlertsRaw = [];
+                const safeguardAlertsSuppressed = [];
                 const svLang = ctx.language || "typescript";
+                // 修冤枉第五刀（2026-10-10）：守卫传播豁免——授权族告警的
+                // 「守卫在 controller 层」根因。保守判据见
+                // computeGuardPropagatedSet（R1-R4）：全部调用方已守卫才豁免、
+                // ≤3 跳、歧义 fail-safe。豁免仅作用于 authorization 类规则
+                // 且函数自身不直接带标记（R5/R6）——标记而非静默丢弃。
+                const guardPropagated = (0, protocol_detector_1.computeGuardPropagatedSet)(functions);
                 for (const f of functions) {
                     const fCalls = f.calls || [];
                     let svs;
@@ -1509,21 +1516,31 @@ async function collectProtocolViolations(ctx, callGraph) {
                     if (svs.length === 0)
                         continue;
                     const params = (f.params || []).map((p) => ({ n: p.name, t: p.type || "" }));
+                    const directlyMarked = fCalls.includes("__progmune_auth_machinery__");
+                    const guardExempt = !directlyMarked && guardPropagated.has(f.name);
                     for (const v of svs) {
-                        safeguardAlertsRaw.push({
+                        const alert = {
                             rule: v.rule,
                             file: f.file,
                             function: f.name,
                             calls: fCalls,
                             nRules: svs.length,
                             params,
-                        });
+                        };
+                        if (guardExempt && v.category === "authorization") {
+                            alert.suppressedByGuardPropagation = true;
+                            safeguardAlertsSuppressed.push(alert);
+                        }
+                        else {
+                            safeguardAlertsRaw.push(alert);
+                        }
                     }
                 }
                 safeguardAlerts = {
                     total: safeguardAlertsRaw.length,
                     groups: (0, alert_ranker_1.groupAlerts)(safeguardAlertsRaw),
                     topRanked: (0, alert_ranker_1.rankAlerts)(safeguardAlertsRaw, { minPerRule: 1 }),
+                    suppressed: safeguardAlertsSuppressed,
                 };
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "progmune-runtime",
-  "version": "3.7.63",
+  "version": "3.7.64",
   "description": "Progmune — AI Trust Decision Engine. Verify AI-generated code before it reaches production. Outputs APPROVED / NEEDS_REVIEW / BLOCKED with evidence.",
   "files": [
     "dist/",