progmune-runtime 3.7.65 → 3.7.66

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## [3.7.66] — 2026-10-12
+
+### 队列作业调用方传播（修冤枉第七刀：授权族告警的「只被作业调用的函数没有请求面」根因）
+
+**根因**：第六刀（3.7.65）只豁免了作业处理器**自身**——docmost 残留
+告警中 service/repo 层函数只被 @Processor/@Interval 作业调用（鉴权
+发生在入队侧 controller，队列下游函数体不面向 HTTP 请求），授权族
+「缺鉴权/缺属主校验」的提问在它们身上同样不适用。
+
+- **机制**：`computeJobSurfacePropagatedSet`（protocol-detector.ts，
+  与第五刀镜像但判据不同）——**B 判据：调用方裸名并集**。凡调用名
+  裸化后等于 F 裸名的函数都是「可能调用方」；并集非空且**全部**
+  已豁免（种子 = 第六刀的 `__progmune_no_request_surface__` 标记）
+  ⇒ F 豁免。裸化只增候选（限定形态调用名也进并集）⇒ 真实调用方
+  必在并集中（R75 正向证据）。**歧义下比第五刀更保守**：同名族
+  任一成员被非作业调用，整个裸名族都不豁免（逐边消歧在作业链
+  Processor→XxxService 上恒失败——docmost 实测只剩同文件层 4 条）
+- **快照轮次语义**，默认 1 轮（只豁免直接作业下游；传递闭包
+  docmost 实测 +16 条但豁免集 120→173，留作数据驱动再开）；
+  `PROGMUNE_JOB_SURFACE_TOGGLE=off` 环境变量逃生门
+- **标记而非静默丢弃（R9）**：被压告警进 `overall.safeguardAlerts.
+  suppressed` 清单（带 suppressedByJobSurfacePropagation 标记），
+  不进 total/groups/topRanked 主计数；豁免仅作用于 authorization
+  类、且不作用于自身直接带标记的函数（R5/R6）
+- **同条件 A/B（docmost 双扫描，fresh IR）**：主告警流 720→697
+  （−23 = Unauthenticated Access 14 + Ownership Check 5 +
+  Unauthenticated Mutation 4），suppressed 117→140（+23 全带标记）；
+  **主路径 violations 11=11 内容级零差 / score 84=84 / NEEDS_REVIEW
+  不变**；control（toggle off）= 720/117 与 3.7.65 基线告警集逐位
+  一致 ⇒ 压降完全归因本刀
+- **23 条被压逐条核对**（blind-benchmark/verify-job-surface-66.ts）：
+  调用方并集全部为 @Processor 作业（NotificationProcessor.process /
+  onCompleted / handleFailedImportJob）或 @Interval 清理作业
+  （cleanupOldTrash / cleanupSessions），TP 0；同名族保守性独立复核
+  通过（无任何被压函数存在非作业调用方）
+- **回归锁定**：单元测试 11 例（protocol-detector-job-surface.test.ts：
+  全作业传播/同名裸名多候选并集豁免（第五刀此处会阻断）/同名族保守/
+  混合调用方 fail-safe/无调用方/1 轮边界/maxHops/自调无豁免证据/
+  限定调用名裸化/种子语义/自定义标记）+ 引擎产品路径 2 例
+  （tests/trust/engine.test.ts：作业下游进 suppressed 不进主计数 +
+  HTTP 对照组照常上报）；引擎套件 27/27；
+  taintpath 160 / webshape 72 / fr-007 5-0 / fr-016 7-0 维持；
+  TS 盲测 LOST 0 / ADDED 0（对 3.7.65 提交基线逐旗标一致；
+  batch-scan 不经过引擎告警循环，此门对本改动空过，
+  真实门 = docmost A/B + 定向测试，如实记录）
+
 ## [3.7.65] — 2026-10-11
 
 ### 队列/定时/事件处理器无请求面豁免（修冤枉第六刀：授权族告警的「作业处理器不是请求面」根因）

