progmune-runtime 3.7.53 → 3.7.55

package/CHANGELOG.md

@@ -1,5 +1,77 @@
 # Changelog
 
+## [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 输入校验族摸底（含两条判据被数据否决）
+
+**落地（§47）**：`SafeguardRule` 新增 `paramTypeSafeguards` 通道，`SESSION_BEARING_TYPE_RE
+= /(?:^|[A-Za-z])Session$/i`。语义是**正向**证据且取自 AST 签名——函数手里握着一个
+session 对象 ⇒ 「任何人无需凭证即可访问/修改」不成立。**只挂** Unauthenticated
+Access / Mutation 两条，**不挂** Ownership：有会话 ≠ 操作对象属于自己，一并补上会让这一刀
+变成洗白越权的工具（否命题由 fixture 反向②承担）。
+
+选择「参数类型」而不是「调用列表」的理由：fp-pool 切片里入边为 0 的函数占 36%~42%，
+凡是依赖 `calls` 的机制在那些函数上都会**静默失效**——表现为一切正常，实际没跑。
+
+**实测**：真实池 LOST 4 / ADDED 0（全部 hedgedoc 的 `RequestWithSession`，逐条读源码确认
+FP）；合成池 LOST 3 / ADDED 0（全部本轮新补的 `webshape_H`，webshape 期望 66→72）。
+
+**诚实分母（R77）**：24 条确认真漏洞当前**无一条**触发授权族规则 ⇒ 「24/24 仍报」对这一族
+是平凡成立。本轮安全性实际由合成正反向 fixture + 被压 4 条逐行读源码承担。
+
+**否决（§47.2 / §48）**：
+- 「calls 里找不到写入 ⇒ 不报未认证变更」——缺席型判据要求「看不到 == 不存在」，但 calls
+  通道有损，提取失败会被伪装成「真的不写」⇒ 真漏洞静默消失且 gold 查不出来（**R75**）
+- 「参数类型以 Options 收尾 ⇒ 内部打包、非外部输入」——`createUser(options)` 这类反例太常见，
+  且语料里没有反向 fixture。**现有真值可分 ≠ 判据安全**（**R79**）
+- 附带修正工具缺陷：离线重放对 `requireMarker` 类规则必然短路（gold 的 calls 里没有
+  `__progmune_input_effect__`）⇒ 此前「40 条已压掉」是**假收益**（**R78**）
+
+**§48 摸底结论**：输入校验族 12 条真漏洞 12/12 仍报（首个可证伪基线）；可打误报 21 条，
+但两族共同的瓶颈是**分不清参数是否外部输入**——这需要跨函数数据流，而入边 0 占 36%~42%。
+⇒ 剩下 35 条误报（授权 14 + 校验 21）不是判据调得不够细，是**能力上限**。
+
+**其它**：修正 `extract-ir.ts` 一处过期注释（写着「Input Validation 不接任何标记」，实际早已
+接通）——注释说通道断着、实际已通，比没注释更危险。
+
+**门**：tsc 0 错 / webshape 72-0 / taintpath 160-0 / fr-007 pre5·post0 + fr-016 pre7·post0 /
+定向 9 文件 130 条全绿 / 反向验证：摘刀重跑 webshape_H 的 3 条 suppress 组精确转红
+
 ## [3.7.53] — 2026-09-26
 
 ### 授权族误报压降收口 + 三处可见性基建（§35-§46 合并发布）

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");
@@ -416,8 +417,14 @@ const PATH_TRAVERSAL_MARKER = "__progmune_path_traversal__";
 // __progmune_auth_machinery__，TS 侧此前从未产出 ⇒ 规则侧零改动。
 //
 // 边界（写死在这里，别想当然）：只有**接受标记的规则**会受益。
