progmune-runtime 3.7.56 → 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.56";
+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

@@ -79,7 +79,9 @@ exports.DEFAULT_RULE_PRIOR = {
     "Password Hashing": 0.0525,
     "Password Hashing (Weak)": 0.0525,
     "Registration Without Email Verification": 0.0525,
-    "Data Mutation Without Audit Trail": 0.0057,
+    // 2026-10-04：Data Mutation Without Audit Trail 规则已移除（fp-gold
+    // 131/131 全 FP、全口径 TP=0，概念性失明——见 protocol-detector.ts 注记），
+    // 先验条目随之删除。
 };
 /** 未知族的兜底先验 = 全局基线 */
 exports.DEFAULT_BASE = 0.0984;

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

@@ -178,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
     // ═══════════════════════════════════════
@@ -227,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,

package/dist/trust/score-calculator.js

@@ -14,6 +14,7 @@ exports.scoreProtocolSafety = scoreProtocolSafety;
 exports.scoreVerificationCoverage = scoreVerificationCoverage;
 exports.scoreGovernanceIntegrity = scoreGovernanceIntegrity;
 exports.calculateOverallScore = calculateOverallScore;
+exports.evaluateDecisionGates = evaluateDecisionGates;
 exports.determineDecision = determineDecision;
 exports.determineConfidence = determineConfidence;
 exports.countViolationsBySeverity = countViolationsBySeverity;
@@ -80,13 +81,14 @@ function scoreProtocolSafety(violations, protocolWeights) {
         totalWeight += detail.weight;
     }
     const score = totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 100;
-    // Determine confidence for this dimension
-    // A protocol is considered "checked" if it was evaluated (score < 100 found issues,
-    // or score = 100 with no violations means we checked and it passed clean)
-    const protocolsChecked = Object.values(details).filter((d) => d.score <= 100 // all protocols are always evaluated
-    ).length;
+    // ── 观察度（§53 / R97）：0 条违规的协议不是「查过且干净」，而是「没看到东西」 ──
+    // 此前这里写的是 `d.score <= 100`（字面恒真）⇒ 5/5 ⇒ 永远 HIGH。
+    // 后果：authentication 0 分、其余 4 个协议零观察，整维度仍报 confidence HIGH，
+    // 进而让 overall confidence = HIGH。改成按**真的产出过观察**的协议计数。
+    const observedProtocols = protocolNames.filter((n) => (byProtocol[n] || []).length > 0);
+    const blindProtocols = protocolNames.filter((n) => (byProtocol[n] || []).length === 0);
     const confidenceRatio = protocolNames.length > 0
-        ? Math.min(1, protocolsChecked / protocolNames.length)
+        ? observedProtocols.length / protocolNames.length
         : 1;
     const confidence = mapDimensionConfidence(confidenceRatio);
     // Collect only protocol-related violations for evidence
