progmune-runtime 3.7.64 → 3.7.66

package/CHANGELOG.md

@@ -1,5 +1,87 @@
 # 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
+
+### 队列/定时/事件处理器无请求面豁免（修冤枉第六刀：授权族告警的「作业处理器不是请求面」根因）
+
+**根因**：docmost 补标注里队列作业/定时任务类 FP 占授权族 FP 的
+10/111——鉴权发生在入队侧（controller 把任务塞进队列时已鉴权），
+BullMQ 处理器 / NestJS Schedule / EventEmitter 监听器的函数体
+不面向 HTTP 请求，「缺鉴权/缺属主校验」的提问在处理器层不适用。
+
+- **机制**：提取器注入 `__progmune_no_request_surface__` 标记——
+  类级 `@Processor(队列名)`（BullMQ，该类全部方法）、方法级
+  `@Interval/@Cron/@Timeout/@OnEvent`（须带实参）；规则侧仅授权族
+  四条（Unauthenticated Access/Mutation + Ownership Check + Resource
+  Ownership）在 safeguard 位接受该标记（与 E2 同款「只做减法」）
+- **反例挡住（是请求面，不注入）**：@Sse（HTTP SSE）、
+  @SubscribeMessage（WebSocket）、@MessagePattern/@EventPattern
+  （微服务 RPC）；`@Processor()` 空实参不是 BullMQ 形态不注入
+- **同条件 A/B（docmost 双扫描，fresh IR 各自重提）**：主告警流
+  748→720（−28 = Ownership Check 10 + Unauthenticated Access 9 +
+  Unauthenticated Mutation 9），**主路径 violations 11=11 内容级零差 /
+  score 84=84 / suppressed 117=117**；注入关对照 = 748 与 3.7.64 时代
+  基线一致 ⇒ 压降完全归因本刀，非扫描间抖动
+- **可压名单交叉核对**：28 条被压告警逐条列函数/文件，全部命中
+  @Processor（FileTask/Notification/History/GeneralQueue ×4 类）或
+  @Interval（cleanupSessions/cleanupOldTrash/sendTelemetry）或
+  @OnEvent（Page/Space/Workspace Listener）形态，TP 0
+- **回归锁定**：提取器测试 4 例（类级全方法/方法级四种/反例四种/
+  空实参边界）+ 规则侧测试 5 例（四族抑制 + 非授权族不受影响）；
+  TS 盲测 119 项目零漂移（LOST 0/ADDED 0——generated 语料无装饰器
+  形状，此门对本改动是空过，真实门=docmost A/B + 定向测试，如实记录）
+- **⚠ 过程教训（TSError 型 toggle）**：上一会话用 `return [];` 做
+  A/B 开关——unreachable 代码中 TS 控制流分析不执行收窄，`name`
+  保持 `string | undefined` 编译失败，对照扫描 0 字节静默中断两轮。
+  toggle 必须用环境变量分支，且对照扫描前必须删 ir.json（IR-STALE
+  复用含标记缓存会让「对照」跑在注入开的数据上）
+
 ## [3.7.64] — 2026-10-10
 
 ### 守卫沿调用链传播（修冤枉第五刀：授权族告警的「守卫在 controller 层」根因）

