progmune-runtime 3.7.54 → 3.7.56

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## [3.7.56] — 2026-10-02
+
+### 排序告警流进产品（§49.15 方案 b 落地，未发布）
+
+**告警排序器产品化**：`alert-ranker.ts` 自 blind-benchmark 迁入 `src/trust/`（评估脚本
+改 import，对表测试差 0.000 确认同一实现）。`evaluateTrust` 在 IR 提取的同一批
+`functions` 上跑 `detectSafeguardViolations`（batch-scan 同款口径：language 必传、
+params 名/类型、exported 近似 exposed），产出**排序后的 safeguard 告警流**：
+
+- `TrustDecision.overall.safeguardAlerts`：`total` + `groups`（推荐形态：按族分组，
+  组间按先验、组内按语义分，防整族沉底）+ `topRanked`（全局平铺，minPerRule=1
+  保底）。族先验来自 fp-gold 标注（DEFAULT_RULE_PRIOR，贝叶斯平滑 α=8），
+  `learnPrior` 可重估；排序不删告警（§49.16），输出条数 == 输入条数。
+- **证据流与判定分离**：告警不进 violations、不扣分、不改 decision/score。
+- 终端报告新增 "Ranked Safeguard Alerts" 区块（每族前 3 条 + 先验 + 语义理由）。
+
+**实测**：docmost decision APPROVED(87) 不变（分离成立）；告警流 1320 条 / 21 族，
+头部 = Input Validation / Data Integrity(FK) 族，语义理由可解释。
+⚠ 口径注记：1320 与 §49.17 的 1202 差 +9.8%——recall-probe 用 extractIRWithTypes、
+产品路径用 extractIR（两个提取器函数集略异）；排序器的族先验基于 withTypes 口径
+的 fp-gold，迁移到产品口径的偏差未量化，如实记录待补核。
+
+**测试**：engine 23/23（新增 safeguardAlerts 排序不变量 + 判定分离 2 条）、
+trust 全家 67/67、alert-ranker-check 对表 0.000。
+
+## [3.7.55] — 2026-09-29
+
+### 主路径（trust 判定）真实项目首测 + NestJS 失明误报修复（§50）
+
+**首次对产品判定路径做真实项目全量测量**（`blind-benchmark/REALWORLD_MAIN_PATH_V1.md`）：
+docmost（NestJS 5k★）修复前被主路径判 **BLOCKED（score 48，auth 0 分）**——132 条违规里
+126 条逐条核实为失明/语义误报，且同一批违规在 policyCompliance 与 protocolSafety
+**双维度重复扣分**。主路径与旁路（safeguard，§49 加权精确率 5.8%）同病：
+真实公告位置命中 0/18（fr-corpus 17 条交叉证实协议状态机 0 检出），
+但主路径把噪声直接变成产品级判定——**虚假 BLOCKED 比虚假告警伤害大**。
+
+**四刀修复（全部 src 接线层，判定核心不动）**：
+
+1. **E3 DTO 通道接入 NestJS 适配器**：`app.useGlobalPipes(...)` 全局管道识别 +
+   路由入参类型 ∈ 已校验 DTO 集合（复用 `validatedDtoClassNames`，加继承闭包与
+   `createZodDto` Zod 形态）⇒ 不报 NO_VALIDATION。`extract-ir.ts` 导出 E3 集合函数。
+2. **无结构化输入豁免**：入参无 @Body/@Query/@Param（仅 AuthUser/Req/Res/
+   UploadedFile）的路由不报 NO_VALIDATION——没有可校验的输入。
+3. **auth 端点豁免扩展**：+ password-reset / reset-password / verify-token /
+   verify / setup / init（docmost 实测 3 条 NO_AUTH 误报）。
+4. **双维度去重**：policyCompliance 只吃策略类违规（policy_ref 以
+   framework/protocol-safety 开头的已在 protocolSafety 计分）。
+
+**效果**：docmost **BLOCKED(48) → APPROVED(87)**，违规 132 → 6（NESTJS 误报
+126 → 0；残留 6 条含 1 条撞 CVE-2026-33193 攻击面的真实语义告警）；
+hedgedoc（Zod 校验体系 + public/private 双 API 面）47 → 32，剩余 19 条逐条定性
+为规则粒度边界（@Param 裸类型 / @Body('field') 单字段，真无校验，如实保留）。
+
+**踩坑**：`param.getType().getText()` 返回 `import("...").DtoName` 形态——取
+首个标识符会取到 `import` 关键字，改取全部标识符任一命中；测试断言 route
+格式无前导斜杠（`POST pages/create`），3 个测试曾因此"假通过"。
+
+**测试**：nestjs-detector 17/17（新增全局管道+DTO / Zod / 继承 / 无输入 7 条
+正反向）；trust 全家 95/95。
+
 ## [3.7.54] — 2026-09-27
 
 ### §47 签名级会话证据 + §48 输入校验族摸底（含两条判据被数据否决）

package/dist/extract-ir.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatedDtoClassNames = validatedDtoClassNames;
 exports.extractIR = extractIR;
 exports.extractIRWithTypes = extractIRWithTypes;
 const ts_morph_1 = require("ts-morph");