@@ -97,6 +99,8 @@ function scoreProtocolSafety(violations, protocolWeights) {
         confidence,
         details,
         violations: protocolViolations,
+        observedProtocols,
+        blindProtocols,
     };
 }
 /**
@@ -191,6 +195,56 @@ function calculateOverallScore(dimensions) {
 // ═══════════════════════════════════════════════
 //  6. Decision Mapping
 // ═══════════════════════════════════════════════
+/**
+ * 计算决策封顶门禁（§53 / R97）。纯函数，只依赖已算好的维度结果。
+ *
+ * 只回答两个问题：
+ *   ① 「有没有一条**我们确实看过**的安全维度塌了」——有 ⇒ 不许说通过。
+ *   ② 「覆盖率测出来是不是真的很低」——**仅在可测时**才问；不可测 ⇒ 不适用（R98）。
+ *
+ * ⚠ 两者都不**扣分**：没有观察就没有扣分依据（扣分也是臆造）。
+ *   它们只作用于 decision 上限与 confidence，这正是「ABSENCE ≠ evidence of
+ *   absence」在聚合层应有的落地形态。
+ *
+ * ⚠ 语义映射命中率（mappingCoverage）**故意不作为门禁**：实测 9 个真实 TS 项目
+ *   的取值范围是 1%~21%（中位 ~9%），没有任何一个够得到 30%。拿它当门槛就等于
+ *   宣布「TS 项目永不放行」——那是常数不是判据，而且阈值会变成从数据里挑出来的
+ *   数字（R86）。它只出现在输出里供人看，不参与决策。
+ */
+function evaluateDecisionGates(input) {
+    const reasons = [];
+    // ① 安全维度下限 —— 只对「有观察」的协议生效（0 条违规的盲区不参与，避免臆造）
+    const breachedProtocols = types_1.SECURITY_PROTOCOLS
+        .filter((p) => input.protocolSafety.observedProtocols.includes(p))
+        .map((p) => ({
+        protocol: p,
+        score: input.protocolSafety.details[p]?.score ?? 100,
+    }))
+        .filter((d) => d.score < types_1.SECURITY_PROTOCOL_FLOOR);
+    for (const b of breachedProtocols) {
+        reasons.push(`安全维度 ${b.protocol} 得分 ${b.score} < ${types_1.SECURITY_PROTOCOL_FLOOR}（已观察，非盲区）——不得输出 APPROVED`);
+    }
+    // ② 覆盖率门槛 —— 只在**可测**时生效
+    let observationIncomplete = false;
+    if (input.coverageLevel === "LOW") {
+        if (input.coverageApplicable) {
+            observationIncomplete = true;
+            reasons.push("覆盖率置信度 LOW（已测得）——本次扫描不足以支撑「通过」结论");
+        }
+        else {
+            // 不适用：没有 protocols.json ⇒ 0% 是「没得测」，不是「测得低」。
+            // 若在此处当成 LOW 处理，门禁会对所有未接入协议定义的项目 100% 触发
+            // ⇒ 连「0 违规、auth=100」的项目也被封顶（实测 6/6）。这是常数不是判据。
+            reasons.push("覆盖率不可测（项目无 protocols.json）——按「不适用」处理，不作门禁（R98）");
+        }
+    }
+    return {
+        securityFloorBreach: breachedProtocols.length > 0,
+        breachedProtocols,
+        observationIncomplete,
+        reasons,
+    };
+}
 /**
  * Maps score + gates → APPROVED / NEEDS_REVIEW / BLOCKED.
  *
@@ -199,9 +253,14 @@ function calculateOverallScore(dimensions) {
  *   - Score < 60 → BLOCKED
  *   - 60 ≤ Score < 80 → NEEDS_REVIEW
  *   - Score ≥ 80 → APPROVED
+ *   - 安全维度下限被击穿 ⇒ 上限 NEEDS_REVIEW（§53/R97）
+ *   - 观察度不足 ⇒ 上限 NEEDS_REVIEW（§53/R97）
  *   - Explainability UNCERTAIN → degrade one level
+ *
+ * ⚠ 封顶（cap）不是降级（degrade）：封顶只阻止「说通过」，不会把 BLOCKED 抬上来，
+ *   也不会把 NEEDS_REVIEW 打成 BLOCKED —— 避免为了修「虚高」而过冲成「虚低」。
  */