package/dist/extract-ir-no-request-surface.test.js

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const extract_ir_1 = require("./extract-ir");
+/**
+ * 修冤枉第六刀（2026-10-10）：队列/定时/事件处理器 → 无请求面标记锁定。
+ *
+ * 数据：docmost 补标注 111 条授权族 FP 里 10 条是队列作业/定时任务——
+ * 鉴权发生在入队侧，处理器函数不面向 HTTP 请求，授权族规则按「请求面
+ * 缺鉴权」提问时结论不适用。
+ *
+ * 注入形态：@Processor(队列名) 类级（BullMQ，全方法）；
+ * @Interval/@Cron/@Timeout/@OnEvent 方法级（须带实参）。
+ * 反例（是请求面，不注入）：@Sse / @SubscribeMessage / @MessagePattern。
+ */
+const MARK = "__progmune_no_request_surface__";
+const TSCONFIG = JSON.stringify({
+    compilerOptions: { target: "ES2020", module: "commonjs", strict: false, skipLibCheck: true, noEmit: true },
+    include: ["**/*.ts"],
+});
+function makeProject(files) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pm-nosurface-"));
+    fs.writeFileSync(path.join(dir, "tsconfig.json"), TSCONFIG);
+    fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: "fixture", version: "0.0.0", private: true }));
+    for (const [rel, body] of Object.entries(files)) {
+        const abs = path.join(dir, rel);
+        fs.mkdirSync(path.dirname(abs), { recursive: true });
+        fs.writeFileSync(abs, body);
+    }
+    return dir;
+}
+function callsOf(dir, fnName) {
+    const fns = (0, extract_ir_1.extractIR)(dir);
+    const f = fns.find((x) => x.name === fnName);
+    return f ? (f.calls ?? []) : [];
+}
+(0, vitest_1.describe)("extractIR：无请求面标记（修冤枉第六刀）", () => {
+    (0, vitest_1.it)("@Processor(队列名) 类级 ⇒ 全部方法注入", () => {
+        const dir = makeProject({
+            "a.ts": `
+declare const Processor: any;
+@Processor("notification-queue")
+export class NotificationProcessor {
+  process() { this.markAsEmailed(); }
+  onCompleted() {}
+}
+`,
+        });
+        (0, vitest_1.expect)(callsOf(dir, "NotificationProcessor.process")).toContain(MARK);
+        (0, vitest_1.expect)(callsOf(dir, "NotificationProcessor.onCompleted")).toContain(MARK);
+    });
+    (0, vitest_1.it)("@Interval/@Cron/@Timeout/@OnEvent 方法级 ⇒ 仅该方法注入", () => {
+        const dir = makeProject({
+            "a.ts": `
+declare const Interval: any; declare const Cron: any; declare const Timeout: any; declare const OnEvent: any;
+export class SessionService {
+  @Interval("session-cleanup", 86400000)
+  cleanupSessions() {}
+  @Cron("0 0 * * *")
+  dailyJob() {}
+  @Timeout(5000)
+  delayedJob() {}
+  @OnEvent("user.created")
+  onUserCreated() {}
+  normalMethod() {}
+}
+`,
+        });
+        for (const fn of ["SessionService.cleanupSessions", "SessionService.dailyJob", "SessionService.delayedJob", "SessionService.onUserCreated"]) {
+            (0, vitest_1.expect)(callsOf(dir, fn)).toContain(MARK);
+        }
+        (0, vitest_1.expect)(callsOf(dir, "SessionService.normalMethod")).not.toContain(MARK);
+    });
+    (0, vitest_1.it)("反例：@Sse/@SubscribeMessage/@MessagePattern/@EventPattern 是请求面，不注入", () => {
+        const dir = makeProject({
+            "a.ts": `
+declare const Sse: any; declare const SubscribeMessage: any; declare const MessagePattern: any; declare const EventPattern: any;
+export class Gateway {
+  @Sse("events")
+  events() {}
+  @SubscribeMessage("chat")
+  onMessage() {}
+  @MessagePattern("orders.get")
+  getOrder() {}
+  @EventPattern("orders.created")
+  onOrderCreated() {}
+}
+`,
+        });
+        for (const fn of ["Gateway.events", "Gateway.onMessage", "Gateway.getOrder", "Gateway.onOrderCreated"]) {
+            (0, vitest_1.expect)(callsOf(dir, fn)).not.toContain(MARK);
+        }
+    });
+    (0, vitest_1.it)("边界：@Processor() 空实参不注入（非 BullMQ 形态）", () => {
+        const dir = makeProject({
+            "a.ts": `
+declare const Processor: any;
+@Processor()
+export class Odd {
+  run() {}
+}
+`,
+        });
+        (0, vitest_1.expect)(callsOf(dir, "Odd.run")).not.toContain(MARK);
+    });
+});

