progmune-runtime 3.7.67 → 3.7.68

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Changelog
 
+## [3.7.68] — 2026-10-16
+
+### 调用方混合并集豁免（修冤枉第九刀）
+
+**根因**：第五刀（全部调用方已守卫）与第七刀（全部调用方是作业）
+各留下边界：① 守卫传播 ≤3 跳，第 4 跳的服务层函数（如
+ExportService.getWorkspaceBaseUrl）在守卫集外；② 第七刀 B 判据是
+**裸名族级**保守——同名族任一成员被 HTTP 面调用则全族不豁免，
+族内「只被作业调用」的成员（如 VerificationNotificationService.
+getPageContext，同为 getPageContext 裸名的 Page 族成员被 controller
+调用）被连坐照报。两者语义上都没有未鉴权请求面：每条到达 F 的
+路径要么已过守卫、要么源起作业处理器。
+
+- **判据（computeMixedSurfacePropagatedSet）**：函数 F 的每个直接
+  调用方都 ∈ {已守卫传播集} ∪ {作业面传播集} ⇒ 豁免。保守规则：
+  R1 调用方集合非空（HTTP 入口无项目调用方，永不豁免）；R2 每条
+  调用边必须可解析（与第五刀共享 computeResolvedCallerMap 分层消歧，
+  歧义 fail-safe）；R3 任一调用方在并集外 → 照报；R4 快照轮次语义，
+  默认 1 轮（传递闭包留数据驱动）；R5 返回集合只含并集新增成员
+- **引擎接线**：豁免仅 authorization 类、函数自身不直接带标记
+  （R5/R6）；被压告警进 `safeguardAlerts.suppressed` 带
+  `suppressedByMixedSurfacePropagation` 标记（标记而非丢弃，R9）；
+  `PROGMUNE_MIXED_SURFACE_TOGGLE=off` 逃生门
+- **同条件 A/B（docmost，各 fresh IR）**：主告警流 685→669
+  （−16 = Access 13 + Mutation 2 + Ownership 1，消失清单与离线重放
+  预测逐条一致、新增 0）；**control（toggle off）685/140 与 3.7.67
+  基线逐条一致**；主路径 violations 11=11 / score 84=84 /
+  NEEDS_REVIEW 不变；suppressed 140→156（156=117 守卫 +23 作业
+  +16 混合，669+156=825 证据守恒）
+- **FN 风险逐条复核**：16 条全核调用方来源——3 条守卫类
+  （@UseGuards(JwtAuthGuard) 导出路由 → export 工具函数，守卫传播
+  第 4 跳）；13 条作业类（@Processor 队列 → 通知/历史服务方法 →
+  下游 getter/写入，B 判据族级连坐的成员）。TP 0
+- **C4/C5 主力类探针结论（knife9-mixed-surface-probe）**：
+  repo-update 类 137 / getter 类 213 中，无调用方（HTTP 入口）62/92、
+  歧义边 50/70、并集外调用方 23/42——「公开设计端点/可达但非
+  鉴权敏感」是语义问题，调用方面传播已到边界（守卫深度敏感性：
+  maxDepth 3→6 仅 +6 条）
+- **回归锁定**：单测 11 例（protocol-detector-mixed-surface.test.ts，
+  含与第七刀族级保守的差异用例）+ 引擎产品路径 2 + 检测器族
+  199/199 + 引擎 239/239；三闸门（taintpath 160 / webshape 72 /
+  fr-007 pre5-post0 + fr-016 pre7-post0）；**TS 盲测 119 项目对
+  3.7.67 提交基线 LOST 0 / ADDED 0**
+
 ## [3.7.67] — 2026-10-12
 
 ### 词撞类豁免（修冤枉第八刀：mutation/access trigger 词段碰撞）

