progmune-runtime 3.7.55 → 3.7.57

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

@@ -418,3 +418,223 @@ export class NotesController {
         (0, vitest_1.expect)(a.issues.some((i) => i.type === "NESTJS_NO_VALIDATION" && i.route === "POST notes/create")).toBe(true);
     });
 });
+// ═══════════════════════════════════════════════════════════
+// §52（2026-10-03）：app-level provider 注册事件
+//
+// immich held-out 实测倒在了第三种注册途径上：
+//   const commonMiddleware = [{ provide: APP_PIPE, useClass: ZodValidationPipe }, ...];
+//   const apiMiddleware = [FileUploadInterceptor, ...commonMiddleware, {...}];
+//   @Module({ providers: [...common, ...apiMiddleware, ...] })
+// `APP_PIPE` 与 `@Module` 之间隔了**两跳数组 spread**，只看装饰器那一层永远
+// 看不到 ⇒ 153 条 NO_VALIDATION 误报。修复原则是「注册事件」而非「写法」：
+// 哪里有注册意图，哪里就是证据，不再要求它必须直连某个 @Module。
+//
+// 同组反向测试是硬要求（R75）：压制放宽后必须证明「该报的还在报」。
+// ═══════════════════════════════════════════════════════════
+(0, vitest_1.describe)("nestjs-detector app-level provider 注册事件（§52）", () => {
+    const ZOD_STUB = `
+export function createZodDto(schema: any): any { return class {} as any; }
+export const CreateAlbumSchema = { albumName: "string" };
+export class CreateAlbumDto extends createZodDto(CreateAlbumSchema) {}
+export class PlainAlbumDto { albumName: string = ""; }
+`;
+    const ALBUM_CONTROLLER = `
+import { Body, Controller, Post } from "@nestjs/common";
+import { CreateAlbumDto } from "./album.dto";
+@Controller("albums")
+export class AlbumController {
+  @Post()
+  create(@Body() dto: CreateAlbumDto) { return {}; }
+}
+`;
+    const APP_MODULE_SPREAD = `
+import { Module } from "@nestjs/common";
+import { APP_PIPE } from "@nestjs/core";
+import { ZodValidationPipe } from "nestjs-zod";
+import { FileUploadInterceptor } from "./middleware";
+
+const commonMiddleware = [
+  { provide: APP_PIPE, useClass: ZodValidationPipe },
+];
+const apiMiddleware = [FileUploadInterceptor, ...commonMiddleware];
+
+@Module({ providers: [...apiMiddleware] })
+export class AppModule {}
+`;
+    function writeImmishApp() {
+        write("tsconfig.json", TSCONFIG);
+        write("src/album.dto.ts", ZOD_STUB);
+        write("src/album.controller.ts", ALBUM_CONTROLLER);
+        write("src/middleware.ts", `
+export class FileUploadInterceptor {}
+`);
+    }
+    (0, vitest_1.it)("APP_PIPE 经两跳 spread 进 @Module ⇒ 已校验 DTO 的 mutation 不报 NO_VALIDATION（immich 形态）", () => {
+        writeImmishApp();
+        write("src/app.module.ts", APP_MODULE_SPREAD);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(a.globalValidationPipes).toContain("ZodValidationPipe");
+        const nv = a.issues.filter((i) => i.type === "NESTJS_NO_VALIDATION");
+        (0, vitest_1.expect)(nv.map((i) => i.route)).not.toContain("POST albums");
+    });
+    (0, vitest_1.it)("反向：同一形态但摘掉 APP_PIPE 注册 ⇒ 精确转红（不是无差别压制）", () => {
+        writeImmishApp();
+        write("src/app.module.ts", `
+import { Module } from "@nestjs/common";
+import { FileUploadInterceptor } from "./middleware";
+const apiMiddleware = [FileUploadInterceptor];
+@Module({ providers: [...apiMiddleware] })
+export class AppModule {}
+`);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(a.globalValidationPipes).toEqual([]);
+        (0, vitest_1.expect)(a.issues.some((i) => i.type === "NESTJS_NO_VALIDATION" && i.route === "POST albums")).toBe(true);
+    });
+    (0, vitest_1.it)("反向：有全局管道但入参不是已校验 DTO ⇒ 仍报（保守豁免不扩散到裸类型）", () => {
+        writeImmishApp();
+        write("src/app.module.ts", APP_MODULE_SPREAD);
+        write("src/album.controller.ts", `
+import { Body, Controller, Post } from "@nestjs/common";
+import { PlainAlbumDto } from "./album.dto";
+@Controller("albums")
+export class AlbumController {
+  @Post()
+  create(@Body() dto: PlainAlbumDto) { 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 albums")).toBe(true);
+    });
+    (0, vitest_1.it)("反向：注释里的 APP_PIPE 不算注册事件 ⇒ 仍报（text-fallback 抗噪）", () => {
+        writeImmishApp();
+        write("src/app.module.ts", `
+import { Module } from "@nestjs/common";
+// 计划中：providers: [{ provide: APP_PIPE, useClass: ZodValidationPipe }]
+// * 文档注释形态同样不应被当作注册证据
+@Module({ providers: [] })
+export class AppModule {}
+`);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(a.globalValidationPipes).toEqual([]);
+        (0, vitest_1.expect)(a.issues.some((i) => i.type === "NESTJS_NO_VALIDATION" && i.route === "POST albums")).toBe(true);
+    });
+    (0, vitest_1.it)("@UsePipes 自定义管道名（不带 Pipe 后缀）⇒ 识别为已注册管道", () => {
+        writeImmishApp();
+        write("src/album.controller.ts", `
+import { Body, Controller, Post, UsePipes } from "@nestjs/common";
+import { CreateAlbumDto } from "./album.dto";
+@Controller("albums")
+export class AlbumController {
+  @Post()
+  @UsePipes(bodyTrimSanitizer)
+  create(@Body() dto: CreateAlbumDto) { return {}; }
+}
+`);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(a.issues.filter((i) => i.type === "NESTJS_NO_VALIDATION" && i.route === "POST albums")).toEqual([]);
+    });
+    (0, vitest_1.it)("@UseGuards(AuthGuard('JWT')) 的参数字符串不产生假认证证据（反向 Sophie）", () => {
+        write("tsconfig.json", TSCONFIG);
+        write("src/auth.guard.ts", GUARD);
+        write("src/api.controller.ts", `
+import { Controller, Post, UseGuards } from "@nestjs/common";
+import { JWTStrategy } from "./jwt";
+@Controller("api")
+export class ApiController {
+  @Post("transfer")
+  @UseGuards(JWTStrategy)
+  transfer() { return {}; }
+}
+`);
+        write("src/jwt.ts", `
+export const JWT = "Bearer";
+export class JWTStrategy { canActivate(): boolean { return false; } }
+`);
+        write("src/app.module.ts", MODULE_EMPTY);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        // JWTStrategy 名字里带 jwt ⇒ 认证守卫（EXPECT 有保护）
+        (0, vitest_1.expect)(a.issues.filter((i) => i.type === "NESTJS_NO_AUTH")).toEqual([]);
+        // 但若写成字符串参数，不得凭 'JWT' 这个 token 冒充守卫名
+        write("src/api.controller.ts", `
+import { Controller, Post, UseGuards } from "@nestjs/common";
+import { AnonymousGate } from "./gate";
+@Controller("api")
+export class ApiController {
+  @Post("transfer")
+  @UseGuards(AnonymousGate("JWT"))
+  transfer() { return {}; }
+}
+`);
+        write("src/gate.ts", `
+export function AnonymousGate(scheme: string): any { return class { canActivate() { return true; } }; }
+`);
+        const b = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(b.issues.some((i) => i.type === "NESTJS_NO_AUTH" && i.route === "POST api/transfer")).toBe(true);
+    });
+    (0, vitest_1.it)("registrations 带可复核的 (file, line) 与发现途径", () => {
+        writeImmishApp();
+        write("src/app.module.ts", APP_MODULE_SPREAD);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        const pipeReg = a.registrations.filter((r) => r.token === "APP_PIPE");
+        (0, vitest_1.expect)(pipeReg.length).toBeGreaterThan(0);
+        for (const r of pipeReg) {
+            // 可复核：每条注册都必须能指回某个文件的某一行
+            (0, vitest_1.expect)(r.file).toMatch(/app\.module\.ts$/);
+            (0, vitest_1.expect)(r.line).toBeGreaterThan(0);
+            (0, vitest_1.expect)(r.impl).toBe("ZodValidationPipe");
+            (0, vitest_1.expect)(["module-decorator", "module-property", "array-literal", "text-fallback"]).toContain(r.source);
+        }
+    });
+    (0, vitest_1.it)("数组路径别名：展开成多条 route，公开豁免重新生效（nocodb 形态，普查 72%）", () => {
+        write("tsconfig.json", TSCONFIG);
+        write("src/app.module.ts", MODULE_EMPTY);
+        write("src/token.controller.ts", `
+import { Controller, Post } from "@nestjs/common";
+@Controller(["meta/bases/:id", "api/v1/db/meta/projects/:id"])
+export class TokenController {
+  @Post(["login", "signin"])
+  login() { return {}; }
+  @Post(["api-tokens"])
+  createToken() { return {}; }
+}
+`);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        const paths = a.routes.map((r) => `${r.method} ${r.path}`).sort();
+        // 2 个 controller 别名 × 3 个方法别名 = 6 条
+        (0, vitest_1.expect)(paths).toEqual([
+            "POST api/v1/db/meta/projects/:id/api-tokens",
+            "POST api/v1/db/meta/projects/:id/login",
+            "POST api/v1/db/meta/projects/:id/signin",
+            "POST meta/bases/:id/api-tokens",
+            "POST meta/bases/:id/login",
+            "POST meta/bases/:id/signin",
+        ]);
+        // 旧实现下 path 是整段数组文本 ⇒ /login 豁免匹配不到 ⇒ 4 条 login/signin 全被误报
+        const noAuth = a.issues.filter((i) => i.type === "NESTJS_NO_AUTH").map((i) => i.route);
+        (0, vitest_1.expect)(noAuth.sort()).toEqual([
+            "POST api/v1/db/meta/projects/:id/api-tokens",
+            "POST meta/bases/:id/api-tokens",
+        ]);
+    });
+    (0, vitest_1.it)("@Module(configVar)：装饰器参数是变量时仍能读到 providers（nocodb 形态，普查 71%）", () => {
+        writeImmishApp();
+        write("src/app.module.ts", `
+import { Module } from "@nestjs/common";
+import { APP_PIPE } from "@nestjs/core";
+import { ZodValidationPipe } from "nestjs-zod";
+
+const moduleMetadata = {
+  imports: [],
+  controllers: [],
+  providers: [{ provide: APP_PIPE, useClass: ZodValidationPipe }],
+};
+
+@Module(moduleMetadata)
+export class AppModule {}
+`);
+        const a = (0, nestjs_detector_1.analyzeNestJSProject)(dir);
+        (0, vitest_1.expect)(a.globalValidationPipes).toContain("ZodValidationPipe");
+        const nv = a.issues.filter((i) => i.type === "NESTJS_NO_VALIDATION");
+        (0, vitest_1.expect)(nv.map((i) => i.route)).not.toContain("POST albums");
+    });
+});

package/dist/protocol-detector.js

@@ -1121,17 +1121,17 @@ const SAFEGUARD_RULES = [
         conceptExpected: ["checkExpiry", "autoRenew", "certificate watch"],
     },
     // ── Data Integrity: Mutation without audit ──
-    {
-        name: "Data Mutation Without Audit Trail",
-        category: "data_integrity",
-        trigger: /\b(update|delete|modify|change|mutate|set\w*field|edit|remove|drop)\b/i,
-        safeguards: [
-            { pattern: /\b(audit|log\w*change|change\w*log|track\w*change|record\w*mutation|mutation\w*log|history|version|revision|snapshot|write\w*ahead|wal\b)/i, label: "audit_trail" },
-        ],
-        violationMessage: "Data mutation without audit trail. Cannot track who changed what or recover from accidental data corruption.",
-        conceptMissing: ["AuditTrail", "ChangeTracking", "DataLineage"],
-        conceptExpected: ["auditLog", "changeHistory", "write-ahead log"],
-    },
+    // 2026-10-04（修冤枉第一刀）：移除 "Data Mutation Without Audit Trail"。
+    // 数据依据：fp-gold 131/131 全 FP（docmost/hedgedoc/hoppscotch/verdaccio/
+    // 3×realworld 七仓九片）；TS 盲测 gold 795 条 0 条此族；PyGoat 232 条里
+    // 此族 8 条全 unlabeled 且样本全 FP 形态；84 条 GHSA 无一条审计轨迹类。
+    // 根因是概念性失明（非词表问题）：真实架构里审计在框架/中间件层
+    // （ORM 拦截器/数据库触发器/日志系统），函数名里永远不会出现 audit
+    // 字样 ⇒ 判据「mutation 函数名附近有审计词汇」在真实代码形态上永远
+    // 不可能满足。与授权族保留的理由对照（R92）：授权族在真实世界有 TP
+    // （fr 语料 8/9 位置命中是授权类），此族在所有口径 TP=0。
+    // 若未来有函数级审计判据（如 decorator/@Audited 标记通道），按
+    // 「先语料后规则」重新提案。
     // ═══════════════════════════════════════════════════════════════
     // Governance meta-rule: Framework Version Convention Check
     // Lesson from proxy.ts incident (2026-08-03)

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.55";
+exports.RUNTIME_VERSION = "3.7.57";
 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,220 @@
+"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,
+    // 2026-10-04：Data Mutation Without Audit Trail 规则已移除（fp-gold
+    // 131/131 全 FP、全口径 TP=0，概念性失明——见 protocol-detector.ts 注记），
+    // 先验条目随之删除。
+};
+/** 未知族的兜底先验 = 全局基线 */
+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/confidence-calculator.js

@@ -207,6 +207,8 @@ function computeCoverageConfidence(projectPath) {
     // 1. Load protocol transition space
     const space = loadTransitionSpace(projectPath);
     const namespaces = [...space.perNamespace.keys()];
+    // §53：协议定义不存在 ⇒ 本指标不可测（0 分是「没得测」，不是「测得低」）
+    const applicable = fs.existsSync(path.join(projectPath, "protocols.json"));
     // 2. Load trajectory coverage
     const coverage = loadTrajectoryCoverage(projectPath);
     // 3. Compute per-namespace confidence
@@ -250,7 +252,7 @@ function computeCoverageConfidence(projectPath) {
     const summary = `Weighted coverage: ${score}% ±${margin}%. ` +
         `${saturated} namespaces saturated, ${partial} partial, ${noVocab} no vocabulary. ` +
         (noVocab > 0 ? `Top gap: add trajectories for ${noVocab} uncovered namespaces.` : "");
-    return { score, margin, level, breakdown, summary };
+    return { score, margin, level, breakdown, summary, applicable };
 }
 /**
  * Clear internal caches (for testing or when corpus is updated).

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);
@@ -176,16 +178,30 @@ async function evaluateTrust(ctx) {
     const effectiveScore = policyResult.hasCritical
         ? Math.min(overallScore, types_1.DECISION_THRESHOLDS.criticalLock)
         : overallScore;
-    const decision = (0, score_calculator_1.determineDecision)(effectiveScore, policyResult.hasCritical, explainResult.status);
     // ── Phase 1: Coverage-based confidence (replaces qualitative labels) ──
     const coverageConfidence = (0, confidence_calculator_1.computeCoverageConfidence)(ctx.projectPath);
+    // ═══════════════════════════════════════════════════════════════════
+    //  §53 / R97：决策门禁
+    //
+    //  实测触发场景（immich / nocodb）：authentication 子协议 0 分（21 / 586 条违规），
+    //  coverageConfidence 0% LOW，mappingCoverage 4%~8% LOW —— 三项独立的
+    //  「其实没看到什么」的指标全部触底，聚合结果却仍是 83 / APPROVED / HIGH。
+    //
+    //  门禁只做**封顶**（不许说通过），不做扣分：没有观察就没有扣分依据。
+    // ═══════════════════════════════════════════════════════════════════
+    const decisionGates = (0, score_calculator_1.evaluateDecisionGates)({
+        protocolSafety: protocolResult,
+        coverageLevel: coverageConfidence.level,
+        coverageApplicable: coverageConfidence.applicable,
+    });
+    const decision = (0, score_calculator_1.determineDecision)(effectiveScore, policyResult.hasCritical, explainResult.status, decisionGates);
     const dimConfidences = [
         policyResult.hasCritical ? "LOW" : coverageResult.confidence,
         protocolResult.confidence,
         coverageResult.confidence,
         governanceResult.confidence,
     ];
-    const confidence = (0, score_calculator_1.determineConfidence)(dimConfidences, explainResult.status);
+    const confidence = (0, score_calculator_1.determineConfidence)(dimConfidences, explainResult.status, decisionGates.observationIncomplete);
     // ═══════════════════════════════════════
     //  PHASE 5: ASSEMBLE
     // ═══════════════════════════════════════
@@ -225,17 +241,21 @@ async function evaluateTrust(ctx) {
             score: effectiveScore,
             decision,
             confidence,
+            decisionGates,
             coverageConfidence: extractionWarning
                 ? {
                     score: 0,
                     margin: 25,
                     level: "LOW",
+                    // §53：IR 提取失败同样是「没得测」，不是「测得低」
+                    applicable: false,
                     summary: `${extractionWarning}——本次扫描是废票，不得据此得出「干净」结论`,
                 }
                 : {
                     score: coverageConfidence.score,
                     margin: coverageConfidence.margin,
                     level: coverageConfidence.level,
+                    applicable: coverageConfidence.applicable,
                     summary: coverageConfidence.summary,
                 },
             extractionWarning,
@@ -263,6 +283,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
                 ? {
@@ -1225,6 +1249,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 ──
         // 序列必须来自「函数体内真实调用」而非「文件内函数声明名单」——
@@ -1462,6 +1489,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 */ }
@@ -1602,6 +1665,7 @@ async function collectProtocolViolations(ctx, callGraph) {
     catch { /* best-effort */ }
     return {
         violations,
+        safeguardAlerts,
         coverage: {
             totalApis,
             lookupHits,