package/dist/extract-ir.js

@@ -462,6 +462,44 @@ function authMachineryFromDecorators(decorators) {
     return auth && !skip ? [AUTH_MACHINERY_MARKER] : [];
 }
 // ═══════════════════════════════════════════════════════════════
+// 修冤枉第六刀（2026-10-10）：队列/定时/事件处理器 → 无请求面标记
+//
+// 数据：docmost 补标注 111 条授权族 FP 里 10 条是队列作业/定时任务——
+// 鉴权发生在入队侧（controller 层），处理器函数本身不面向 HTTP 请求，
+// 授权族规则按「请求面缺鉴权」提问时结论不适用。
+// 当前流量化：44 个队列/定时函数命中 19 条授权族告警（全 FP 类）。
+//
+// 形态：@Processor(队列名) 类级（BullMQ，该类全部方法都是作业）；
+// @Interval/@Cron/@Timeout 方法级（NestJS Schedule）；
+// @OnEvent 方法级（NestJS EventEmitter2）。
+// ⚠ 反例（是请求面，不注入）：@Sse（HTTP SSE）、@SubscribeMessage
+//   （WebSocket 消息）、@MessagePattern/@EventPattern（微服务 RPC）。
+// ═══════════════════════════════════════════════════════════════
+const NO_REQUEST_SURFACE_MARKER = "__progmune_no_request_surface__";
+/** 队列/定时/事件装饰器 —— 出现即注入无请求面标记（须带实参：@Interval('name', ms) 等） */
+const NO_SURFACE_CLASS_DECORATOR = /^Processor$/i;
+const NO_SURFACE_METHOD_DECORATOR = /^(?:Interval|Cron|Timeout|OnEvent)$/i;
+/**
+ * 由类/方法装饰器判定是否注入无请求面标记（与 authMachineryFromDecorators 同款文本匹配）。
+ * @returns [] 或 [NO_REQUEST_SURFACE_MARKER]
+ */
+function noRequestSurfaceFromDecorators(decorators) {
+    let noSurface = false;
+    for (const d of decorators) {
+        const text = (d?.getText?.() ?? "").trim();
+        const name = /^@([A-Za-z_$][\w$]*)/.exec(text)?.[1];
+        if (!name)
+            continue;
+        if (!NO_SURFACE_CLASS_DECORATOR.test(name) && !NO_SURFACE_METHOD_DECORATOR.test(name))
+            continue;
+        // 须带实参（@Processor() 空参不是 BullMQ 形态；@Interval 必带名字+毫秒）
+        if (!/^@[\w$]*\([^)]+\)/.test(text))
+            continue;
+        noSurface = true;
+    }
+    return noSurface ? [NO_REQUEST_SURFACE_MARKER] : [];
+}
+// ═══════════════════════════════════════════════════════════════
 // E3（2026-09-22）：TS 侧「入参已按 schema 校验」语义标记
 //
 // 判据（先抄准再写 expect，R22）：
@@ -3256,6 +3294,15 @@ function _extractSingleProject(absRoot, tsconfigPath) {
                     if (!mCalls.includes(mk))
                         mCalls.push(mk);
                 }