package/dist/protocol-detector-mixed-surface.test.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const protocol_detector_1 = require("./protocol-detector");
+/**
+ * 调用方混合并集豁免（修冤枉第九刀，2026-10-16）单元测试。
+ *
+ * 判据（见 computeMixedSurfacePropagatedSet 注释）：
+ *   函数 F 的每个直接调用方都 ∈ {已守卫传播集} ∪ {作业面传播集} ⇒
+ *   F 无未鉴权请求面（每条到达 F 的路径要么已过守卫、要么源起作业）。
+ * R1-R5：调用方非空 / 边全解析 / 全部落在并集内 / 快照轮次默认 1 /
+ * 返回集合只含并集新增成员。
+ * 消费方（engine）负责 R5/R6：只压 authorization 类、且不压直接标记函数。
+ */
+const MG = "__progmune_auth_machinery__";
+const MJ = "__progmune_no_request_surface__";
+/** 便捷：guard/job 集 + 混合集一并算 */
+function sets(fns, opts) {
+    const guard = (0, protocol_detector_1.computeGuardPropagatedSet)(fns);
+    const job = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+    const mixed = (0, protocol_detector_1.computeMixedSurfacePropagatedSet)(fns, guard, job, opts);
+    return { guard, job, mixed };
+}
+(0, vitest_1.describe)("computeMixedSurfacePropagatedSet（调用方混合并集，第九刀）", () => {
+    (0, vitest_1.it)("混合调用方（已守卫 + 作业）⇒ 豁免", () => {
+        const fns = [
+            { name: "GuardedController.create", file: "c/page.controller.ts", calls: [MG, "log"] },
+            { name: "AuditService.log", file: "s/audit.service.ts", calls: ["fn"] },
+            { name: "DigestJob.run", file: "q/digest.job.ts", calls: [MJ, "fn"] },
+            { name: "MixedTarget.fn", file: "m/target.ts", calls: [] },
+        ];
+        // AuditService.log：全部调用方已守卫 ⇒ 守卫集成员；
+        // MixedTarget.fn 调用方 = {AuditService.log[g], DigestJob.run[j]} ⇒ 混合豁免
+        const { guard, job, mixed } = sets(fns);
+        (0, vitest_1.expect)(guard.has("AuditService.log")).toBe(true);
+        (0, vitest_1.expect)(job.has("DigestJob.run")).toBe(true);
+        (0, vitest_1.expect)(mixed.has("MixedTarget.fn")).toBe(true);
+    });
+    (0, vitest_1.it)("全部调用方已守卫但超过守卫传播深度（第 4 跳）⇒ 并集豁免", () => {
+        const fns = [
+            { name: "AuthRoot", file: "f.ts", calls: [MG, "b"] },
+            { name: "b", file: "f.ts", calls: ["c"] },
+            { name: "c", file: "f.ts", calls: ["d"] },
+            { name: "d", file: "f.ts", calls: ["e"] },
+            { name: "e", file: "f.ts", calls: [] },
+        ];
+        const { guard, mixed } = sets(fns);
+        (0, vitest_1.expect)(guard.has("d")).toBe(true); // 第 3 跳：在守卫集内
+        (0, vitest_1.expect)(guard.has("e")).toBe(false); // 第 4 跳：守卫传播边界外
+        (0, vitest_1.expect)(mixed.has("e")).toBe(true); // 并集判据罩住（调用方 d ∈ 守卫集）
+    });
+    (0, vitest_1.it)("作业调用方与作业面集族级保守的差异：按边解析只豁免作业链成员", () => {
+        // docmost 实测形态：作业处理器与被调方同「类根」（processExpiring
+        // → getPageContext），逐边消歧可解析。B 判据（第七刀）在裸名族含
+        // HTTP 调用方时全族不豁免；并集判据按边解析——只豁免作业链上
+        // 那个成员，HTTP 面成员照报。
+        const fns = [
+            { name: "VerificationNotificationService.processExpiring", file: "s/verification.service.ts", calls: [MJ, "getPageContext"] },
+            { name: "VerificationNotificationService.getPageContext", file: "s/verification.service.ts", calls: [] },
+            { name: "PageNotificationService.getPageContext", file: "s/page.service.ts", calls: [] },
+            { name: "PageNotificationService.notify", file: "s/page.service.ts", calls: ["getPageContext"] }, // 同文件 HTTP 面调用方
+        ];
+        const { job, mixed } = sets(fns);
+        // 第七刀 B 判据：裸名族含非作业调用方 ⇒ 全族不豁免
+        (0, vitest_1.expect)(job.has("VerificationNotificationService.getPageContext")).toBe(false);
+        (0, vitest_1.expect)(job.has("PageNotificationService.getPageContext")).toBe(false);
+        // 第九刀并集：边解析逐条——Verification 成员只被作业调用 ⇒ 豁免；
+        // Page 成员被 notify（并集外）调用 ⇒ 不豁免
+        (0, vitest_1.expect)(mixed.has("VerificationNotificationService.getPageContext")).toBe(true);
+        (0, vitest_1.expect)(mixed.has("PageNotificationService.getPageContext")).toBe(false);
+    });
+    (0, vitest_1.it)("任一调用方在并集外 ⇒ 不豁免（fail-safe）", () => {
+        const fns = [
+            { name: "GuardedController.create", file: "c.ts", calls: [MG, "write"] },
+            { name: "PublicController.import", file: "c2.ts", calls: ["write"] },
+            { name: "write", file: "r.ts", calls: [] },
+        ];
+        const { mixed } = sets(fns);
+        (0, vitest_1.expect)(mixed.has("write")).toBe(false);
+    });
+    (0, vitest_1.it)("无调用方（入口/未连通）⇒ 不豁免（R1）", () => {
+        const fns = [{ name: "orphanEntry", file: "m.ts", calls: [] }];
+        const { mixed } = sets(fns);
+        (0, vitest_1.expect)(mixed.has("orphanEntry")).toBe(false);
+    });
+    (0, vitest_1.it)("歧义调用边 ⇒ 不豁免（R2 fail-safe）", () => {
+        // 同名裸名两个候选、调用方无法消歧（不同文件不同目录不同类根）
+        const fns = [
+            { name: "GuardedController.create", file: "c/ctrl.ts", calls: [MG, "load"] },
+            { name: "XxxService.load", file: "x/x.service.ts", calls: [] },
+            { name: "YyyService.load", file: "y/y.service.ts", calls: [] },
+        ];
+        const { mixed } = sets(fns);
+        (0, vitest_1.expect)(mixed.has("XxxService.load")).toBe(false);
+        (0, vitest_1.expect)(mixed.has("YyyService.load")).toBe(false);
+    });
+    (0, vitest_1.it)("默认 1 轮：并集下游的下游不豁免（传递闭包未开）", () => {
+        const fns = [
+            { name: "Job.run", file: "q.ts", calls: [MJ, "b"] },
+            { name: "b", file: "f.ts", calls: ["c"] },
+            { name: "c", file: "f.ts", calls: ["d"] },
+            { name: "d", file: "f.ts", calls: [] },
+        ];
+        const { job, mixed } = sets(fns);
+        (0, vitest_1.expect)(job.has("b")).toBe(true); // b 已在作业面集（第七刀，第 1 跳）
+        (0, vitest_1.expect)(mixed.has("b")).toBe(false); // R5：既有成员不重复进 mixed
+        (0, vitest_1.expect)(mixed.has("c")).toBe(true); // c 调用方 {b[j]} ⊆ 并集 ⇒ 混合豁免
+        (0, vitest_1.expect)(mixed.has("d")).toBe(false); // d 调用方 {c} 不在并集（1 轮）⇒ 不豁免
+    });
+    (0, vitest_1.it)("maxRounds=2 ⇒ 传递两跳成立（快照轮次语义）", () => {
+        const fns = [
+            { name: "Job.run", file: "q.ts", calls: [MJ, "b"] },
+            { name: "b", file: "f.ts", calls: ["c"] },
+            { name: "c", file: "f.ts", calls: ["d"] },
+            { name: "d", file: "f.ts", calls: [] },
+        ];
+        const { mixed } = sets(fns, { maxRounds: 2 });
+        (0, vitest_1.expect)(mixed.has("c")).toBe(true);
+        (0, vitest_1.expect)(mixed.has("d")).toBe(true); // 第 2 轮：d 调用方 {c} ⊆ 并集∪第 1 轮新增
+    });
+    (0, vitest_1.it)("返回集合只含并集新增成员（R5：种子/既有成员由各自刀处理）", () => {
+        const fns = [
+            { name: "GuardedController.create", file: "c.ts", calls: [MG, "service"] },
+            { name: "Job.run", file: "q.ts", calls: [MJ, "jobOnly"] },
+            { name: "service", file: "s.ts", calls: ["target"] },
+            { name: "jobOnly", file: "s.ts", calls: ["target"] },
+            { name: "target", file: "s.ts", calls: [] },
+        ];
+        const { guard, job, mixed } = sets(fns);
+        // 种子/既有成员（GuardedController.create、Job.run、service、jobOnly）不重复进 mixed
+        (0, vitest_1.expect)(guard.has("service")).toBe(true); // service 全部调用方已守卫 ⇒ 守卫集成员
+        (0, vitest_1.expect)(job.has("jobOnly")).toBe(true); // jobOnly 只被作业调用 ⇒ 作业面成员
+        (0, vitest_1.expect)(mixed.has("GuardedController.create")).toBe(false);
+        (0, vitest_1.expect)(mixed.has("Job.run")).toBe(false);
+        (0, vitest_1.expect)(mixed.has("service")).toBe(false);
+        (0, vitest_1.expect)(mixed.has("jobOnly")).toBe(false);
+        // 新增成员：target 调用方 = {service[g], jobOnly[j]} ⇒ 混合豁免
+        (0, vitest_1.expect)(mixed.has("target")).toBe(true);
+    });
+    (0, vitest_1.it)("自调不提供豁免证据", () => {
+        const fns = [{ name: "CleanupService.cleanup", file: "s.ts", calls: ["cleanup"] }];
+        const { mixed } = sets(fns);
+        (0, vitest_1.expect)(mixed.has("CleanupService.cleanup")).toBe(false);
+    });
+    (0, vitest_1.it)("直接标记函数不进入混合新增集合（自身已是守卫/作业种子）", () => {
+        const fns = [
+            { name: "GuardedController.create", file: "c.ts", calls: [MG, "self2"] },
+            { name: "self2", file: "c.ts", calls: [] },
+        ];
+        const { mixed } = sets(fns);
+        (0, vitest_1.expect)(mixed.has("GuardedController.create")).toBe(false);
+        (0, vitest_1.expect)(mixed.has("self2")).toBe(false); // self2 已在守卫集（第 1 跳）
+    });
+});