-function determineDecision(overallScore, hasCriticalViolation, explainabilityStatus) {
+function determineDecision(overallScore, hasCriticalViolation, explainabilityStatus, gates) {
     // Hard gate: critical = BLOCKED regardless of score
     if (hasCriticalViolation) {
         return "BLOCKED";
@@ -217,6 +276,15 @@ function determineDecision(overallScore, hasCriticalViolation, explainabilitySta
     else {
         decision = "BLOCKED";
     }
+    // ── §53 / R97：封顶 ──
+    // 背景：immich（auth 0 分 / coverage 0% / mapping 8%）与 nocodb
+    // （auth 0 分 / 586 条 / mapping 4%）都拿到了 83 / APPROVED / HIGH。
+    // 「分数够高」不等于「可以说通过」——前提是我们确实看过、且看过的维度没塌。
+    if (gates &&
+        (gates.securityFloorBreach || gates.observationIncomplete) &&
+        decision === "APPROVED") {
+        decision = "NEEDS_REVIEW";
+    }
     // Explainability degrade: drop one level
     if (explainabilityStatus === "UNCERTAIN") {
         if (decision === "APPROVED")
@@ -239,7 +307,16 @@ function determineDecision(overallScore, hasCriticalViolation, explainabilitySta
  *   - 2+ dimensions MEDIUM → overall MEDIUM
  *   - All HIGH → overall HIGH
  */
-function determineConfidence(dimConfidences, explainabilityStatus) {
+function determineConfidence(dimConfidences, explainabilityStatus, 
+/**
+ * §53 / R97：观察度不足时，置信度**封顶**为 MEDIUM。
+ *
+ * 背景：immich 的 coverageConfidence 是 0% ±25% LOW，而 overall confidence
+ * 仍是 HIGH —— 四个维度的 confidence 里没有一项接了覆盖率这条线。
+ * 代码里甚至已经写了「本次扫描是废票，不得据此得出『干净』结论」，
+ * 但没有任何一行消费它。**声明与实现分离**是这里真正的缺陷。
+ */
+observationIncomplete) {
     // Explainability gate overrides everything
     if (explainabilityStatus === "UNCERTAIN") {
         return "UNCERTAIN";
@@ -252,6 +329,9 @@ function determineConfidence(dimConfidences, explainabilityStatus) {
         return "MEDIUM";
     if (mediumCount === 1)
         return "MEDIUM"; // Even one medium drags confidence
+    // 观察度不足 ⇒ 即便各维度都报 HIGH，也不得给出 HIGH
+    if (observationIncomplete)
+        return "MEDIUM";
     return "HIGH";
 }
 // ═══════════════════════════════════════════════

package/dist/trust/score-calculator.test.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * §53 / R97：决策门禁单测
+ *
+ * 背景（immich + nocodb 实测）：authentication 子协议 0 分（21 / 586 条违规）、
+ * coverageConfidence 0% LOW、mappingCoverage 4%~8% LOW —— 三项独立的
+ * 「其实没看到什么」的指标全部触底，聚合结果却仍是 83 / APPROVED / HIGH。
+ *
+ * 本文件的重点不是「门禁会不会触发」，而是**它会不会过冲**：
+ *   - 只封顶（不许说通过），不降级（不许把 BLOCKED 抬上来、也不许把 NEEDS_REVIEW 打成 BLOCKED）
+ *   - 盲区（0 条违规）不得被当成「查过且干净」加分，也不得被当成「有问题」扣分
+ *   - 没有观察 ⇒ 影响的是 confidence 与 decision 上限，不是分数
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const score_calculator_1 = require("./score-calculator");
+function v(ruleId, severity = "medium") {
+    return {
+        rule_id: ruleId,
+        severity,
+        file: "src/a.ts",
+        function: "handler",
+        message: "test",
+        evidence: "test",
+        why: "test",
+        fix: "test",
+        policy_ref: "protocol-safety.specific",
+    };
+}
+/** 造一个「只有 authentication 有观察」的维度（= immich 的真实形态） */
+function authOnlyProtocolSafety(violationCount) {
+    return (0, score_calculator_1.scoreProtocolSafety)(Array.from({ length: violationCount }, () => v("AUTH_MISSING")));
+}
+(0, vitest_1.describe)("§53 decision gates — 观察度（protocolSafety.confidence）", () => {
+    (0, vitest_1.it)("0 条违规的协议是 blind，不是 checked-clean（此前恒为 HIGH）", () => {
+        const ps = authOnlyProtocolSafety(21);
+        (0, vitest_1.expect)(ps.observedProtocols).toEqual(["authentication"]);
+        (0, vitest_1.expect)(ps.blindProtocols.sort()).toEqual([
+            "authorization",
+            "data_integrity",
+            "ledger",
+            "payment",
+        ]);
+        // 5 个协议只有 1 个有观察 ⇒ 0.2 ⇒ LOW
+        (0, vitest_1.expect)(ps.confidence).toBe("LOW");
+    });
+    (0, vitest_1.it)("全盲（0 违规）时分数仍为 100，但 confidence 塌到 LOW —— 不加分也不扣分", () => {
+        const ps = (0, score_calculator_1.scoreProtocolSafety)([]);
+        (0, vitest_1.expect)(ps.score).toBe(100);
+        (0, vitest_1.expect)(ps.observedProtocols).toEqual([]);
+        (0, vitest_1.expect)(ps.blindProtocols.length).toBe(5);
+        (0, vitest_1.expect)(ps.confidence).toBe("LOW");
+    });
+});
+(0, vitest_1.describe)("§53 decision gates — 安全维度下限", () => {
+    (0, vitest_1.it)("已观察的安全协议塌方 ⇒ 封顶 NEEDS_REVIEW（且分数不动）", () => {
+        const ps = authOnlyProtocolSafety(21);
+        (0, vitest_1.expect)(ps.details.authentication.score).toBe(0);
+        const gates = (0, score_calculator_1.evaluateDecisionGates)({ protocolSafety: ps });
+        (0, vitest_1.expect)(gates.securityFloorBreach).toBe(true);
+        (0, vitest_1.expect)(gates.breachedProtocols).toEqual([{ protocol: "authentication", score: 0 }]);
+        // 83 分照样 APPROVED —— 门禁把它封住
+        (0, vitest_1.expect)((0, score_calculator_1.determineDecision)(83, false, "EXPLAINABLE", gates)).toBe("NEEDS_REVIEW");
+    });
+    (0, vitest_1.it)("反向：盲区不得触发下限（没有观察就没有扣分依据）", () => {
+        const ps = (0, score_calculator_1.scoreProtocolSafety)([]);
+        const gates = (0, score_calculator_1.evaluateDecisionGates)({ protocolSafety: ps });
+        // 全盲：分数都是 100，本来也不会 breach；关键是 breachedProtocols 必须为空
+        (0, vitest_1.expect)(gates.securityFloorBreach).toBe(false);
+        (0, vitest_1.expect)(gates.breachedProtocols).toEqual([]);
+    });
+    (0, vitest_1.it)("反向：封顶不是降级 —— 低分 BLOCKED 不会被抬成 NEEDS_REVIEW", () => {
+        const ps = authOnlyProtocolSafety(21);
+        const gates = (0, score_calculator_1.evaluateDecisionGates)({ protocolSafety: ps });
+        (0, vitest_1.expect)((0, score_calculator_1.determineDecision)(30, false, "EXPLAINABLE", gates)).toBe("BLOCKED");
+        (0, vitest_1.expect)((0, score_calculator_1.determineDecision)(65, false, "EXPLAINABLE", gates)).toBe("NEEDS_REVIEW");
+    });
+});
+(0, vitest_1.describe)("§53 decision gates — 观察度门槛", () => {
+    (0, vitest_1.it)("coverage LOW **且可测** ⇒ observationIncomplete ⇒ decision 封顶、confidence 封顶 MEDIUM", () => {
+        const ps = authOnlyProtocolSafety(1);
+        const gates = (0, score_calculator_1.evaluateDecisionGates)({
+            protocolSafety: ps,
+            coverageLevel: "LOW",
+            coverageApplicable: true,
+        });
+        (0, vitest_1.expect)(gates.observationIncomplete).toBe(true);
+        (0, vitest_1.expect)((0, score_calculator_1.determineDecision)(95, false, "EXPLAINABLE", gates)).toBe("NEEDS_REVIEW");
+        (0, vitest_1.expect)((0, score_calculator_1.determineConfidence)(["HIGH", "HIGH", "HIGH", "HIGH"], "EXPLAINABLE", true)).toBe("MEDIUM");
+    });
+    (0, vitest_1.it)("★ 反向（R98）：coverage LOW 但**不可测** ⇒ 不封顶 —— 没得测 ≠ 测得低", () => {
+        // 实测：9 个真实 TS 项目全部没有 protocols.json ⇒ coverage 恒 0% LOW。
+        // 若不区分「不适用」与「真的低」，门禁 100% 触发，连「0 违规、auth=100」
+        // 的项目也被封顶（实测 6/6 全变 NEEDS_REVIEW）——那是常数不是判据。
+        const ps = (0, score_calculator_1.scoreProtocolSafety)([v("AUTH_ONE")]);
+        const gates = (0, score_calculator_1.evaluateDecisionGates)({
+            protocolSafety: ps,
+            coverageLevel: "LOW",
+            coverageApplicable: false,
+        });
+        (0, vitest_1.expect)(gates.observationIncomplete).toBe(false);
+        (0, vitest_1.expect)(gates.reasons.some((r) => r.includes("不适用"))).toBe(true);
+        (0, vitest_1.expect)((0, score_calculator_1.determineDecision)(95, false, "EXPLAINABLE", gates)).toBe("APPROVED");
+    });
+    (0, vitest_1.it)("★ 反向：0 违规且 auth=100 的干净项目不得被封顶（过冲防线）", () => {
+        // express-realworld / koa-realworld / netflx-web 的真实形态：
+        // 0 条违规、authentication=100、coverage 不可测 ⇒ 必须仍是 APPROVED。
+        const ps = (0, score_calculator_1.scoreProtocolSafety)([]);
+        const gates = (0, score_calculator_1.evaluateDecisionGates)({
+            protocolSafety: ps,
+            coverageLevel: "LOW",
+            coverageApplicable: false,
+        });
+        (0, vitest_1.expect)(gates.securityFloorBreach).toBe(false);
+        (0, vitest_1.expect)(gates.observationIncomplete).toBe(false);
+        (0, vitest_1.expect)((0, score_calculator_1.determineDecision)(90, false, "EXPLAINABLE", gates)).toBe("APPROVED");
+    });
+    (0, vitest_1.it)("反向：观察度充足且无塌方 ⇒ 不封顶（不许把门禁做成一律 NEEDS_REVIEW）", () => {
+        const ps = (0, score_calculator_1.scoreProtocolSafety)([v("AUTH_OK_LOW")]);
+        // 造一个 authentication 高分、且 5 个协议都有观察的形态
+        const allObserved = {
+            ...ps,
+            observedProtocols: ["authentication", "authorization", "payment", "data_integrity", "ledger"],
+            blindProtocols: [],
+            confidence: "HIGH",
+        };
+        const gates = (0, score_calculator_1.evaluateDecisionGates)({
+            protocolSafety: allObserved,
+            coverageLevel: "HIGH",
+            coverageApplicable: true,
+        });
+        (0, vitest_1.expect)(gates.securityFloorBreach).toBe(false);
+        (0, vitest_1.expect)(gates.observationIncomplete).toBe(false);
+        (0, vitest_1.expect)(gates.reasons).toEqual([]);
+        (0, vitest_1.expect)((0, score_calculator_1.determineDecision)(95, false, "EXPLAINABLE", gates)).toBe("APPROVED");
+    });
+});
+(0, vitest_1.describe)("§53 decision gates — 硬门优先级", () => {
+    (0, vitest_1.it)("critical 仍然压过一切（门禁不得削弱 BLOCKED）", () => {
+        const ps = authOnlyProtocolSafety(21);
+        const gates = (0, score_calculator_1.evaluateDecisionGates)({ protocolSafety: ps });
+        (0, vitest_1.expect)((0, score_calculator_1.determineDecision)(95, true, "EXPLAINABLE", gates)).toBe("BLOCKED");
+    });
+    (0, vitest_1.it)("门禁为 undefined 时行为与改动前完全一致（向后兼容）", () => {
+        (0, vitest_1.expect)((0, score_calculator_1.determineDecision)(95, false, "EXPLAINABLE")).toBe("APPROVED");
+        (0, vitest_1.expect)((0, score_calculator_1.determineDecision)(70, false, "EXPLAINABLE")).toBe("NEEDS_REVIEW");
+        (0, vitest_1.expect)((0, score_calculator_1.determineDecision)(30, false, "EXPLAINABLE")).toBe("BLOCKED");
+    });
+});