+                // 修冤枉第六刀：队列/定时/事件处理器 → 无请求面标记（与 E2 并列，
+                // 语义相反——E2 是「有鉴权」，本标记是「鉴权问题不适用」）
+                for (const mk of noRequestSurfaceFromDecorators([
+                    ...(cls.getDecorators?.() ?? []),
+                    ...(m.getDecorators?.() ?? []),
+                ])) {
+                    if (!mCalls.includes(mk))
+                        mCalls.push(mk);
+                }
                 funcs.push({
                     name: `${cn}.${mn}`,
                     params: mParams.map((p) => ({ name: p.getName(), type: getParamType(p), typeDetail: getParamTypeDetail(p) })),

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-no-request-surface.test.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const protocol_detector_1 = require("./protocol-detector");
+/**
+ * 修冤枉第六刀（2026-10-10）：无请求面标记的规则侧接受位锁定。
+ *
+ * 语义：队列/定时/事件处理器不面向 HTTP 请求，鉴权发生在入队侧——
+ * 授权族四条的「缺鉴权/缺属主校验」提问在处理器层不适用（N/A 抑制）。
+ * 只抑制 authorization 类；其他族规则不受标记影响。
+ */
+const M = "__progmune_no_request_surface__";
+const has = (vs, rule) => vs.some((v) => v.rule === rule);
+(0, vitest_1.describe)("no_request_surface 标记：授权族四条接受、其他族不受影响", () => {
+    const calls = ["getWorkspaceUrl", M];
+    (0, vitest_1.it)("Unauthenticated Access 被抑制", () => {
+        const bare = (0, protocol_detector_1.detectSafeguardViolations)(["getWorkspaceUrl"], "NotificationProcessor.getWorkspaceUrl", "typescript", ["job"], true);
+        (0, vitest_1.expect)(has(bare, "Authorization (Unauthenticated Access)")).toBe(true);
+        const withMark = (0, protocol_detector_1.detectSafeguardViolations)(calls, "NotificationProcessor.getWorkspaceUrl", "typescript", ["job"], true);
+        (0, vitest_1.expect)(has(withMark, "Authorization (Unauthenticated Access)")).toBe(false);
+    });
+    (0, vitest_1.it)("Unauthenticated Mutation 被抑制", () => {
+        const bare = (0, protocol_detector_1.detectSafeguardViolations)(["updateTable"], "HistoryProcessor.process", "typescript", ["job"], true);
+        (0, vitest_1.expect)(has(bare, "Authorization (Unauthenticated Mutation)")).toBe(true);
+        const withMark = (0, protocol_detector_1.detectSafeguardViolations)(["updateTable", M], "HistoryProcessor.process", "typescript", ["job"], true);
+        (0, vitest_1.expect)(has(withMark, "Authorization (Unauthenticated Mutation)")).toBe(false);
+    });
+    (0, vitest_1.it)("Ownership Check 被抑制（queue job 的属主校验提问不适用）", () => {
+        const bare = (0, protocol_detector_1.detectSafeguardViolations)(["deleteSessions"], "SessionService.cleanupSessions", "typescript", ["job"], true);
+        (0, vitest_1.expect)(has(bare, "Authorization (Ownership Check)")).toBe(true);
+        const withMark = (0, protocol_detector_1.detectSafeguardViolations)(["deleteSessions", M], "SessionService.cleanupSessions", "typescript", ["job"], true);
+        (0, vitest_1.expect)(has(withMark, "Authorization (Ownership Check)")).toBe(false);
+    });
+    (0, vitest_1.it)("Resource Ownership 被抑制", () => {
+        const bare = (0, protocol_detector_1.detectSafeguardViolations)(["removeIcon"], "AttachmentProcessor.process", "typescript", ["job"], true);
+        (0, vitest_1.expect)(has(bare, "Authorization (Resource Ownership)")).toBe(true);
+        const withMark = (0, protocol_detector_1.detectSafeguardViolations)(["removeIcon", M], "AttachmentProcessor.process", "typescript", ["job"], true);
+        (0, vitest_1.expect)(has(withMark, "Authorization (Resource Ownership)")).toBe(false);
+    });
+    (0, vitest_1.it)("非授权族规则不受标记影响（渲染 sink 照报）", () => {
+        const vs = (0, protocol_detector_1.detectSafeguardViolations)(["render", M], "EmailProcessor.renderTemplate", "typescript");
+        (0, vitest_1.expect)(has(vs, "No Input Sanitization")).toBe(true);
+    });
+});

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;
@@ -385,6 +386,9 @@ const SAFEGUARD_RULES = [
         safeguards: [
             { pattern: /\b(checkOwner|isOwner|ownerId\s*[!=]==?|authorId\s*[!=]==?|userId\s*[!=]==?|createdBy\s*[!=]==?|\.owner\s*[!=]==?|\.user\s*[!=]==?)\b/i, label: "ownership_check" },
             { pattern: /\b(hasPermission|checkPermission|checkAccess|isAuthorized|checkRole|requireRole|adminCheck|isAdmin|canModify|canDelete|canEdit)\b/i, label: "authz_check" },
+            // 修冤枉第六刀：队列/定时/事件处理器不面向请求面——鉴权发生在入队侧，
+            // 「改资源没查属主」的提问在处理器层不适用（docmost 补标注 FP 类）
+            { pattern: /\b(__progmune_no_request_surface__)\b/, label: "no_request_surface" },
             { pattern: /\b(__progmune_ownership_checked__)\b/, label: "inline_ownership_check" },
             // §46 ②：资源属主被**赋值为当前主体**（`{ userId: user.id }` / `where:{userId: user.id}`）。
             // 这类函数的被操作对象就是（或已被限定在）主体自己，谈不上「改别人的东西」。
@@ -428,7 +432,7 @@ const SAFEGUARD_RULES = [
         paramTypeSafeguards: [SESSION_BEARING_TYPE_RE],
         trigger: /\b(list|download|view|fetch)(?:[A-Z]\w*|_\w+)|get(?:[A-Z]\w+|_\w+)/i,
         safeguards: [
-            { pattern: /\b(getUser|validateToken|verifyToken|verifySession|validateSession|getSessionUser|getSession\b|getCurrentUser|token\w*(Check|Verify|Valid)|session\w*(Check|Verify|Valid)|auth\w*(Check|Verify|Valid|Guard|Middleware|Required)|requireAuth|withAuth|authenticate\w*(User|Request|Token)?|checkAuth|isAuth|hasAuth|checkAccess|hasAccess|get_user|get_session_user|get_current_user|validate_session|verify_token|require_auth|with_auth|check_auth|auth_required|authenticate_user|authenticate_request|authenticate_token|token_check|token_verify|token_valid|session_check|session_verify|session_valid|auth_check|auth_guard|auth_middleware|get_current_user_authorizer|current_user_authorizer|login_required|permission_required|user_passes_test|check_authorization|check_permission|jwt\.decode|decode_token|__progmune_auth_checked__|__progmune_credential_check__|__progmune_drf_permissions__|__progmune_auth_machinery__)\b/i, label: "auth_check" },
+            { pattern: /\b(getUser|validateToken|verifyToken|verifySession|validateSession|getSessionUser|getSession\b|getCurrentUser|token\w*(Check|Verify|Valid)|session\w*(Check|Verify|Valid)|auth\w*(Check|Verify|Valid|Guard|Middleware|Required)|requireAuth|withAuth|authenticate\w*(User|Request|Token)?|checkAuth|isAuth|hasAuth|checkAccess|hasAccess|get_user|get_session_user|get_current_user|validate_session|verify_token|require_auth|with_auth|check_auth|auth_required|authenticate_user|authenticate_request|authenticate_token|token_check|token_verify|token_valid|session_check|session_verify|session_valid|auth_check|auth_guard|auth_middleware|get_current_user_authorizer|current_user_authorizer|login_required|permission_required|user_passes_test|check_authorization|check_permission|jwt\.decode|decode_token|__progmune_auth_checked__|__progmune_credential_check__|__progmune_drf_permissions__|__progmune_auth_machinery__|__progmune_no_request_surface__)\b/i, label: "auth_check" },
             // §40 C1：裸 can —— verdaccio 的 can('publish') 中间件就是这里的授权判定
             { pattern: exports.AUTHZ_BARE_CAN_RE, label: "bare_can", callsOnly: true },
         ],
@@ -464,7 +468,7 @@ const SAFEGUARD_RULES = [
         // (listPosts/getPost/deletePost fire via identifier-parsed words).
         trigger: /\b(add|create|update|set|publish|insert|submit)(?:[A-Z]\w*|_\w+)|(?:[A-Z]\w*|_\w+)(Add|Create|Update|Set|Publish|Insert|Submit)\b/i,
         safeguards: [
-            { pattern: /\b(getUser|validateToken|verifyToken|verifySession|validateSession|getSessionUser|getSession\b|getCurrentUser|token\w*(Check|Verify|Valid)|session\w*(Check|Verify|Valid)|auth\w*(Check|Verify|Valid|Guard|Middleware|Required)|requireAuth|withAuth|authenticate\w*(User|Request|Token)?|checkAuth|isAuth|hasAuth|checkAccess|hasAccess|get_user|get_session_user|get_current_user|validate_session|verify_token|require_auth|with_auth|check_auth|auth_required|authenticate_user|authenticate_request|authenticate_token|token_check|token_verify|token_valid|session_check|session_verify|session_valid|auth_check|auth_guard|auth_middleware|get_current_user_authorizer|current_user_authorizer|login_required|permission_required|user_passes_test|check_authorization|check_permission|__progmune_auth_checked__|__progmune_credential_check__|__progmune_drf_permissions__|__progmune_auth_machinery__)\b/i, label: "auth_check" },
+            { pattern: /\b(getUser|validateToken|verifyToken|verifySession|validateSession|getSessionUser|getSession\b|getCurrentUser|token\w*(Check|Verify|Valid)|session\w*(Check|Verify|Valid)|auth\w*(Check|Verify|Valid|Guard|Middleware|Required)|requireAuth|withAuth|authenticate\w*(User|Request|Token)?|checkAuth|isAuth|hasAuth|checkAccess|hasAccess|get_user|get_session_user|get_current_user|validate_session|verify_token|require_auth|with_auth|check_auth|auth_required|authenticate_user|authenticate_request|authenticate_token|token_check|token_verify|token_valid|session_check|session_verify|session_valid|auth_check|auth_guard|auth_middleware|get_current_user_authorizer|current_user_authorizer|login_required|permission_required|user_passes_test|check_authorization|check_permission|__progmune_auth_checked__|__progmune_credential_check__|__progmune_drf_permissions__|__progmune_auth_machinery__|__progmune_no_request_surface__)\b/i, label: "auth_check" },
             // §40 C1：裸 can —— 同上
             { pattern: exports.AUTHZ_BARE_CAN_RE, label: "bare_can", callsOnly: true },
             // §46 ①：凭签发入口豁免 —— 独立 safeguard，**不并入 auth_check**。
@@ -624,6 +628,8 @@ const SAFEGUARD_RULES = [
         safeguards: [
             { pattern: /\b(ownerId\s*[!=]==?|authorId\s*[!=]==?|userId\s*[!=]==?|createdBy|\.owner\s*[!=]==?)/i, label: "ownership_comparison" },
             { pattern: /\b(__progmune_ownership_checked__)\b/, label: "inline_ownership_check" },
+            // 修冤枉第六刀：同上（无请求面 ⇒ 属主校验提问不适用）
+            { pattern: /\b(__progmune_no_request_surface__)\b/, label: "no_request_surface" },
             // §38：同 Ownership Check，组合式谓语一并接上（这条规则更严，更需要）
             { pattern: exports.AUTHZ_PREDICATE_RE, label: "casl_predicate" },
             { pattern: exports.AUTHZ_CAN_HELPER_RE, label: "can_helper" },
@@ -1748,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.64";
+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.64",
+  "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/",