package/dist/protocol-detector.js

@@ -14,8 +14,10 @@ exports.isAuthFunctionName = isAuthFunctionName;
 exports.classifyParamType = classifyParamType;
 exports.detectSafeguardViolations = detectSafeguardViolations;
 exports.buildCallerMap = buildCallerMap;
+exports.computeResolvedCallerMap = computeResolvedCallerMap;
 exports.computeGuardPropagatedSet = computeGuardPropagatedSet;
 exports.computeJobSurfacePropagatedSet = computeJobSurfacePropagatedSet;
+exports.computeMixedSurfacePropagatedSet = computeMixedSurfacePropagatedSet;
 exports.detectSafeguardViolationsV7 = detectSafeguardViolationsV7;
 exports.detectProtocolViolations = detectProtocolViolations;
 exports.validateProtocolState = validateProtocolState;
@@ -1643,31 +1645,17 @@ 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 自身处理；不接受标记的规则照报）
+ * 反向调用图（分层消歧，R4）：被调【全限定名】→ 调用方列表
+ * （resolved=false = 歧义 fail-safe）。computeGuardPropagatedSet（第五刀）
+ * 与 computeMixedSurfacePropagatedSet（第九刀）共享同一边解析。
  *
- * 返回集合含直接标记函数本身（消费方须自行应用 R6 过滤），
- * 因为传递闭包的种子就是它们。
+ * 边解析分层消歧（R4）：① 后缀唯一 ② 同文件唯一 ③ 同目录唯一
+ * ④ 类根对齐唯一（XController→XService→XRepo 的 MVC 命名惯例）；
+ * 全部失败 ⇒ 给全部同名候选挂未解析边（fail-safe）。
+ * 调用方自身排除：controller.create 调 "create" 时自己就是后缀候选
+ * 之一，同文件/同目录层会错误自我捕获（递归/自调不提供守卫证据）。
  */
