progmune-runtime 3.7.69 → 3.7.71

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog
 
+## [3.7.71] — 2026-10-18
+
+### Express 匿名中间件函数体鉴权证据（fr-014 残留归零）
+
+**根因**：旧 `extractGlobalMiddleware` 用 `[^)]+` 捕获 `app.use(...)`
+实参——匿名中间件函数体的鉴权证据（`app.use(\`${prefix}*\`,
+(req,res,next) => { extractBearerToken(...) ... })`）被截断在第一个
+`）` 处（`(req,res,next)` 的右括号），`classifyMiddleware` 永远看不
+到函数体 ⇒ `hasAnyAuth` 恒 false ⇒ mockoon 管理 API 修复版本
+（CVE-2026-59148 / GHSA-rqx4-3f6q-3x2v）仍残留 1 条
+EXPRESS_NO_AUTH_MIDDLEWARE critical。
+
+- **顶层实参解析（parseUseArgs）**：括号/花括号/字符串/注释感知的
+  顶层逗号切分——匿名中间件函数体完整进入 classifyMiddleware，
+  函数体内的 extractBearerToken/timingSafeEqual 等强证据词命中
+  auth 分类。边界如实记录：模板串按无嵌套 ${} 处理；正则字面量
+  不特殊处理（与检测器其他文本级判定同口径）
+- **模板串路径归属边界**：动态路径路由（`${prefix}/x`）跳过逐路由
+  EXPRESS_ROUTE_MISSING_AUTH 检查——全局守卫挂载路径同样是变量
+  拼接，检测器无法证明「该路由不在守卫覆盖内」，逐路由告警是不
+  可归属的噪声（mockoon 修复形态实测 12 条全 FP）。保守边界：整
+  app 无认证的 critical 不受影响（动态路径照常进 hasNakedMutation
+  计数，修复前形态照报 critical）
+- **fr-014 三态复测（mini 语料，真值文件 raw 直链）**：修复前
+  admin-api.ts 报 critical + server.ts 3 条加固建议类（两版本一致）；
+  修复后 0 critical + 同 3 条建议类——**注册表升级为干净 DETECTED**
+  （fr-corpus 有效 11/17 的 with-boundary 项收窄）
+- **回归锁定**：express 检测器 33/33（+6 例：函数体证据/三态/嵌套
+  实参不切碎/字面量路由照报/注释括号）；框架全族 188/188；引擎 +
+  检测器族 245/245；express-realworld 20 路由 0 协议级 FP 保持
+  （仅已知 NO_HELMET 加固建议边界）
+
+## [3.7.70] — 2026-10-18
+
+### 裸名族兜底传播豁免（修冤枉第十一刀）
+
+**根因**：computeResolvedCallerMap 分层消歧（后缀唯一→同文件→同目录
+→类根）失败时挂未解析边 fail-safe ⇒ 豁免被阻断。第九刀探针实测
+C4/C5 残部里「歧义边」占 50/70 条——但歧义≠证据缺失：同名族调用方
+**并集**全落在豁免集合内时，最坏归因（每个族成员都被每个调用方
+调用）也在并集内，不需要边解析。
+
+- **内核（computeBareFamilyPropagatedSet）**：第七刀 B 判据泛化——
+  裸名族调用方并集全 ⊆ base ⇒ 全族豁免；裸化只增候选（R75 正向
+  证据）⇒ 并集全豁免蕴含真实调用方全豁免；比逐边消歧更保守
+  （族内任一成员被并集外调用则全族不豁免）；快照轮次默认 1；
+  computeJobSurfacePropagatedSet 重构委托本内核（includeBase 保留
+  第七刀「含种子」历史语义，11 例既有测试锁零漂移）
+- **引擎接线**：base = 公开∪守卫∪作业∪混合∪公开传播；suppressed 带
+  `suppressedByBareFamilyPropagation` 标记（R9），
+  `PROGMUNE_BARE_FAMILY_TOGGLE=off` 逃生门；消费顺序
+  guard→job→mixed→public→family（未豁免才挂标记）
+- **A/B（docmost，各 fresh IR）**：control（toggle off）与 3.7.69
+  基线**逐条一致**（642/166，diff 0）；pre **642→585（−57）**，
+  suppressed 166→223（+57 全带 family 标记），主路径 11=11/84=84。
+  −57 = 探针预测的 50 条歧义边类 + **7 条「已豁免成员下游一跳」类**
+  （如 getGreetingName ← PageUpdateEmail、getPageContext ←
+  notifyMentionedUsers——族调用方是第五~十刀豁免成员的函数，内核
+  base 含传播集故自然覆盖；逐条核族调用方 100% 在并集内，TP 0）
+- **FN 风险逐条复核**：57 条全核调用方来源——守卫 controller
+  （updateSpace/removeSpaceIcon/markAllAsRead 类）、@OnEvent 监听器
+  作业链（isTypesense→getSearchDriver 类）、公开路由、既有豁免成员
+  下游；族并集外调用方 148 条照报（不豁免）
+- **回归锁定**：内核 9 例 + 引擎产品路径 2；全量 552/552；三闸门
+  （taintpath 160 / webshape 72 / fr-007 pre5-post0 + fr-016
+  pre7-post0）；TS 盲测 119 项目 LOST 0/ADDED 0（引擎侧豁免不进
+  batch-scan，构造保证 + 实测）
+- **过程教训**：探针只统计「有未解析边」的告警，低估 7 条——
+  传播内核作用于全量函数，「已豁免成员下游」也是合法覆盖。探针
+  过滤器必须与实现判据逐字对齐（R59 家族）
+
 ## [3.7.69] — 2026-10-17
 
 ### 公开表面传播豁免（修冤枉第十刀）