package/dist/protocol-detector-job-surface-propagation.test.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const protocol_detector_1 = require("./protocol-detector");
+/**
+ * 队列作业调用方传播（修冤枉第七刀，2026-10-11）单元测试。
+ *
+ * B 判据（与第五刀逐边消歧镜像，但判据不同）：调用方**裸名并集**——
+ * 凡调用名等于 F 裸名的函数都是「可能调用方」；并集非空且全部已豁免
+ * （种子 = 带 __progmune_no_request_surface__ 标记的作业处理器）
+ * ⇒ F 豁免。歧义下比逐边消歧更保守：同名族任一成员被非作业调用，
+ * 整个裸名族都不豁免。快照轮次语义；默认 1 轮。
+ * 消费方（engine）负责 R5/R6：只压 authorization 类、且不压直接标记函数。
+ */
+const M = "__progmune_no_request_surface__";
+(0, vitest_1.describe)("computeJobSurfacePropagatedSet（作业调用方传播 B 判据）", () => {
+    (0, vitest_1.it)("全部调用方都是作业 ⇒ 传播（processor→service）", () => {
+        const fns = [
+            { name: "NotificationProcessor.process", file: "q.ts", calls: [M, "processPageUpdate"] },
+            { name: "PageNotificationService.processPageUpdate", file: "s.ts", calls: ["insertLog"] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageNotificationService.processPageUpdate")).toBe(true);
+    });
+    (0, vitest_1.it)("调用方含 HTTP 面 ⇒ 不豁免（fail-safe）", () => {
+        const fns = [
+            { name: "NotificationProcessor.process", file: "q.ts", calls: [M, "processPageUpdate"] },
+            { name: "PageController.getPage", file: "c.ts", calls: ["processPageUpdate"] },
+            { name: "PageNotificationService.processPageUpdate", file: "s.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageNotificationService.processPageUpdate")).toBe(false);
+    });
+    (0, vitest_1.it)("无调用方（入口函数）⇒ 不豁免", () => {
+        const fns = [{ name: "bootstrap", file: "m.ts", calls: [] }];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("bootstrap")).toBe(false);
+    });
+    (0, vitest_1.it)("默认 1 轮：只豁免作业直接下游，不传递闭包", () => {
+        const fns = [
+            { name: "Job.run", file: "q.ts", calls: [M, "step1"] },
+            { name: "Svc.step1", file: "s.ts", calls: ["step2"] },
+            { name: "Repo.step2", file: "r.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("Svc.step1")).toBe(true);
+        (0, vitest_1.expect)(g.has("Repo.step2")).toBe(false);
+    });
+    (0, vitest_1.it)("maxHops=2 时传递两跳", () => {
+        const fns = [
+            { name: "Job.run", file: "q.ts", calls: [M, "step1"] },
+            { name: "Svc.step1", file: "s.ts", calls: ["step2"] },
+            { name: "Repo.step2", file: "r.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns, { maxHops: 2 });
+        (0, vitest_1.expect)(g.has("Svc.step1")).toBe(true);
+        (0, vitest_1.expect)(g.has("Repo.step2")).toBe(true);
+    });
+    (0, vitest_1.it)("同名族保守：任一成员被非作业调用，整个裸名族都不豁免", () => {
+        const fns = [
+            { name: "Job.run", file: "q.ts", calls: [M, "create"] },
+            { name: "PageService.create", file: "s.ts", calls: [] },
+            { name: "CommentService.create", file: "c2.ts", calls: [] },
+            { name: "PageController.post", file: "c.ts", calls: ["create"] },
+        ];
+        // create 裸名族含 CommentService.create——PageController.post（非作业）
+        // 也在调用方并集中 ⇒ 族级不豁免，即使 Job.run 只调 PageService.create
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageService.create")).toBe(false);
+        (0, vitest_1.expect)(g.has("CommentService.create")).toBe(false);
+    });
+    (0, vitest_1.it)("限定形态调用名（Class.method）按裸名命中", () => {
+        const fns = [
+            { name: "Job.run", file: "q.ts", calls: [M, "PageService.processUpdate"] },
+            { name: "PageService.processUpdate", file: "s.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageService.processUpdate")).toBe(true);
+    });
+    (0, vitest_1.it)("直接标记函数在返回集合中（种子语义，R6 由消费方过滤）", () => {
+        const fns = [{ name: "Job.run", file: "q.ts", calls: [M] }];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("Job.run")).toBe(true);
+    });
+    (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.computeJobSurfacePropagatedSet)(fns, { marker: "__custom_mark__" });
+        (0, vitest_1.expect)(g.has("B")).toBe(true);
+        // 默认标记下不传播
+        const g2 = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g2.has("B")).toBe(false);
+    });
+});

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const protocol_detector_1 = require("./protocol-detector");
+/**
+ * 作业调用方传播（修冤枉第七刀，2026-10-11）单元测试。
+ *
+ * B 判据（裸名并集，见 computeJobSurfacePropagatedSet 注释）：
+ *   函数的调用方并集（调用名=裸名的所有函数）非空且全部带
+ *   __progmune_no_request_surface__ 标记 ⇒ 豁免；默认 1 轮。
+ * 正确性前提：IR 调用名即裸名 ⇒ 真实调用方必在并集中 ⇒
+ *   并集全作业蕴含真实调用方全作业（R75 正向证据）。
+ * 与第五刀的差别：歧义不阻断——同名族任一成员被非作业调用，
+ *   整个裸名族都不豁免（比逐边消歧更保守的族级行为）。
+ * 消费方（engine）负责 R5/R6：只压 authorization 类、且不压直接标记函数。
+ */
+const M = "__progmune_no_request_surface__";
+(0, vitest_1.describe)("computeJobSurfacePropagatedSet（作业调用方传播，B 判据）", () => {
+    (0, vitest_1.it)("全部调用方是作业 ⇒ 传播（Processor→Service）", () => {
+        const fns = [
+            { name: "NotificationProcessor.process", file: "q/notification.processor.ts", calls: [M, "processPageUpdate"] },
+            { name: "PageNotificationService.processPageUpdate", file: "s/page-notification.service.ts", calls: ["insertNotification"] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageNotificationService.processPageUpdate")).toBe(true);
+    });
+    (0, vitest_1.it)("同名裸名多候选且调用方全作业 ⇒ 并集判据豁免（第五刀此处会阻断）", () => {
+        // processDigest 裸名有两个定义；调用方是两个不同的作业
+        // 处理器。逐边消歧（第五刀）会挂未解析边阻断；并集判据
+        // 检查「所有可能调用方全作业」⇒ 豁免。
+        const fns = [
+            { name: "EmailProcessor.process", file: "q/email.processor.ts", calls: [M, "processDigest"] },
+            { name: "DigestProcessor.process", file: "q/digest.processor.ts", calls: [M, "processDigest"] },
+            { name: "PageNotificationService.processDigest", file: "s/page.service.ts", calls: [] },
+            { name: "CommentNotificationService.processDigest", file: "s/comment.service.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageNotificationService.processDigest")).toBe(true);
+        (0, vitest_1.expect)(g.has("CommentNotificationService.processDigest")).toBe(true);
+    });
+    (0, vitest_1.it)("同名族任一成员被非作业调用 ⇒ 整个裸名族不豁免（保守族级）", () => {
+        const fns = [
+            { name: "EmailProcessor.process", file: "q.ts", calls: [M, "processDigest"] },
+            { name: "PageController.show", file: "c.ts", calls: ["processDigest"] },
+            { name: "PageNotificationService.processDigest", file: "s1.ts", calls: [] },
+            { name: "CommentNotificationService.processDigest", file: "s2.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageNotificationService.processDigest")).toBe(false);
+        (0, vitest_1.expect)(g.has("CommentNotificationService.processDigest")).toBe(false);
+    });
+    (0, vitest_1.it)("调用方含非作业 ⇒ 不豁免（fail-safe）", () => {
+        const fns = [
+            { name: "EmailProcessor.process", file: "q.ts", calls: [M, "markAsEmailed"] },
+            { name: "NotificationService.markAsEmailedDirect", file: "s.ts", calls: ["markAsEmailed"] },
+            { name: "NotificationRepo.markAsEmailed", file: "r.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("NotificationRepo.markAsEmailed")).toBe(false);
+    });
+    (0, vitest_1.it)("无调用方（入口/未连通）⇒ 不豁免", () => {
+        const fns = [
+            { name: "orphanJobHelper", file: "m.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("orphanJobHelper")).toBe(false);
+    });
+    (0, vitest_1.it)("默认 1 轮：作业下游的下游不豁免（传递闭包未开）", () => {
+        const fns = [
+            { name: "NotificationProcessor.process", file: "q.ts", calls: [M, "processPageUpdate"] },
+            { name: "PageNotificationService.processPageUpdate", file: "s.ts", calls: ["insertNotification"] },
+            { name: "NotificationRepo.insertNotification", file: "r.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageNotificationService.processPageUpdate")).toBe(true);
+        (0, vitest_1.expect)(g.has("NotificationRepo.insertNotification")).toBe(false);
+    });
+    (0, vitest_1.it)("maxHops=2 ⇒ 传递两跳成立（快照轮次语义）", () => {
+        const fns = [
+            { name: "NotificationProcessor.process", file: "q.ts", calls: [M, "processPageUpdate"] },
+            { name: "PageNotificationService.processPageUpdate", file: "s.ts", calls: ["insertNotification"] },
+            { name: "NotificationRepo.insertNotification", file: "r.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns, { maxHops: 2 });
+        (0, vitest_1.expect)(g.has("NotificationRepo.insertNotification")).toBe(true);
+    });
+    (0, vitest_1.it)("自调不提供豁免证据（自己不是作业 ⇒ 不能靠自调豁免）", () => {
+        const fns = [
+            { name: "CleanupService.cleanup", file: "s.ts", calls: ["cleanup"] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("CleanupService.cleanup")).toBe(false);
+    });
+    (0, vitest_1.it)("限定形态调用名（Class.method）按裸名命中（裸化只增候选，保守方向）", () => {
+        const fns = [
+            { name: "Job.run", file: "q.ts", calls: [M, "PageService.processUpdate"] },
+            { name: "PageService.processUpdate", file: "s.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("PageService.processUpdate")).toBe(true);
+    });
+    (0, vitest_1.it)("直接标记函数在返回集合中（种子语义，R6 由消费方过滤）", () => {
+        const fns = [{ name: "Job.run", file: "q.ts", calls: [M] }];
+        const g = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g.has("Job.run")).toBe(true);
+    });
+    (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.computeJobSurfacePropagatedSet)(fns, { marker: "__custom_mark__" });
+        (0, vitest_1.expect)(g.has("B")).toBe(true);
+        // 默认标记下不传播
+        const g2 = (0, protocol_detector_1.computeJobSurfacePropagatedSet)(fns);
+        (0, vitest_1.expect)(g2.has("B")).toBe(false);
+    });
+});

package/dist/protocol-detector.js

@@ -15,6 +15,7 @@ exports.classifyParamType = classifyParamType;
 exports.detectSafeguardViolations = detectSafeguardViolations;
 exports.buildCallerMap = buildCallerMap;
 exports.computeGuardPropagatedSet = computeGuardPropagatedSet;
+exports.computeJobSurfacePropagatedSet = computeJobSurfacePropagatedSet;
 exports.detectSafeguardViolationsV7 = detectSafeguardViolationsV7;
 exports.detectProtocolViolations = detectProtocolViolations;
 exports.validateProtocolState = validateProtocolState;
@@ -1753,6 +1754,67 @@ function computeGuardPropagatedSet(funcs, opts) {
     }
     return guarded;
 }
+/**
+ * 修冤枉第七刀（2026-10-11）：队列作业调用方传播 ——「函数只被作业调用
+ * ⇒ 无请求面」。与 computeGuardPropagatedSet（第五刀）镜像，但判据不同：
+ *
+ * 第五刀对被调名做逐边分层消歧（后缀唯一→同文件→同目录→类根），歧义
+ * fail-safe 挂未解析边 ⇒ 任何歧义阻断豁免。而作业链（Processor→XxxService）
+ * 跨目录、类根不同名，分层消歧恒失败——docmost 实测第七刀若沿用该框架
+ * 只剩同文件层 4 条（预测压掉 4/600）。
+ *
+ * 本判据（B 判据）：调用方**裸名并集**——凡调用名裸化后等于 F 裸名的函数
+ * 都是「可能调用方」；并集非空且全部已豁免 ⇒ F 豁免。正确性：裸化只增
+ * 候选（限定形态调用名也被收进并集）⇒ 真实调用方必在并集中 ⇒ 并集全作业
+ * 蕴含真实调用方全作业（R75 正向证据）。歧义下比逐边消歧更保守：同名族
+ * 任一成员被非作业调用，整个裸名族都不豁免。
+ * 快照轮次语义与第五刀一致；默认 1 轮（只豁免直接作业下游；传递闭包
+ * docmost 实测 +16 条告警命中但豁免集从 120 膨胀到 173，留作数据驱动再开）。
+ */
+function computeJobSurfacePropagatedSet(funcs, opts) {
+    const marker = opts?.marker ?? "__progmune_no_request_surface__";
+    const maxHops = opts?.maxHops ?? 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);
+    }
+    const callersByBare = new Map();
+    for (const f of funcs) {
+        for (const c of f.calls || []) {
+            const bareC = c.split(".").pop() || c; // 裸化：限定形态调用名也进并集（只增候选，保守方向）
+            if (!bySuffix.has(bareC))
+                continue; // 非项目函数名 → 无豁免语义
+            if (!callersByBare.has(bareC))
+                callersByBare.set(bareC, new Set());
+            callersByBare.get(bareC).add(f.name);
+        }
+    }
+    const exempt = new Set();
+    for (const f of funcs)
+        if ((f.calls || []).includes(marker))
+            exempt.add(f.name);
+    for (let round = 0; round < maxHops; round++) {
+        const toAdd = [];
+        for (const f of funcs) {
+            if (exempt.has(f.name))
+                continue;
+            const bare = f.name.split(".").pop() || f.name;
+            const callers = callersByBare.get(bare);
+            if (!callers || callers.size === 0)
+                continue; // 无调用方 → 不豁免
+            if ([...callers].every((c) => exempt.has(c)))
+                toAdd.push(f.name);
+        }
+        if (toAdd.length === 0)
+            break;
+        for (const n of toAdd)
+            exempt.add(n);
+    }
+    return exempt;
+}
 /**
  * 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.65";
+exports.RUNTIME_VERSION = "3.7.66";
 function verify(filePath) {
     const cert = (0, certify_1.certify)(filePath);
     const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();

package/dist/trust/engine.js

@@ -1504,6 +1504,14 @@ async function collectProtocolViolations(ctx, callGraph) {
                 // ≤3 跳、歧义 fail-safe。豁免仅作用于 authorization 类规则
                 // 且函数自身不直接带标记（R5/R6）——标记而非静默丢弃。
                 const guardPropagated = (0, protocol_detector_1.computeGuardPropagatedSet)(functions);
+                // 修冤枉第七刀（2026-10-11）：队列作业调用方传播——「函数只被
+                // 作业/定时/事件处理器调用 ⇒ 无请求面」。B 判据（裸名并集，见
+                // computeJobSurfacePropagatedSet）：并集非空且全部已豁免才豁免，
+                // 默认 1 轮。豁免仅作用于 authorization 类且函数自身不直接带
+                // 标记（R5/R6）——与第五刀同：标记而非静默丢弃。
+                const jobSurfacePropagated = process.env.PROGMUNE_JOB_SURFACE_TOGGLE === "off"
+                    ? new Set()
+                    : (0, protocol_detector_1.computeJobSurfacePropagatedSet)(functions);
                 for (const f of functions) {
                     const fCalls = f.calls || [];
                     let svs;
@@ -1517,7 +1525,9 @@ async function collectProtocolViolations(ctx, callGraph) {
                         continue;
                     const params = (f.params || []).map((p) => ({ n: p.name, t: p.type || "" }));
                     const directlyMarked = fCalls.includes("__progmune_auth_machinery__");
+                    const directlyJobMarked = fCalls.includes("__progmune_no_request_surface__");
                     const guardExempt = !directlyMarked && guardPropagated.has(f.name);
+                    const jobExempt = !directlyJobMarked && jobSurfacePropagated.has(f.name);
                     for (const v of svs) {
                         const alert = {
                             rule: v.rule,
@@ -1527,13 +1537,22 @@ async function collectProtocolViolations(ctx, callGraph) {
                             nRules: svs.length,
                             params,
                         };
-                        if (guardExempt && v.category === "authorization") {
-                            alert.suppressedByGuardPropagation = true;
-                            safeguardAlertsSuppressed.push(alert);
-                        }
-                        else {
-                            safeguardAlertsRaw.push(alert);
+                        if (v.category === "authorization") {
+                            let suppressed = false;
+                            if (guardExempt) {
+                                alert.suppressedByGuardPropagation = true;
+                                suppressed = true;
+                            }
+                            if (jobExempt) {
+                                alert.suppressedByJobSurfacePropagation = true;
+                                suppressed = true;
+                            }
+                            if (suppressed) {
+                                safeguardAlertsSuppressed.push(alert);
+                                continue;
+                            }
                         }
+                        safeguardAlertsRaw.push(alert);
                     }
                 }
                 safeguardAlerts = {

package/package.json

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