-// Input Validation 的 safeguard 不接受任何 __progmune_* 标记（protocol-detector.ts:481
-// 是纯词形匹配），装饰器对它无效；实测注入后 Input Validation 条仍在。
+//
+// ⚠ 2026-09-27 更正（别删这段）：本注释此前长期写着
+//     「Input Validation 的 safeguard 不接受任何 __progmune_* 标记，装饰器对它无效」。
+//   **该结论已失效** —— 本文件 E3 的 __progmune_input_schema__ 通道现已接通，
+//   见 protocol-detector.ts:647 的 input_validation safeguard（含
+//   __progmune_input_schema__|__progmune_input_guard__）。
+//   保留这条更正，是因为「注释说通道断着、实际早已通」比没有注释更危险：
+//   它会让人把瓶颈判错地方（2026-09-27 摸底时差点据此重开一条已修好的通道）。
 // ═══════════════════════════════════════════════════════════════
 const AUTH_MACHINERY_MARKER = "__progmune_auth_machinery__";
 /** 显式免鉴权装饰器 —— 出现即不注入。把公开端点判成「有鉴权」是最危险的假阴性。 */
@@ -487,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/protocol-detector-session-param.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * §47：签名级会话证据 —— 参数类型以 `Session` 结尾 ⇒ 「未认证」结论不成立。
+ *
+ * 为什么不是继续在 calls 里找 auth 词：hedgedoc 的 pending-user 三个接口 +
+ * OidcController.callback 都是 `@UseGuards(SessionGuard)` 保护的会话类路由，
+ * 但它们**一个认证函数都不调用** —— 身份是从 `request.session.*` 上取的，
+ * 调用列表里只有 property access，选择器读不到。真实池里这四条全是人工确认的 FP。
+ *
+ * 改用**参数类型**：签名上存在 session 对象 ⇒ 这次调用必然落在某个会话上下文里。
+ * 好处是它来自 AST 签名，不依赖调用图连通（fp-pool 入边 0 的函数占 36%~42%，
+ * 依赖 calls 的机制在那里会静默失效）。
+ *
+ * ⚠ R66 的否命题在本文件 §47 反向② 组：
+ *   有会话 ≠ 操作对象属于自己。越权读取的同形状反例必须 Unauthenticated 熄灭
+ *   而 **Ownership 继续亮**，否则这一刀就是把越权漏洞洗白。
+ */
+const vitest_1 = require("vitest");
+const protocol_detector_1 = require("./protocol-detector");
+const ACC = "Authorization (Unauthenticated Access)";
+const MUT = "Authorization (Unauthenticated Mutation)";
+const OWN = "Authorization (Ownership Check)";
+const RES = "Authorization (Resource Ownership)";
+/** lang 固定 typescript；params/paramTypes 逐用例给定 */
+function fire(calls, name, params, paramTypes) {
+    const vs = (0, protocol_detector_1.detectSafeguardViolations)(calls, name, "typescript", params, false, paramTypes);
+    return new Set(vs.map((v) => v.rule));
+}
+const lit = (b) => (b ? "fires" : "silent");
+(0, vitest_1.describe)("§47 正向：签名带会话 ⇒ Unauthenticated 两条熄灭（hedgedoc 真实 FP）", () => {
+    (0, vitest_1.it)("getPendingUserData(request: RequestWithSession) 不再报未认证读取", () => {
+        const s = fire(["create"], "getPendingUserData", ["request"], ["RequestWithSession"]);
+        (0, vitest_1.expect)(lit(s.has(ACC))).toBe("silent");
+    });
+    (0, vitest_1.it)("confirmPendingUserData(request: RequestWithSession, dto) 不再报未认证变更", () => {
+        const s = fire(["createUserWithIdentityFromPendingUserConfirmation", "save"], "confirmPendingUserData", ["request", "pendingUserConfirmationData"], ["RequestWithSession", "PendingUserConfirmationDto"]);
+        (0, vitest_1.expect)(lit(s.has(MUT))).toBe("silent");
+    });
+    (0, vitest_1.it)("OidcController.callback —— session 不在第一个参数也算数", () => {
+        const s = fire(["extractUserInfoFromCallback", "getExistingOidcIdentity", "mayUpdateIdentity", "save"], "OidcController.callback", ["oidcIdentifier", "request"], ["string", "RequestWithSession"]);
+        (0, vitest_1.expect)(lit(s.has(ACC))).toBe("silent");
+        (0, vitest_1.expect)(lit(s.has(MUT))).toBe("silent");
+    });
+    (0, vitest_1.it)("裸 Session 类型同样成立（不要求 Request 前缀）", () => {
+        const s = fire(["find"], "getProfile", ["session"], ["Session"]);
+        (0, vitest_1.expect)(lit(s.has(ACC))).toBe("silent");
+    });
+});
+(0, vitest_1.describe)("§47 反向①：摘掉这一刀必须重新亮（证明是它在压，不是别机制抢先）", () => {
+    (0, vitest_1.it)("同函数把 RequestWithSession 换成 Request ⇒ 未认证读取重新报", () => {
+        const s = fire(["create"], "getPendingUserData", ["request"], ["Request"]);
+        (0, vitest_1.expect)(lit(s.has(ACC))).toBe("fires");
+    });
+    // 注意这里**不是** §47 在压：`request` 的类型退化成标量后，是 §44 的 paramGated
+    // 先把规则整体跳过了（标量参数不算身份证据）。单独留一条是为了把两层闸门的关系钉住：
+    // 类型通道同时喂给 paramGate（§44）和 paramTypeSafeguards（§47），
+    // 断言这一条可以防止以后有人误以为「类型一变就该亮」。
+    (0, vitest_1.it)("request:string 时由 §44 paramGate 先行跳过 —— 记录两层闸门的先后关系", () => {
+        const s = fire(["createUserWithIdentityFromPendingUserConfirmation", "save"], "confirmPendingUserData", ["request", "pendingUserConfirmationData"], ["string", "PendingUserConfirmationDto"]);
+        (0, vitest_1.expect)(lit(s.has(MUT))).toBe("silent");
+    });
+    (0, vitest_1.it)("不传类型通道时退回旧行为（仍报）—— R57 要求通道不可用时不得静默压", () => {
+        const vs = (0, protocol_detector_1.detectSafeguardViolations)(["create"], "getPendingUserData", "typescript", ["request"]);
+        (0, vitest_1.expect)(lit(vs.some((v) => v.rule === ACC))).toBe("fires");
+    });
+});
+(0, vitest_1.describe)("§47 反向②：有会话 ≠ 有权 —— 越权形态的 Unauthenticated 熄灭但 Ownership 必须继续亮", () => {
+    (0, vitest_1.it)("removeSharedFile(req: RequestWithSession, id) —— 归属检查不能随会话一起被免掉", () => {
+        const s = fire(["findById", "removeFile"], "removeSharedFile", ["request", "id"], ["RequestWithSession", "string"]);
+        (0, vitest_1.expect)(lit(s.has(MUT))).toBe("silent");
+        (0, vitest_1.expect)(lit(s.has(OWN))).toBe("fires");
+    });
+    (0, vitest_1.it)("deleteOtherUsersNote(session: Session, noteId) —— Resource Ownership 必须继续亮", () => {
+        const s = fire(["findNote", "deleteNote"], "deleteOtherUsersNote", ["session", "noteId"], ["Session", "string"]);
+        (0, vitest_1.expect)(lit(s.has(MUT))).toBe("silent");
+        (0, vitest_1.expect)(lit(s.has(OWN) || s.has(RES))).toBe("fires");
+    });
+});
+(0, vitest_1.describe)("§47 边界：类型名不得以 Session 收尾就被误当成会话", () => {
+    const cases = [
+        ["Transaction", " mutation"],
+        ["SessionOptions", "配置对象不是会话本身"],
+        ["Partial<AuthConf>", "verdaccio addAuth 的真类型"],
+        ["Knex", "查询构造器"],
+    ];
+    for (const [type, why] of cases) {
+        (0, vitest_1.it)(`${type} 不应被当作会话（${why.trim()}）`, () => {
+            const s = fire(["merge"], "addAuth", ["auth"], [type]);
+            (0, vitest_1.expect)(lit(s.has(MUT))).toBe("fires");
+        });
+    }
+});