package/dist/frameworks/express-detector.js

@@ -223,23 +223,124 @@ function classifyMiddleware(code, name) {
         return "logging";
     return "unknown";
 }
+/**
+ * 解析 app.use(...) 的实参列表（2026-10-18，fr-014 残留根因修复）：
+ * 顶层逗号切分 + 括号/花括号/字符串/注释感知。
+ *
+ * 根因：旧实现用 `[^)]+` 捕获实参——匿名中间件函数体的鉴权证据
+ * （app.use(`${prefix}*`, (req,res,next) => { extractBearerToken(...)
+ * ... })）被截断在第一个 `)` 处（(req,res,next) 的右括号），
+ * classifyMiddleware 永远看不到函数体 ⇒ hasAnyAuth 恒 false。
+ *
+ * 边界（如实记录）：模板串按无嵌套 ${} 处理（路径字面量形态；
+ * ${} 内含反引号/顶层括号的极端形态会错切）；正则字面量不特殊
+ * 处理（检测器不做语法树，与其他文本级判定同口径）。
+ */
+function parseUseArgs(code, openParenIndex) {
+    const args = [];
+    let i = openParenIndex + 1;
+    let paren = 1; // app.use( 的实参层
+    let brace = 0;
+    let argStart = i;
+    let quote = null;
+    let lineComment = false;
+    let blockComment = false;
+    while (i < code.length) {
+        const ch = code[i];
+        if (lineComment) {
+            if (ch === "\n")
+                lineComment = false;
+            i++;
+            continue;
+        }
+        if (blockComment) {
+            if (ch === "*" && code[i + 1] === "/") {
+                blockComment = false;
+                i += 2;
+                continue;
+            }
+            i++;
+            continue;
+        }
+        if (quote) {
+            if (ch === "\\") {
+                i += 2;
+                continue;
+            }
+            if (ch === quote)
+                quote = null;
+            i++;
+            continue;
+        }
+        if (ch === "'" || ch === '"' || ch === "`") {
+            quote = ch;
+            i++;
+            continue;
+        }
+        if (ch === "/" && code[i + 1] === "/") {
+            lineComment = true;
+            i += 2;
+            continue;
+        }
+        if (ch === "/" && code[i + 1] === "*") {
+            blockComment = true;
+            i += 2;
+            continue;
+        }
+        if (ch === "(") {
+            paren++;
+            i++;
+            continue;
+        }
+        if (ch === ")") {
+            paren--;
+            if (paren === 0) {
+                const text = code.slice(argStart, i).trim();
+                if (text)
+                    args.push({ text, start: argStart });
+                return args;
+            }
+            i++;
+            continue;
+        }
+        if (ch === "{") {
+            brace++;
+            i++;
+            continue;
+        }
+        if (ch === "}") {
+            brace = Math.max(0, brace - 1);
+            i++;
+            continue;
+        }
+        if (ch === "," && paren === 1 && brace === 0) {
+            const text = code.slice(argStart, i).trim();
+            if (text)
+                args.push({ text, start: argStart });
+            argStart = i + 1;
+        }
+        i++;
+    }
+    return args;
+}
 /**
  * Extract global middleware registrations (app.use(fn)).
  */
 function extractGlobalMiddleware(code, appName) {
     const middleware = [];
-    const useRegex = new RegExp(`${appName}\\.use\\s*\\(([^)]+)\\)`, "gi");
+    const useRegex = new RegExp(`${appName}\\.use\\s*\\(`, "gi");
     let match;
     while ((match = useRegex.exec(code)) !== null) {
-        const args = match[1].split(",").map(a => a.trim());
-        for (const arg of args) {
-            if (arg.startsWith("'") || arg.startsWith('"'))
+        const openParen = match.index + match[0].length - 1;
+        for (const arg of parseUseArgs(code, openParen)) {
+            const t = arg.text;
+            if (/^['"`]/.test(t))
                 continue; // skip path strings
-            if (/^(express|router|Router)\./.test(arg))
+            if (/^(express|router|Router)\./.test(t))
                 continue; // skip sub-routers (handled separately)
             middleware.push({
-                name: arg,
-                type: classifyMiddleware(code, arg),
+                name: t,
+                type: classifyMiddleware(code, t),
                 registeredAt: code.slice(0, match.index).split("\n").length,
             });
         }
@@ -311,6 +412,14 @@ function analyzeExpressApp(code) {
                 continue; // 读操作不查（公开读常见）
             if (routeHasAuth(route))
                 continue;
+            // 模板串路径（如 `${adminApiPrefix}/env-vars`）不可静态归属——
+            // 全局守卫挂载路径同样是变量拼接（app.use(`${prefix}*`, auth)），
+            // 检测器无法证明「该路由不在守卫覆盖内」，逐路由告警是不可归属的
+            // 噪声（fr-014 mockoon 修复形态实测 12 条全 FP）。保守边界：动态
+            // 路径跳过逐路由检查；整 app 无认证的 critical 检查不受影响
+            // （动态路径照常进入 hasNakedMutation 计数）。
+            if (route.path.includes("${"))
+                continue;
             if (isPublicRoute(route.path))
                 continue;
             if (route.method === "post" && (0, route_window_1.isRegisterRoot)(route.path, registerRoots))

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

@@ -273,3 +273,93 @@ module.exports = router;
         (0, vitest_1.expect)(issues.some((i) => i.rule === "EXPRESS_ROUTE_MISSING_AUTH" && i.route === "PUT /admin")).toBe(false);
     });
 });
+// ═══════════════════════════════════════════════════════════════
+// fr-014 残留修复（2026-10-18）：匿名中间件函数体鉴权证据 + 模板
+// 串路径归属边界（mockoon admin-api 修复形态）
+//
+// 根因：extractGlobalMiddleware 旧实现 [^)]+ 把 app.use(`${prefix}*`,
+// (req,res,next) => { ...extractBearerToken... }) 截断在第一个 `)`，
+// 函数体证据永远不可见 ⇒ hasAnyAuth 恒 false ⇒ 修复后仍报 critical。
+// 修复：顶层实参解析（括号/花括号/字符串感知）+ 模板串路径跳过
+// 逐路由检查（动态路径不可静态归属，12 条实测全 FP）。
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("express-detector：匿名中间件函数体鉴权证据（fr-014 残留）", () => {
+    const ADMIN_API_FIX_SHAPE = `
+const express = require('express');
+const { timingSafeEqual } = require('node:crypto');
+const setupAdminApi = (app: Express) => {
+  const adminApiPrefix = '/mockoon-admin';
+  const hasValidAdminApiToken = (token: string) => timingSafeEqual(Buffer.from('x'), Buffer.from(token));
+
+  app.use(\`\${adminApiPrefix}*\`, (req, res, next) => {
+    const bearerToken = extractBearerToken(req.get('authorization'));
+    if (!bearerToken || !hasValidAdminApiToken(bearerToken)) {
+      res.status(401).send({ message: 'Unauthorized' });
+      return;
+    }
+    next();
+  });
+
+  app.post(\`\${adminApiPrefix}/env-vars\`, setEnvVarHandler);
+  app.put(\`\${adminApiPrefix}/env-vars\`, setEnvVarHandler);
+};
+
+export { setupAdminApi };
+`;
+    const ADMIN_API_PRE_SHAPE = ADMIN_API_FIX_SHAPE.replace(`  app.use(\`\${adminApiPrefix}*\`, (req, res, next) => {
+    const bearerToken = extractBearerToken(req.get('authorization'));
+    if (!bearerToken || !hasValidAdminApiToken(bearerToken)) {
+      res.status(401).send({ message: 'Unauthorized' });
+      return;
+    }
+    next();
+  });
+
+`, "");
+    (0, vitest_1.it)("匿名中间件函数体内的 bearer 证据 ⇒ 分类为 auth（修复形态）", () => {
+        const mw = (0, express_detector_1.extractGlobalMiddleware)(ADMIN_API_FIX_SHAPE, "app");
+        const auth = mw.find((m) => m.type === "auth");
+        (0, vitest_1.expect)(auth).toBeDefined();
+        (0, vitest_1.expect)(auth.name).toContain("extractBearerToken");
+    });
+    (0, vitest_1.it)("修复形态（全局匿名 auth + 模板串 mutation 路由）⇒ 0 issues", () => {
+        const { issues } = (0, express_detector_1.analyzeExpressApp)(ADMIN_API_FIX_SHAPE);
+        (0, vitest_1.expect)(issues).toEqual([]);
+    });
+    (0, vitest_1.it)("修复前形态（无任何鉴权证据 + 模板串 mutation 路由）⇒ critical 照报", () => {
+        const { issues } = (0, express_detector_1.analyzeExpressApp)(ADMIN_API_PRE_SHAPE);
+        (0, vitest_1.expect)(issues.some((i) => i.rule === "EXPRESS_NO_AUTH_MIDDLEWARE")).toBe(true);
+    });
+    (0, vitest_1.it)("嵌套调用实参不被切碎（app.use(cors({origin:'x,y'})) 分类 cors）", () => {
+        const code = `
+const app = require('express')();
+app.use(cors({ origin: 'a,b', methods: ['GET','POST'] }));
+app.post('/x', handler);
+`;
+        const mw = (0, express_detector_1.extractGlobalMiddleware)(code, "app");
+        (0, vitest_1.expect)(mw.some((m) => m.type === "cors")).toBe(true);
+        // 逗号在字符串/嵌套括号内不产生碎实参
+        (0, vitest_1.expect)(mw.length).toBe(1);
+    });
+    (0, vitest_1.it)("字面量路径 mutation 路由在 hasAnyAuth 下仍逐路由报（回归锁定）", () => {
+        const code = `
+const app = require('express')();
+app.use(passport.initialize());
+app.post('/admin/secret', handler);
+`;
+        const { issues } = (0, express_detector_1.analyzeExpressApp)(code);
+        (0, vitest_1.expect)(issues.some((i) => i.rule === "EXPRESS_ROUTE_MISSING_AUTH" && i.route === "POST /admin/secret")).toBe(true);
+    });
+    (0, vitest_1.it)("注释内的括号/花括号不破坏实参解析", () => {
+        const code = `
+const app = require('express')();
+app.use(
+  // (注释里的括号) 与 /* 块注释 { } */
+  (req, res, next) => { /* } */ if (req.url) { next(); } }
+);
+app.post('/x', handler);
+`;
+        const mw = (0, express_detector_1.extractGlobalMiddleware)(code, "app");
+        (0, vitest_1.expect)(mw.length).toBe(1);
+    });
+});

package/dist/protocol-detector-bare-family.test.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const protocol_detector_1 = require("./protocol-detector");
+/**
+ * 裸名族兜底传播内核（修冤枉第十一刀，2026-10-17）单元测试。
+ *
+ * B 判据（见 computeBareFamilyPropagatedSet 注释）：
+ *   裸名族调用方并集全 ⊆ base ⇒ 族内每个成员豁免。
+ * 正确性（R75 正向证据）：裸化只增候选 ⇒ 真实调用方必在并集中 ⇒
+ *   并集全豁免蕴含真实调用方全豁免——不需要边解析。
+ * 比逐边消歧更保守：族内任一成员被并集外调用则全族不豁免。
+ * 第七刀经 includeBase=true 与本内核共享（既有 11 例锁定）。
+ */
+(0, vitest_1.describe)("computeBareFamilyPropagatedSet（裸名族兜底，B 判据内核）", () => {
+    (0, vitest_1.it)("歧义族（同名两候选）+ 调用方并集全在 base ⇒ 全族豁免（逐边消歧失败的形态）", () => {
+        // 第五/九/十刀的逐边消歧在此形态挂未解析边 fail-safe；
+        // 族级兜底不需要边解析——最坏归因也落在并集内。
+        const fns = [
+            { name: "GuardedController.get", file: "c/page.controller.ts", calls: ["getData"] },
+            { name: "OtherGuardedController.get", file: "c/space.controller.ts", calls: ["getData"] },
+            { name: "PageService.getData", file: "s/page.service.ts", calls: [] },
+            { name: "SpaceService.getData", file: "s/space.service.ts", calls: [] },
+        ];
+        const base = new Set(["GuardedController.get", "OtherGuardedController.get"]);
+        const g = (0, protocol_detector_1.computeBareFamilyPropagatedSet)(fns, base);
+        (0, vitest_1.expect)(g.has("PageService.getData")).toBe(true);
+        (0, vitest_1.expect)(g.has("SpaceService.getData")).toBe(true);
+    });
+    (0, vitest_1.it)("族内任一成员被并集外调用 ⇒ 全族不豁免（族级保守）", () => {
+        const fns = [
+            { name: "GuardedController.get", file: "c1.ts", calls: ["getData"] },
+            { name: "PublicController.get", file: "c2.ts", calls: ["getData"] }, // 并集外
+            { name: "PageService.getData", file: "s1.ts", calls: [] },
+            { name: "SpaceService.getData", file: "s2.ts", calls: [] },
+        ];
+        const base = new Set(["GuardedController.get"]);
+        const g = (0, protocol_detector_1.computeBareFamilyPropagatedSet)(fns, base);
+        (0, vitest_1.expect)(g.has("PageService.getData")).toBe(false);
+        (0, vitest_1.expect)(g.has("SpaceService.getData")).toBe(false);
+    });
+    (0, vitest_1.it)("无调用方（入口/未连通）⇒ 不豁免", () => {
+        const fns = [{ name: "orphanEntry", file: "m.ts", calls: [] }];
+        const g = (0, protocol_detector_1.computeBareFamilyPropagatedSet)(fns, new Set());
+        (0, vitest_1.expect)(g.has("orphanEntry")).toBe(false);
+    });
+    (0, vitest_1.it)("默认 1 轮：族豁免成员的下游不豁免（传递闭包未开）", () => {
+        const fns = [
+            { name: "GuardedController.get", file: "c.ts", calls: ["getData"] },
+            { name: "PageService.getData", file: "s.ts", calls: ["loadMore"] },
+            { name: "loadMore", file: "s.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeBareFamilyPropagatedSet)(fns, new Set(["GuardedController.get"]));
+        (0, vitest_1.expect)(g.has("PageService.getData")).toBe(true);
+        (0, vitest_1.expect)(g.has("loadMore")).toBe(false);
+    });
+    (0, vitest_1.it)("maxRounds=2 ⇒ 传递两跳成立（快照轮次语义）", () => {
+        const fns = [
+            { name: "GuardedController.get", file: "c.ts", calls: ["getData"] },
+            { name: "PageService.getData", file: "s.ts", calls: ["loadMore"] },
+            { name: "loadMore", file: "s.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeBareFamilyPropagatedSet)(fns, new Set(["GuardedController.get"]), { maxRounds: 2 });
+        (0, vitest_1.expect)(g.has("PageService.getData")).toBe(true);
+        (0, vitest_1.expect)(g.has("loadMore")).toBe(true);
+    });
+    (0, vitest_1.it)("默认返回只含 base 新增成员（R5）；includeBase=true 返回全集（第七刀语义）", () => {
+        const fns = [
+            { name: "GuardedController.get", file: "c.ts", calls: ["getData"] },
+            { name: "PageService.getData", file: "s.ts", calls: [] },
+        ];
+        const base = new Set(["GuardedController.get"]);
+        const added = (0, protocol_detector_1.computeBareFamilyPropagatedSet)(fns, base);
+        (0, vitest_1.expect)(added.has("GuardedController.get")).toBe(false); // base 不重复
+        (0, vitest_1.expect)(added.has("PageService.getData")).toBe(true);
+        const full = (0, protocol_detector_1.computeBareFamilyPropagatedSet)(fns, base, { includeBase: true });
+        (0, vitest_1.expect)(full.has("GuardedController.get")).toBe(true);
+        (0, vitest_1.expect)(full.has("PageService.getData")).toBe(true);
+    });
+    (0, vitest_1.it)("自调不提供豁免证据", () => {
+        const fns = [{ name: "CleanupService.cleanup", file: "s.ts", calls: ["cleanup"] }];
+        const g = (0, protocol_detector_1.computeBareFamilyPropagatedSet)(fns, new Set());
+        (0, vitest_1.expect)(g.has("CleanupService.cleanup")).toBe(false);
+    });
+    (0, vitest_1.it)("限定形态调用名（Class.method）按裸名并入并集（裸化只增候选，保守方向）", () => {
+        const fns = [
+            { name: "GuardedController.get", file: "c.ts", calls: ["PageService.getData"] },
+            { name: "PageService.getData", file: "s.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeBareFamilyPropagatedSet)(fns, new Set(["GuardedController.get"]));
+        (0, vitest_1.expect)(g.has("PageService.getData")).toBe(true);
+    });
+    (0, vitest_1.it)("空 base ⇒ 无人豁免（无正向证据不豁免，R75）", () => {
+        const fns = [
+            { name: "A", file: "a.ts", calls: ["b"] },
+            { name: "b", file: "a.ts", calls: [] },
+        ];
+        const g = (0, protocol_detector_1.computeBareFamilyPropagatedSet)(fns, new Set());
+        (0, vitest_1.expect)(g.has("b")).toBe(false);
+    });
+});

package/dist/protocol-detector.js

@@ -17,6 +17,7 @@ exports.buildCallerMap = buildCallerMap;
 exports.computeResolvedCallerMap = computeResolvedCallerMap;
 exports.computeGuardPropagatedSet = computeGuardPropagatedSet;
 exports.computeJobSurfacePropagatedSet = computeJobSurfacePropagatedSet;
+exports.computeBareFamilyPropagatedSet = computeBareFamilyPropagatedSet;
 exports.computeMixedSurfacePropagatedSet = computeMixedSurfacePropagatedSet;
 exports.computePublicSurfacePropagatedSet = computePublicSurfacePropagatedSet;
 exports.detectSafeguardViolationsV7 = detectSafeguardViolationsV7;
@@ -1798,6 +1799,27 @@ function computeGuardPropagatedSet(funcs, opts) {
 function computeJobSurfacePropagatedSet(funcs, opts) {
     const marker = opts?.marker ?? "__progmune_no_request_surface__";
     const maxHops = opts?.maxHops ?? 1;
+    // 种子：直接带标记的函数（含种子的返回语义由消费方 R6 过滤）
+    const seeds = new Set();
+    for (const f of funcs)
+        if ((f.calls || []).includes(marker))
+            seeds.add(f.name);
+    return computeBareFamilyPropagatedSet(funcs, seeds, { maxRounds: maxHops, includeBase: true });
+}
+/**
+ * 裸名族兜底传播内核（B 判据）：裸名族调用方并集全 ⊆ base ⇒ 族内
+ * 每个成员豁免。正确性（R75 正向证据）：裸化只增候选 ⇒ 真实调用方
+ * 必在并集中 ⇒ 并集全豁免蕴含真实调用方全豁免——**不需要边解析**，
+ * 即使最坏归因（每个族成员都被每个调用方调用）也落在并集内。
+ * 比逐边消歧更保守：族内任一成员被并集外调用则全族不豁免。
+ *
+ * 第七刀（computeJobSurfacePropagatedSet）与第十一刀共用本内核；
+ * 默认返回只含 base 新增成员（includeBase=false），第七刀保留
+ * 「含种子」的历史语义（消费方 R6 过滤）故传 includeBase=true。
+ * 快照轮次语义；无调用方的函数不豁免。
+ */
+function computeBareFamilyPropagatedSet(funcs, base, opts) {
+    const maxRounds = opts?.maxRounds ?? 1;
     const bySuffix = new Map();
     for (const f of funcs) {
         const bare = f.name.split(".").pop() || f.name;
@@ -1816,11 +1838,9 @@ function computeJobSurfacePropagatedSet(funcs, opts) {
             callersByBare.get(bareC).add(f.name);
         }
     }
-    const exempt = new Set();
-    for (const f of funcs)
-        if ((f.calls || []).includes(marker))
-            exempt.add(f.name);
-    for (let round = 0; round < maxHops; round++) {
+    const exempt = new Set(base);
+    const added = new Set();
+    for (let round = 0; round < maxRounds; round++) {
         const toAdd = [];
         for (const f of funcs) {
             if (exempt.has(f.name))
@@ -1834,10 +1854,12 @@ function computeJobSurfacePropagatedSet(funcs, opts) {
         }
         if (toAdd.length === 0)
             break;
-        for (const n of toAdd)
+        for (const n of toAdd) {
             exempt.add(n);
+            added.add(n);
+        }
     }
-    return exempt;
+    return opts?.includeBase ? exempt : added;
 }
 /**
  * 修冤枉第九刀（2026-10-16）：调用方混合并集豁免——

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

package/dist/trust/engine.js

@@ -1535,6 +1535,21 @@ async function collectProtocolViolations(ctx, callGraph) {
                 const publicSurfacePropagated = process.env.PROGMUNE_PUBLIC_SURFACE_TOGGLE === "off"
                     ? new Set()
                     : (0, protocol_detector_1.computePublicSurfacePropagatedSet)(functions, publicMarked, guardPropagated, jobSurfacePropagated);
+                // 修冤枉第十一刀（2026-10-17）：裸名族兜底传播——逐边消歧失败
+                // 的函数用 B 判据族级保守形态兜底：裸名族调用方并集全 ⊆ base
+                // （公开∪守卫∪作业∪既有传播）⇒ 全族豁免。正确性：裸化只增候选
+                // ⇒ 真实调用方必在并集中（不需要边解析，最坏归因也在并集内）。
+                // 比逐边消歧更保守：族内任一成员被并集外调用则全族不豁免。
+                // 默认 1 轮；豁免仅 authorization 类且不作用于直接标记函数。
+                const bareFamilyPropagated = process.env.PROGMUNE_BARE_FAMILY_TOGGLE === "off"
+                    ? new Set()
+                    : (0, protocol_detector_1.computeBareFamilyPropagatedSet)(functions, new Set([
+                        ...publicMarked,
+                        ...guardPropagated,
+                        ...jobSurfacePropagated,
+                        ...mixedSurfacePropagated,
+                        ...publicSurfacePropagated,
+                    ]));
                 for (const f of functions) {
                     const fCalls = f.calls || [];
                     let svs;
@@ -1554,6 +1569,7 @@ async function collectProtocolViolations(ctx, callGraph) {
                     const jobExempt = !directlyJobMarked && jobSurfacePropagated.has(f.name);
                     const mixedExempt = !directlyMarked && !directlyJobMarked && mixedSurfacePropagated.has(f.name);
                     const publicExempt = !directlyPublicMarked && publicSurfacePropagated.has(f.name);
+                    const familyExempt = !directlyMarked && !directlyJobMarked && !directlyPublicMarked && bareFamilyPropagated.has(f.name);
                     for (const v of svs) {
                         const alert = {
                             rule: v.rule,
@@ -1581,6 +1597,10 @@ async function collectProtocolViolations(ctx, callGraph) {
                                 alert.suppressedByPublicSurfacePropagation = true;
                                 suppressed = true;
                             }
+                            if (!suppressed && familyExempt) {
+                                alert.suppressedByBareFamilyPropagation = true;
+                                suppressed = true;
+                            }
                             if (suppressed) {
                                 safeguardAlertsSuppressed.push(alert);
                                 continue;

package/package.json

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