-function computeGuardPropagatedSet(funcs, opts) {
-    const marker = opts?.marker ?? "__progmune_auth_machinery__";
-    const maxDepth = opts?.maxDepth ?? 3;
+function computeResolvedCallerMap(funcs) {
     const byName = new Map();
     for (const f of funcs)
         if (!byName.has(f.name))
@@ -1680,10 +1668,6 @@ function computeGuardPropagatedSet(funcs, opts) {
             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;
@@ -1694,8 +1678,6 @@ function computeGuardPropagatedSet(funcs, opts) {
         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;
@@ -1740,6 +1722,35 @@ function computeGuardPropagatedSet(funcs, opts) {
             }
         }
     }
+    return calleeToCallers;
+}
+/**
+ * 修冤枉第五刀（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 calleeToCallers = computeResolvedCallerMap(funcs);
     // 种子：直接带标记的函数
     const guarded = new Set();
     for (const f of funcs)
@@ -1827,6 +1838,53 @@ function computeJobSurfacePropagatedSet(funcs, opts) {
     }
     return exempt;
 }
+/**
+ * 修冤枉第九刀（2026-10-16）：调用方混合并集豁免——
+ * 「函数的每个直接调用方都 ∈ {已守卫传播集} ∪ {作业面传播集}」。
+ *
+ * 第五刀要求【全部调用方已守卫】，第七刀要求【全部调用方是作业】；
+ * 混合形态（部分调用方是已守卫 controller、部分是无请求面作业）两者都
+ * 覆盖不到，但语义上同样无未鉴权请求面：每条到达 F 的路径要么已过守卫
+ * （guardSet 成员自身及其调用链上方都已守卫），要么源起作业处理器
+ * （jobSet 成员无请求面）。C4 repo 层 update* 语义类与 C5 getter 语义类
+ * 的主力根因就是这种调用方混合（knife8-word-collision-probe 分类结论）。
+ *
+ * 保守规则（与第五刀共享边解析，见 computeResolvedCallerMap R4）：
+ *   R1 调用方集合非空——入口函数（HTTP 面）无项目调用方，永不豁免
+ *   R2 每条调用边都必须可解析（resolved=true），歧义 fail-safe
+ *   R3 调用方必须 ∈ guardSet ∪ jobSet；任一调用方不在此并集 → 照报
+ *   R4 快照轮次语义（与第五刀一致）；默认 1 轮（只豁免直接混合下游；
+ *      传递闭包留数据驱动再开，与第七刀同决策）
+ *   R5 返回集合只含并集【新增】成员——guardSet/jobSet 成员由各自刀处理
+ *
+ * guardSet/jobSet 由调用方传入（engine 处与第五/七刀同源：
+ * computeGuardPropagatedSet / computeJobSurfacePropagatedSet 的返回值）。
+ */
+function computeMixedSurfacePropagatedSet(funcs, guardSet, jobSet, opts) {
+    const maxRounds = opts?.maxRounds ?? 1;
+    const calleeToCallers = computeResolvedCallerMap(funcs);
+    const base = new Set([...guardSet, ...jobSet]);
+    const mixed = new Set(); // R5：只记本轮新增
+    for (let round = 0; round < maxRounds; round++) {
+        const toAdd = [];
+        for (const f of funcs) {
+            if (base.has(f.name))
+                continue;
+            const callers = calleeToCallers.get(f.name) || [];
+            if (callers.length === 0)
+                continue; // R1：无调用方（入口/未连通）→ 不豁免
+            if (callers.every((c) => c.resolved && base.has(c.caller)))
+                toAdd.push(f.name);
+        }
+        if (toAdd.length === 0)
+            break;
+        for (const n of toAdd) {
+            base.add(n);
+            mixed.add(n);
+        }
+    }
+    return mixed;
+}
 /**
  * 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.67";
+exports.RUNTIME_VERSION = "3.7.68";
 function verify(filePath) {
     const cert = (0, certify_1.certify)(filePath);
     const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();

package/dist/trust/engine.js

@@ -1512,6 +1512,14 @@ async function collectProtocolViolations(ctx, callGraph) {
                 const jobSurfacePropagated = process.env.PROGMUNE_JOB_SURFACE_TOGGLE === "off"
                     ? new Set()
                     : (0, protocol_detector_1.computeJobSurfacePropagatedSet)(functions);
+                // 修冤枉第九刀（2026-10-16）：调用方混合并集豁免——「每个直接
+                // 调用方都 ∈ {已守卫传播集} ∪ {作业面传播集}」⇒ 无未鉴权请求面。
+                // 保守判据见 computeMixedSurfacePropagatedSet（R1-R5）：调用方
+                // 非空、边全解析、默认 1 轮。豁免仅作用于 authorization 类且
+                // 函数自身不直接带标记（R5/R6）——与第五/七刀同：标记而非丢弃。
+                const mixedSurfacePropagated = process.env.PROGMUNE_MIXED_SURFACE_TOGGLE === "off"
+                    ? new Set()
+                    : (0, protocol_detector_1.computeMixedSurfacePropagatedSet)(functions, guardPropagated, jobSurfacePropagated);
                 for (const f of functions) {
                     const fCalls = f.calls || [];
                     let svs;
@@ -1528,6 +1536,7 @@ async function collectProtocolViolations(ctx, callGraph) {
                     const directlyJobMarked = fCalls.includes("__progmune_no_request_surface__");
                     const guardExempt = !directlyMarked && guardPropagated.has(f.name);
                     const jobExempt = !directlyJobMarked && jobSurfacePropagated.has(f.name);
+                    const mixedExempt = !directlyMarked && !directlyJobMarked && mixedSurfacePropagated.has(f.name);
                     for (const v of svs) {
                         const alert = {
                             rule: v.rule,
@@ -1547,6 +1556,10 @@ async function collectProtocolViolations(ctx, callGraph) {
                                 alert.suppressedByJobSurfacePropagation = true;
                                 suppressed = true;
                             }
+                            if (mixedExempt) {
+                                alert.suppressedByMixedSurfacePropagation = true;
+                                suppressed = true;
+                            }
                             if (suppressed) {
                                 safeguardAlertsSuppressed.push(alert);
                                 continue;

package/package.json

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