package/dist/protocol-detector.js

@@ -314,6 +314,22 @@ exports.AUTHZ_BARE_CAN_RE = /^(?:can|cannot)$|\.(?:can|cannot)$/i;
  * ⇒ `canSendEmail` 会拆出单词 "can" ⇒ 裸 can 误命中 ⇒ §38 的负对照直接转绿。
  * callsOnly 把匹配限定在**原始调用名**上（`can` 作为被调名才作数）。
  */
+/**
+ * §47（2026-09-27）**会话承载型请求**：参数类型名以 `Session` 结尾
+ * （`RequestWithSession` / `AuthenticatedSession` / `HttpSession` / `Session`）。
+ *
+ * 语义：函数手里握着一个 session 对象 ⇒ 这次调用**已经落在某个会话上下文里**，
+ * 「任何人无需凭证即可访问/修改」这个结论不成立。这是**正向**证据且来自 AST 签名，
+ * 不像「calls 里没有 xxx」那样会被提取失败伪装过去（fp-pool 入边为 0 的函数占
+ * 36%~42%，依赖 calls 的机制在那些函数上会静默失效）。
+ *
+ * ⚠ 只喂给「未认证」两条规则，**不**给 Ownership / Resource Ownership 补 ——
+ *   有会话 ≠ 操作对象属于自己。R66 的否命题由这对组合承担：
+ *   同形状的越权读取 `getOthersData(req: RequestWithSession)` 应当
+ *   Unauthenticated 熄灭、**Ownership 继续亮**（fixture 见
+ *   src/protocol-detector-session-param.test.ts 的反向组）。
+ */
+const SESSION_BEARING_TYPE_RE = /(?:^|[A-Za-z])Session$/i;
 const SAFEGUARD_RULES = [
     // ── Password Hashing ──
     {
@@ -407,6 +423,8 @@ const SAFEGUARD_RULES = [
         category: "authorization",
         languages: ["typescript", "javascript", "python"],
         paramGated: true,
+        // §47：签名带 session ⇒ 已落在会话上下文中（详见 SESSION_BEARING_TYPE_RE 注释）
+        paramTypeSafeguards: [SESSION_BEARING_TYPE_RE],
         trigger: /\b(list|download|view|fetch)(?:[A-Z]\w*|_\w+)|get(?:[A-Z]\w+|_\w+)/i,
         safeguards: [
             { pattern: /\b(getUser|validateToken|verifyToken|verifySession|validateSession|getSessionUser|getSession\b|getCurrentUser|token\w*(Check|Verify|Valid)|session\w*(Check|Verify|Valid)|auth\w*(Check|Verify|Valid|Guard|Middleware|Required)|requireAuth|withAuth|authenticate\w*(User|Request|Token)?|checkAuth|isAuth|hasAuth|checkAccess|hasAccess|get_user|get_session_user|get_current_user|validate_session|verify_token|require_auth|with_auth|check_auth|auth_required|authenticate_user|authenticate_request|authenticate_token|token_check|token_verify|token_valid|session_check|session_verify|session_valid|auth_check|auth_guard|auth_middleware|get_current_user_authorizer|current_user_authorizer|login_required|permission_required|user_passes_test|check_authorization|check_permission|jwt\.decode|decode_token|__progmune_auth_checked__|__progmune_credential_check__|__progmune_drf_permissions__|__progmune_auth_machinery__)\b/i, label: "auth_check" },
@@ -439,6 +457,8 @@ const SAFEGUARD_RULES = [
         category: "authorization",
         languages: ["typescript", "javascript", "python"],
         paramGated: true,
+        // §47：同上 —— 只压制「未认证」，不压制「越权」
+        paramTypeSafeguards: [SESSION_BEARING_TYPE_RE],
         // Note: "post" deliberately excluded — it collides with the Post entity name
         // (listPosts/getPost/deletePost fire via identifier-parsed words).
         trigger: /\b(add|create|update|set|publish|insert|submit)(?:[A-Z]\w*|_\w+)|(?:[A-Z]\w*|_\w+)(Add|Create|Update|Set|Publish|Insert|Submit)\b/i,
@@ -1485,6 +1505,12 @@ function detectSafeguardViolations(calls, enclosingFuncName, language, params, e
             if (!hasIdentity && !exposed)
                 continue;
         }
+        // §47（2026-09-27）签名级会话证据：命中即视为「已认证」，与 calls 类 safeguard 并列。
+        // 放在 `guards.find` 之前，语义上等价于命中了一个 safeguard。
+        if (rule.paramTypeSafeguards && paramTypes) {
+            if (paramTypes.some((t) => t && rule.paramTypeSafeguards.some((re) => re.test(t))))
+                continue;
+        }
         // Check if at least one safeguard matches
         const guards = (params && rule.strictSafeguards) ? rule.strictSafeguards : rule.safeguards;
         const matchedSafeguard = guards.find(s => {

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

package/dist/trust/engine.js

@@ -151,7 +151,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);
@@ -361,7 +368,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,

package/package.json

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