@@ -493,6 +494,8 @@ function decoratorIsValidator(text) {
 /**
  * 全项目扫描：类自身或其属性上带校验装饰器的类名集合。
  * 只看类名（不做类型解析）—— 与污点管线口径一致，跨文件引用靠名字对上。
+ * 导出供框架适配器复用（2026-09-29：NestJS 检测器的 NO_VALIDATION
+ * 失明误报——路由 DTO 在别的文件带 class-validator 装饰器，检测器看不到）。
  */
 function validatedDtoClassNames(project) {
     const out = new Set();

package/dist/frameworks/nestjs-detector.js

@@ -21,6 +21,7 @@ exports.analyzeNestJSFile = analyzeNestJSFile;
 exports.formatNestJSReport = formatNestJSReport;
 const ts_morph_1 = require("ts-morph");
 const route_window_1 = require("./route-window");
+const extract_ir_1 = require("../extract-ir");
 // ── Core Analysis ──
 function analyzeNestJSProject(projectRoot) {
     let project;
@@ -65,6 +66,66 @@ function analyzeNestJSProject(projectRoot) {
         }
     }
     const hasGlobalAuthGuard = analysis.globalAuthGuards.length > 0;
+    // ── 全局校验管道（2026-09-29：docmost 123 条 NO_VALIDATION 失明误报的根因）──
+    // NestJS 标准做法是 bootstrap 里 app.useGlobalPipes(new ValidationPipe(...))，
+    // 路由本身不带 @UsePipes 装饰器 ⇒ 此前全部报 NO_VALIDATION。
+    // 检测方式：任意非 node_modules 源文件出现 .useGlobalPipes( 调用（参数不限——
+    // hedgedoc 形态是 useGlobalPipes(setupValidationPipe(logger))，管道经辅助函数
+    // 创建，字面 ValidationPipe 不在调用处）。
+    // 保守判定：全局管道只豁免「入参是已校验 DTO」的路由（见下），裸类型入参仍报。
+    let hasGlobalValidationPipe = false;
+    for (const file of project.getSourceFiles()) {
+        if (file.getFilePath().includes("node_modules"))
+            continue;
+        if (/\.(test|spec)\.ts$/.test(file.getFilePath()))
+            continue;
+        if (/\.useGlobalPipes\s*\(/.test(file.getText())) {
+            hasGlobalValidationPipe = true;
+            break;
+        }
+    }
+    // ── 已校验 DTO 类名集合（E3 通道同款实现，import 落地代码而非重写）──
+    const validatedDtos = hasGlobalValidationPipe
+        ? (0, extract_ir_1.validatedDtoClassNames)(project)
+        : new Set();
+    // ── 继承闭包（2026-09-29 docmost 实测：RemoveFavoriteDto extends AddFavoriteDto）──
+    // E3 集合只收「类自身带校验装饰器」的类，继承来的装饰器看不到。
+    // 只扩 detector 侧集合，不动 E3 函数（后者影响 safeguard 盲测基线）。
+    for (const file of project.getSourceFiles()) {
+        if (file.getFilePath().includes("node_modules"))
+            continue;
+        for (const cls of file.getClasses()) {
+            let base = cls.getBaseClass();
+            while (base) {
+                const baseName = base.getName();
+                if (baseName && validatedDtos.has(baseName)) {
+                    const clsName = cls.getName();
+                    if (clsName)
+                        validatedDtos.add(clsName);
+                    break;
+                }
+                base = base.getBaseClass();
+            }
+        }
+    }
+    // ── Zod 形态扩展（2026-09-29 hedgedoc 实测）──
+    // class LoginDto extends createZodDto(LoginSchema) {} —— nestjs-zod 的校验
+    // 体系不产 class-validator 装饰器，E3 通道看不见。extends 表达式文本
+    // 含 createZodDto( 即视为已校验 DTO。同样只扩 detector 侧集合。
+    for (const file of project.getSourceFiles()) {
+        if (file.getFilePath().includes("node_modules"))
+            continue;
+        for (const cls of file.getClasses()) {
+            const ext = cls.getExtends();
+            if (!ext)
+                continue;
+            if (/createZodDto\s*\(/.test(ext.getText())) {
+                const clsName = cls.getName();
+                if (clsName)
+                    validatedDtos.add(clsName);
+            }
+        }
+    }
     // ── 第二遍：模块级中间件保护（Nest 5 时代惯用法）──
     // class XxxModule implements NestModule { configure(consumer) {
     //   consumer.apply(AuthMiddleware).forRoutes({path, method}, ...) } }
@@ -154,6 +215,25 @@ function analyzeNestJSProject(projectRoot) {
                     || method.getDecorator("AllowAnon") !== undefined;
                 // 认证守卫 = 认证名分类后的守卫（ThrottlerGuard 等限流守卫不算认证）
                 const authGuards = guards.filter(isAuthGuardName);
+                // 入参是否指向已校验 DTO：@Body()/@Query()/@Param() 参数的
+                // 类型名 ∈ class-validator 装饰类集合（E3 通道语义）。
+                // ts-morph 的类型文本会带 import 前缀：import(".../page.dto").PageInfoDto
+                // 或泛型 Selectable<import("...").Users> —— 取全部标识符，
+                // 任一命中已校验 DTO 集合即豁免（联合类型/裸类型/数组皆可对上；
+                // db 类型 Users 等不在集合，不会误豁免）。
+                const hasValidatedDto = method.getParameters().some((param) => {
+                    const decNames = param.getDecorators().map((d) => d.getName());
+                    if (!decNames.some((n) => ["Body", "Query", "Param"].includes(n)))
+                        return false;
+                    const typeText = param.getType().getText();
+                    const ids = typeText.match(/[A-Za-z_$][\w$]*/g) || [];
+                    return ids.some((id) => validatedDtos.has(id));
+                });
+                // 无结构化输入：入参没有 @Body/@Query/@Param——只有 AuthUser/Req/Res/
+                // UploadedFile 等上下文注入或文件对象（2026-09-29 docmost 实测：
+                // auth/collab-token、auth/logout 等无 body 路由被误报 NO_VALIDATION）。
+                // 没有可校验的 DTO 输入，规则判定面不覆盖，不报。
+                const hasStructuredInput = method.getParameters().some((param) => param.getDecorators().some((d) => ["Body", "Query", "Param"].includes(d.getName())));
                 const route = {
                     method: httpMethod,
                     path: fullPath,
@@ -161,6 +241,7 @@ function analyzeNestJSProject(projectRoot) {
                     handler: method.getName() || "unknown",
                     hasAuthGuard: authGuards.length > 0,
                     hasValidationPipe: pipes.length > 0,
+                    hasValidatedDto,
                     guards,
                     pipes,
                     isPublicDecorated,
@@ -188,7 +269,12 @@ function analyzeNestJSProject(projectRoot) {
                             fix: `Add @UseGuards(AuthGuard) to the method or controller class, or remove the @Public marker.`,
                         });
                     }
-                    if (!route.hasValidationPipe) {
+                    // 豁免：@UsePipes 装饰器，或「全局 ValidationPipe + 入参是已校验 DTO」
+                    // （docmost 实测 123 条失明误报的修复——路由 DTO 在别的文件带
+                    // class-validator 装饰器，只看 @UsePipes 永远看不到），
+                    // 或路由无结构化输入（没有可校验的东西）
+                    const validatedByGlobalPipe = hasGlobalValidationPipe && route.hasValidatedDto;
+                    if (!route.hasValidationPipe && !validatedByGlobalPipe && hasStructuredInput) {
                         analysis.issues.push({
                             type: "NESTJS_NO_VALIDATION",
                             severity: "medium",
@@ -367,6 +453,12 @@ function isPublicRoute(path) {
         /\/auth\/register$/i, /\/register$/i, /\/signup$/i,
         /\/auth\/signup$/i, /\/auth\/signin$/i, /\/signin$/i,
         /\/auth\/refresh$/i, /\/auth\/forgot/i, /\/auth\/reset/i,
+        // auth 流程自身端点（2026-09-29 docmost 实测：auth/setup、
+        // auth/password-reset、auth/verify-token 被误报 NO_AUTH——
+        // 用户尚未登录，这些端点天生无认证；原 /auth/reset 匹配不了 password-reset）
+        /\/auth\/password-reset$/i, /\/auth\/reset-password$/i,
+        /\/auth\/verify-token$/i, /\/auth\/verify$/i,
+        /\/auth\/setup$/i, /\/auth\/init$/i,
         /\/health$/i, /\/healthcheck$/i, /\/ping$/i, /\/status$/i,
         /\/public\//i, /\/static\//i,
     ];
@@ -462,6 +554,7 @@ function analyzeNestJSFile(filePath) {
                     handler: method.getName() || "unknown",
                     hasAuthGuard: guards.filter(isAuthGuardName).length > 0,
                     hasValidationPipe: pipes.length > 0,
+                    hasValidatedDto: false, // 单文件分析无跨文件 DTO 上下文（项目级用 analyzeNestJSProject）
                     guards,
                     pipes,
                     isPublicDecorated: false, // 单文件分析不解析 @Public（项目级用 analyzeNestJSProject）

package/dist/frameworks/nestjs-detector.test.js

@@ -241,3 +241,180 @@ export class AdminController {
         (0, vitest_1.expect)(a.issues.some((i) => i.type === "NESTJS_NO_AUTH" && i.route === "POST /users")).toBe(true);
     });
 });
+// ═══════════════════════════════════════════════════════════
+// 全局 ValidationPipe + DTO 校验识别（2026-09-29 docmost 实测：
+// 123 条 NO_VALIDATION 失明误报的修复——路由 DTO 在别的文件带
+// class-validator 装饰器，只看 @UsePipes 永远看不到）
+// ═══════════════════════════════════════════════════════════
+(0, vitest_1.describe)("nestjs-detector 全局管道 + DTO 校验通道", () => {
+    function writeValidatedApp() {
+        write("tsconfig.json", TSCONFIG);
+        write("src/main.ts", `
+import { ValidationPipe } from "@nestjs/common";
+import { NestFactory } from "@nestjs/core";
+import { AppModule } from "./app.module";
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  app.useGlobalPipes(
+    new ValidationPipe({ whitelist: true, transform: true }),
+  );
+  await app.listen(3000);
+}
+`);
+        write("src/app.module.ts", `
+import { Module } from "@nestjs/common";
+import { PageController } from "./page.controller";
+@Module({ controllers: [PageController] })
+export class AppModule {}
+`);
+        write("src/create-page.dto.ts", `
+import { IsString, IsUUID, IsOptional } from "class-validator";
+export class CreatePageDto {
+  @IsOptional() @IsString() title?: string;
+  @IsUUID() spaceId: string;
+}
+`);
+        write("src/page.controller.ts", `
+import { Controller, Post, Body } from "@nestjs/common";
+import { CreatePageDto } from "./create-page.dto";
+@Controller("pages")
+export class PageController {
+  @Post("create")
+  create(@Body() dto: CreatePageDto) { return {}; }
+}
+`);
+    }
+    (0, vitest_1.it)("全局 ValidationPipe + 入参是已校验 DTO → 不报 NO_VALIDATION", () => {
+        writeValidatedApp();
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        const nv = a.issues.filter((i) => i.type === "NESTJS_NO_VALIDATION");
+        (0, vitest_1.expect)(nv).toEqual([]);
+    });
+    (0, vitest_1.it)("反向：DTO 摘掉 class-validator 装饰器 → 精确转红", () => {
+        writeValidatedApp();
+        write("src/create-page.dto.ts", `
+export class CreatePageDto {
+  title?: string;
+  spaceId: string;
+}
+`);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(a.issues.some((i) => i.type === "NESTJS_NO_VALIDATION" && i.route === "POST pages/create")).toBe(true);
+    });
+    (0, vitest_1.it)("反向：摘掉全局管道 → 精确转红（无 @UsePipes 的路由失去豁免源）", () => {
+        writeValidatedApp();
+        write("src/main.ts", `
+async function bootstrap() { await (await import("@nestjs/core").then(m => m.NestFactory.create(Object))).listen(3000); }
+`);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(a.issues.some((i) => i.type === "NESTJS_NO_VALIDATION" && i.route === "POST pages/create")).toBe(true);
+    });
+    (0, vitest_1.it)("继承 DTO：子类 extends 已校验父类 → 不报（RemoveFavoriteDto 形态）", () => {
+        writeValidatedApp();
+        write("src/create-page.dto.ts", `
+import { IsString, IsUUID, IsOptional } from "class-validator";
+export class CreatePageDto {
+  @IsOptional() @IsString() title?: string;
+  @IsUUID() spaceId: string;
+}
+export class UpdatePageDto extends CreatePageDto {}
+`);
+        write("src/page.controller.ts", `
+import { Controller, Post, Body } from "@nestjs/common";
+import { UpdatePageDto } from "./create-page.dto";
+@Controller("pages")
+export class PageController {
+  @Post("update")
+  update(@Body() dto: UpdatePageDto) { return {}; }
+}
+`);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(a.issues.some((i) => i.type === "NESTJS_NO_VALIDATION" && i.route === "POST pages/update")).toBe(false);
+    });
+    (0, vitest_1.it)("无结构化输入（仅 AuthUser/Req）→ 不报 NO_VALIDATION（collab-token/logout 形态）", () => {
+        write("tsconfig.json", TSCONFIG);
+        write("src/main.ts", `
+import { ValidationPipe } from "@nestjs/common";
+async function bootstrap() { (globalThis as any).app.useGlobalPipes(new ValidationPipe()); }
+`);
+        write("src/app.module.ts", `
+import { Module } from "@nestjs/common";
+import { AuthController } from "./auth.controller";
+@Module({ controllers: [AuthController] })
+export class AppModule {}
+`);
+        write("src/auth.controller.ts", `
+import { Controller, Post, Req } from "@nestjs/common";
+@Controller("auth")
+export class AuthController {
+  @Post("logout")
+  logout(@Req() req: any) { return {}; }
+}
+`);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(a.issues.some((i) => i.type === "NESTJS_NO_VALIDATION" && i.route === "POST auth/logout")).toBe(false);
+    });
+    (0, vitest_1.it)("Zod 形态：class XDto extends createZodDto(schema) + 辅助函数全局管道 → 不报（hedgedoc 形态）", () => {
+        write("tsconfig.json", TSCONFIG);
+        write("src/main.ts", `
+import { setupValidationPipe } from "./setup-pipes";
+async function bootstrap() { (globalThis as any).app.useGlobalPipes(setupValidationPipe()); }
+`);
+        write("src/setup-pipes.ts", `
+import { createZodValidationPipe } from "nestjs-zod";
+export function setupValidationPipe(): any { return new (createZodValidationPipe({}))(); }
+`);
+        write("src/app.module.ts", `
+import { Module } from "@nestjs/common";
+import { NotesController } from "./notes.controller";
+@Module({ controllers: [NotesController] })
+export class AppModule {}
+`);
+        write("src/login.dto.ts", `
+import { createZodDto } from "nestjs-zod";
+export class LoginDto extends createZodDto({}) {}
+`);
+        write("src/notes.controller.ts", `
+import { Controller, Post, Body } from "@nestjs/common";
+import { LoginDto } from "./login.dto";
+@Controller("notes")
+export class NotesController {
+  @Post("create")
+  create(@Body() dto: LoginDto) { return {}; }
+}
+`);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(a.issues.some((i) => i.type === "NESTJS_NO_VALIDATION" && i.route === "POST notes/create")).toBe(false);
+    });
+    (0, vitest_1.it)("反向：Zod DTO 摘掉 createZodDto 继承 → 精确转红", () => {
+        write("tsconfig.json", TSCONFIG);
+        write("src/main.ts", `
+import { setupValidationPipe } from "./setup-pipes";
+async function bootstrap() { (globalThis as any).app.useGlobalPipes(setupValidationPipe()); }
+`);
+        write("src/setup-pipes.ts", `
+import { createZodValidationPipe } from "nestjs-zod";
+export function setupValidationPipe(): any { return new (createZodValidationPipe({}))(); }
+`);
+        write("src/app.module.ts", `
+import { Module } from "@nestjs/common";
+import { NotesController } from "./notes.controller";
+@Module({ controllers: [NotesController] })
+export class AppModule {}
+`);
+        write("src/login.dto.ts", `
+export class LoginDto {}
+`);
+        write("src/notes.controller.ts", `
+import { Controller, Post, Body } from "@nestjs/common";
+import { LoginDto } from "./login.dto";
+@Controller("notes")
+export class NotesController {
+  @Post("create")
+  create(@Body() dto: LoginDto) { return {}; }
+}
+`);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(a.issues.some((i) => i.type === "NESTJS_NO_VALIDATION" && i.route === "POST notes/create")).toBe(true);
+    });
+});

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.52";
+exports.RUNTIME_VERSION = "3.7.56";
 function verify(filePath) {
     const cert = (0, certify_1.certify)(filePath);
     const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();

package/dist/trust/alert-ranker.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * §49.13 告警排序器 —— 把 §49.12 的评估结论变成可执行代码（2026-09-28）
+ *
+ * 一、为什么是排序而不是压制
+ *   §49.9 把压制型判据的三个方向全否决了（缺席型伤真漏洞 3/18；组合型在真漏洞上 0/18）。
+ *   剩下的只有**排序**：告警一条不少，但让真漏洞浮到前面。这不删除信息，
+ *   所以对判据的要求比压制低——压制错了不可逆，排错了只是顺序次优。
+ *
+ * 二、两个信号为什么是**正交**的
+ *   ① 族先验 rulePrior：这条规则**历史上**有多大比例是真漏洞（族级、来自标注）
+ *   ② 语义自身信号 semanticScore：这个**函数自身**做了什么（函数级、来自 IR）
+ *   ① 是「这一类告警值不值得看」，② 是「这一条告警像不像真的」。
+ *   实测留一仓：单独 ① AUC 0.891、单独 ② AUC 0.744、合起来 **0.895**，
+ *   且合起来前 10% 密度从 30.6% 提到 45.8% ⇒ ② 在 ① 分好的层里还能再分，确证互补。
+ *
+ * 三、三条必须知道的口径（不知道就会用错）
+ *   ① **先验来自真值标注 ⇒ 有自证风险**。某族先验一旦是 0，它就被压到最后，
+ *      没人看 ⇒ 永远发现不了它的真漏洞 ⇒ 先验永远是 0。缓解靠**调用方式**：
+ *      默认用 `groupAlerts()` 分组（每个族都有一块，不会被整体沉底），
+ *      或 `rankAlerts({ minPerRule })` 给每族保底名额。**不要**用无保底的纯全局排序。
+ *      曾试图用「规则宽泛度（命中密度）」替代先验以绕开这个风险，实测与真漏洞率
+ *      相关系数 r = -0.026（无关）⇒ 替代方案不成立，已否决。
+ *   ② **信号必须语义定义，不能数据挑选**。§49.12 先让程序从数据里挑「真漏洞率高的
+ *      call 名」，嵌套留一仓（选信号也只在训练仓内做）后前 10% 从 76.9% 掉到 25.3%
+ *      ——挑出来的 `notifyothers` / `dbactor` / `createbytecountingstream` 是**项目专有
+ *      函数名**，过拟合。这里全部改成语义集合（数据操作 / 防护证据 / 鉴权 / token）。
+ *   ③ **这是排序，不是压制**：输出条数 == 输入条数，一条都不会少。
+ *
+ * 四、落地契约（要接进产品时照这个做）
+ *   输入：告警 + 该函数的 IR（calls / params / 同函数命中了几条规则）。产品路径
+ *   FunctionInfo 里这几项都有 ⇒ 不需要扩 IR，不需要改任何判定逻辑。
+ *   先验：内置 DEFAULT_RULE_PRIOR（本轮从 fp-gold 学出）。**线上应该用自己项目
+ *   的反馈数据重估**（learnPrior），并保留关闭先验的能力（usePrior:false，
+ *   此时只剩语义信号，实测仍有前 10% 3.06× 的提升，不会归零）。
+ *
+ * 用法：
+ *   import { rankAlerts, groupAlerts, learnPrior } from "./alert-ranker";
+ *   const ranked = rankAlerts(alerts, { minPerRule: 1 });
+ *
+ * 2026-10-02：自 blind-benchmark/alert-ranker.ts 迁入产品代码（§49.15 方案 b
+ * 落地——产品新增 safeguard 告警流）。评估脚本（alert-ranker-check /
+ * rank-robustness / rank-alerts-cli）改为 import 本文件，对表测试保证同一实现。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BASE = exports.DEFAULT_RULE_PRIOR = exports.W_PRIOR = void 0;
+exports.semanticScore = semanticScore;
+exports.scoreOne = scoreOne;
+exports.rankAlerts = rankAlerts;
+exports.groupAlerts = groupAlerts;
+exports.learnPrior = learnPrior;
+/** 先验权重：先验取值 0~0.41，×3 后与语义分量级相当（§49.12 实测最优组合用的就是这个比例） */
+exports.W_PRIOR = 3.0;
+/**
+ * 内置族先验。来源：fp-gold.jsonl，2026-09-28，n=244（真漏洞 24 / 误报 220），
+ * 贝叶斯平滑 alpha=8（伪计数按全局基线 0.0984 注入）。
+ *
+ * ⚠ 这张表反映的是**本项目这批标注**的分布，换项目必须重估（learnPrior）。
+ *   尤其注意 "Data Mutation Without Audit Trail" = 0.0057：它在本批标注里 140 条
+ *   全是误报，但那不代表它在**任何**项目上都是噪音（比如有审计合规要求的场景）。
+ */
+exports.DEFAULT_RULE_PRIOR = {
+    "Data Integrity (Foreign Key)": 0.4098,
+    "Input Validation": 0.3456,
+    "No Input Sanitization": 0.2367,
+    "File Upload Without Validation": 0.2144,
+    "Session Fixation (Logout without Invalidation)": 0.0874,
+    "No Token Rotation After Privilege Change": 0.0874,
+    "Token Security (Weak Generation)": 0.0874,
+    "Authorization (Resource Ownership)": 0.0787,
+    "Authorization (Unauthenticated Access)": 0.0787,
+    "TLS Enforcement": 0.0656,
+    "Rate Limiting": 0.0656,
+    "API Without Rate Limiting": 0.0656,
+    "Authorization (Ownership Check)": 0.0656,
+    "Session No Timeout": 0.0605,
+    "Notification Without Retry": 0.0605,
+    "Authorization (Unauthenticated Mutation)": 0.0562,
+    "Password Hashing": 0.0525,
+    "Password Hashing (Weak)": 0.0525,
+    "Registration Without Email Verification": 0.0525,
+    "Data Mutation Without Audit Trail": 0.0057,
+};
+/** 未知族的兜底先验 = 全局基线 */
+exports.DEFAULT_BASE = 0.0984;
+// ── 语义信号集合（全部**语义定义**，不是从数据里挑出来的，见文件头 ③）──
+/** 直接的数据操作：真漏洞多半要真的动数据 */
+const DATA_OP = new Set([
+    "insert", "select", "where", "update", "delete", "save", "remove", "upsert",
+    "patch", "create", "destroy", "findone", "findmany", "find", "executetx",
+    "add", "write", "execute",
+]);
+/** 提取器注入的「有校验证据」标记 —— 有防护 ⇒ 更像误报 */
+const GUARD_MARKS = new Set(["__progmune_input_guard__", "__progmune_input_schema__"]);
+/** 鉴权判定调用 */
+const AUTHZ = new Set([
+    "can", "cannot", "authorize", "checkpermission", "haspermission",
+    "verifyjwt", "isauthorized",
+]);
+const INPUT_EFFECT = "__progmune_input_effect__";
+const TOKEN_ISSUED = "__progmune_token_issued__";
+// 权重（§49.12 评估用的就是这组，语义分与先验量级匹配）
+const W = {
+    dataOp: 0.5, // 每个命中的数据操作名
+    multiRule: 0.4, // 同函数被多条规则命中
+    inputEffect: 0.3, // 输入确实被使用
+    guard: -0.6, // 有校验证据 ⇒ 降权
+    authz: -0.4, // 有鉴权判定 ⇒ 降权
+    token: -0.3, // 已签发 token ⇒ 降权
+};
+/** 语义自身信号打分：这个函数**自身**做了什么。只吃 IR 可得字段。 */
+function semanticScore(a) {
+    const calls = a.calls || [];
+    const lower = new Set(calls.map((c) => String(c).toLowerCase()));
+    const reasons = [];
+    let s = 0;
+    const nData = [...DATA_OP].filter((d) => lower.has(d)).length;
+    if (nData) {
+        s += W.dataOp * nData;
+        reasons.push(`直接数据操作 ×${nData}`);
+    }
+    if ((a.nRules ?? 1) >= 2) {
+        s += W.multiRule;
+        reasons.push("同函数命中多条规则");
+    }
+    if (calls.includes(INPUT_EFFECT)) {
+        s += W.inputEffect;
+        reasons.push("输入被使用");
+    }
+    if (calls.some((c) => GUARD_MARKS.has(String(c)))) {
+        s += W.guard;
+        reasons.push("有校验证据（降权）");
+    }
+    if ([...AUTHZ].some((x) => lower.has(x))) {
+        s += W.authz;
+        reasons.push("有鉴权判定（降权）");
+    }
+    if (calls.includes(TOKEN_ISSUED)) {
+        s += W.token;
+        reasons.push("已签发 token（降权）");
+    }
+    return { score: s, reasons };
+}
+function scoreOne(a, o = {}) {
+    const prior = (o.prior ?? exports.DEFAULT_RULE_PRIOR)[a.rule] ?? (o.base ?? exports.DEFAULT_BASE);
+    const sem = semanticScore(a);
+    const p = o.usePrior === false ? 0 : exports.W_PRIOR * prior;
+    return { alert: a, score: p + sem.score, prior, semantic: sem.score, reasons: sem.reasons };
+}
+/**
+ * 全局排序：输出一条平铺列表。
+ * minPerRule>0 时先给每族保底名额，再排剩下的 —— 避免整族沉底。
+ */
+function rankAlerts(alerts, o = {}) {
+    const all = alerts.map((a) => scoreOne(a, o));
+    const min = o.minPerRule ?? 0;
+    if (min <= 0)
+        return all.sort((x, y) => y.score - x.score);
+    const byRule = new Map();
+    for (const r of all) {
+        const k = r.alert.rule;
+        if (!byRule.has(k))
+            byRule.set(k, []);
+        byRule.get(k).push(r);
+    }
+    const head = [];
+    const tail = [];
+    for (const [, list] of byRule) {
+        list.sort((x, y) => y.score - x.score);
+        head.push(...list.slice(0, min));
+        tail.push(...list.slice(min));
+    }
+    const cmp = (x, y) => y.score - x.score;
+    return [...head.sort(cmp), ...tail.sort(cmp)];
+}
+/**
+ * **推荐形态**：按族分组，组间按先验排序，组内按语义分排序。
+ * 每个族都有一块 ⇒ 天然不会因为先验低而被整体沉底（缓解自证风险）。
+ */
+function groupAlerts(alerts, o = {}) {
+    const scored = alerts.map((a) => scoreOne(a, o));
+    const m = new Map();
+    for (const r of scored) {
+        const k = r.alert.rule;
+        if (!m.has(k))
+            m.set(k, []);
+        m.get(k).push(r);
+    }
+    const groups = [...m.entries()].map(([rule, list]) => ({
+        rule,
+        prior: list[0].prior,
+        count: list.length,
+        alerts: list.sort((x, y) => y.score - x.score),
+    }));
+    return groups.sort((a, b) => b.prior - a.prior);
+}
+/**
+ * 从**已标注**的告警里学族先验。线上应该用自己项目的反馈数据调它重估。
+ * alpha 越大越保守（越接近全局基线）——样本少的时候调大。
+ */
+function learnPrior(labeled, alpha = 8) {
+    const cnt = new Map();
+    let tpAll = 0;
+    for (const r of labeled) {
+        const c = cnt.get(r.rule) ?? { tp: 0, n: 0 };
+        c.n++;
+        if (r.gold === "TP") {
+            c.tp++;
+            tpAll++;
+        }
+        cnt.set(r.rule, c);
+    }
+    const base = labeled.length ? tpAll / labeled.length : exports.DEFAULT_BASE;
+    const prior = {};
+    for (const [rule, c] of cnt)
+        prior[rule] = (c.tp + alpha * base) / (c.n + alpha);
+    return { base, prior };
+}

package/dist/trust/engine.js

@@ -74,6 +74,8 @@ const gin_detector_1 = require("../frameworks/gin-detector");
 const fiber_detector_1 = require("../frameworks/fiber-detector");
 const ssg_bridge_1 = require("./ssg-bridge");
 const call_sequence_1 = require("../call-sequence");
+const protocol_detector_1 = require("../protocol-detector");
+const alert_ranker_1 = require("./alert-ranker");
 const extract_ir_1 = require("../extract-ir");
 const extract_ir_python_1 = require("../extract-ir-python");
 const extract_ir_c_1 = require("../extract-ir-c");
@@ -103,7 +105,7 @@ async function evaluateTrust(ctx) {
     // ── Phase 5: Build call graph for cross-function propagation ──
     const callGraph = (0, call_graph_propagator_1.buildCallGraphFromIR)(path.join(ctx.projectPath, "ir.json"));
     const enterpriseViolations = collectEnterpriseViolations(ctx);
-    const { violations: protocolViolations, coverage: mappingCoverageData, ssgCoverage: ssgCov, annotationSuggestions: cAnnotationSuggestions, extractionWarning } = await collectProtocolViolations(ctx, callGraph);
+    const { violations: protocolViolations, coverage: mappingCoverageData, ssgCoverage: ssgCov, annotationSuggestions: cAnnotationSuggestions, extractionWarning, safeguardAlerts } = await collectProtocolViolations(ctx, callGraph);
     const expressResult = collectExpressViolations(ctx);
     const nestjsResult = collectNestJSViolations(ctx);
     const trpcResult = collectTRPCViolations(ctx);
@@ -151,7 +153,14 @@ async function evaluateTrust(ctx) {
     writeTrustFailuresToCorpus(ctx, allViolations);
     //  PHASE 3: SCORE
     // ═══════════════════════════════════════
-    const policyResult = (0, score_calculator_1.scorePolicyCompliance)(allViolations);
+    // 企业策略维度只吃策略类违规——框架适配器（framework.*）与协议检测
+    // （protocol-safety.*）的违规在 protocolSafety 维度已计分，同池双计
+    // 会把失明误报放大成双倍扣分（2026-09-29 docmost 实测：132 条
+    // NestJS 违规双计，auth 0 分 + score 48 + BLOCKED，逐条核实 126 条为 FP）。
+    const policyViolations = allViolations.filter((v) => !v.policy_ref.startsWith("framework") &&
+        !v.policy_ref.startsWith("protocol-safety") &&
+        v.policy_ref !== "protocol");
+    const policyResult = (0, score_calculator_1.scorePolicyCompliance)(policyViolations);
     const protocolResult = (0, score_calculator_1.scoreProtocolSafety)(allViolations);
     const coverageResult = (0, score_calculator_1.scoreVerificationCoverage)(coverageData);
     const governanceResult = (0, score_calculator_1.scoreGovernanceIntegrity)(governanceDefects);
@@ -256,6 +265,10 @@ async function evaluateTrust(ctx) {
                 : undefined,
             /** SSG State Machine coverage — how many calls were matched to protocol rules */
             ssgCoverage: ssgCov,
+            /** 2026-10-02（§49.15 方案 b）：排序后的 safeguard 告警流——证据流，
+             *  不进判定。groups 为推荐形态（按族分组防整族沉底），topRanked
+             *  为全局平铺（minPerRule=1 保底）。total=0 时字段仍在（0 必须自证）。 */
+            safeguardAlerts,
             /** Express framework adapter coverage — routes & middleware analyzed */
             expressCoverage: expressResult.coverage.expressApps > 0
                 ? {
@@ -361,7 +374,7 @@ async function evaluateTrust(ctx) {
                 score: policyResult.score,
                 weight: types_1.DEFAULT_DIMENSION_WEIGHTS.policyCompliance,
                 confidence: policyResult.hasCritical ? "LOW" : "HIGH",
-                violations: allViolations.filter((v) => v.severity !== "low" || v.policy_ref !== "protocol"),
+                violations: policyViolations,
             },
             protocolSafety: protocolResult,
             verificationCoverage: coverageResult,
@@ -1218,6 +1231,9 @@ async function collectProtocolViolations(ctx, callGraph) {
     let annotationSuggestions;
     // 2026-09-22：提取失败标记（跨 try 作用域，随结果返回）
     let extractionWarning;
+    // 2026-10-02：排序后的 safeguard 告警流（§49.15 方案 b）——同一批 IR 上
+    // 收集，try 内赋值、try 外返回
+    let safeguardAlerts;
     try {
         // ── P4.5 校准：TS/JS 项目在 ir.json 缺失时先提取 IR ──
         // 序列必须来自「函数体内真实调用」而非「文件内函数声明名单」——
@@ -1455,6 +1471,42 @@ async function collectProtocolViolations(ctx, callGraph) {
                 if ((ctx.language || "typescript") === "c") {
                     annotationSuggestions = (0, annotation_suggest_1.suggestAnnotations)(functions, protocolRulesData ? new Set(protocolRulesData.rules.keys()) : undefined);
                 }
+                // ── safeguard 告警流（2026-10-02，§49.15 方案 b 落地）──
+                // 同一批 IR 上跑 detectSafeguardViolations（batch-scan 同款口径：
+                // language 必传，params 名/类型、exported 近似 exposed），产出
+                // **排序后的告警流**。证据流与判定分离：不进 violations、不扣分、
+                // 不改 decision/score——排序告警是给人工审查的入口（§49.16：
+                // 排序不删告警，一条不少；groupAlerts 分组防整族沉底）。
+                const safeguardAlertsRaw = [];
+                const svLang = ctx.language || "typescript";
+                for (const f of functions) {
+                    const fCalls = f.calls || [];
+                    let svs;
+                    try {
+                        svs = (0, protocol_detector_1.detectSafeguardViolations)(fCalls, f.name, svLang, (f.params || []).map((p) => p.name), !!f.exported, (f.params || []).map((p) => p.type || ""));
+                    }
+                    catch {
+                        continue; // 单函数失败不阻断整批（与 batch-scan 容错一致）
+                    }
+                    if (svs.length === 0)
+                        continue;
+                    const params = (f.params || []).map((p) => ({ n: p.name, t: p.type || "" }));
+                    for (const v of svs) {
+                        safeguardAlertsRaw.push({
+                            rule: v.rule,
+                            file: f.file,
+                            function: f.name,
+                            calls: fCalls,
+                            nRules: svs.length,
+                            params,
+                        });
+                    }
+                }
+                safeguardAlerts = {
+                    total: safeguardAlertsRaw.length,
+                    groups: (0, alert_ranker_1.groupAlerts)(safeguardAlertsRaw),
+                    topRanked: (0, alert_ranker_1.rankAlerts)(safeguardAlertsRaw, { minPerRule: 1 }),
+                };
             }
         }
         catch { /* best-effort */ }
@@ -1595,6 +1647,7 @@ async function collectProtocolViolations(ctx, callGraph) {
     catch { /* best-effort */ }
     return {
         violations,
+        safeguardAlerts,
         coverage: {
             totalApis,
             lookupHits,

package/dist/trust/formatters/terminal.js

@@ -138,6 +138,29 @@ function formatTrustTerminal(decision) {
             lines.push(`${BOX_V}${" ".repeat(w - 2)}${BOX_V}`);
         }
     }
+    // Ranked Safeguard Alerts — 证据流（2026-10-02，§49.15 方案 b）：
+    // 排序后的 safeguard 告警，不进判定（decision/score 不受影响）。
+    // 展示分组形态的头部：组间按族先验、组内按语义分；每组最多 3 条。
+    const sa = overall.safeguardAlerts;
+    if (sa && sa.total > 0) {
+        lines.push(`${BOX_ML}${BOX_H.repeat(w - 2)}${BOX_MR}`);
+        lines.push(`${BOX_V}  ${BOLD}Ranked Safeguard Alerts${RESET} (evidence stream — does not affect the decision)${BOX_V}`.slice(0, w + 1));
+        lines.push(`${BOX_V}${" ".repeat(w - 2)}${BOX_V}`);
+        lines.push(`${BOX_V}  ${DIM}${sa.total} alert(s), ${sa.groups.length} rule group(s). Groups ordered by rule prior; within each group by semantic signals.${RESET}`.slice(0, w + 1));
+        lines.push(`${BOX_V}${" ".repeat(w - 2)}${BOX_V}`);
+        for (const g of sa.groups.slice(0, 8)) {
+            lines.push(`${BOX_V}  ${CYAN}◆ ${g.rule}${RESET} ${DIM}(prior ${(g.prior * 100).toFixed(1)}%, ${g.count} alerts)${RESET}`.slice(0, w + 1));
+            for (const r of g.alerts.slice(0, 3)) {
+                const a = r.alert;
+                const fn = `${a.function || "?"} @ ${a.file || "?"}`;
+                lines.push(`${BOX_V}    ${DIM}${fn.slice(0, w - 8)}${RESET}`);
+                if (r.reasons.length > 0) {
+                    lines.push(`${BOX_V}    ${DIM}↳ ${r.reasons.join(" · ").slice(0, w - 9)}${RESET}`);
+                }
+            }
+            lines.push(`${BOX_V}${" ".repeat(w - 2)}${BOX_V}`);
+        }
+    }
     // Audit Trail
     lines.push(`${BOX_ML}${BOX_H.repeat(w - 2)}${BOX_MR}`);
     lines.push(`${BOX_V}  ${BOLD}Audit Trail${RESET}${" ".repeat(w - 16)}${BOX_V}`);

package/package.json

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