progmune-runtime 3.7.55 → 3.7.57

package/dist/trust/formatters/terminal.js

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

package/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");
+    });
+});

package/dist/trust/types.js

@@ -8,7 +8,7 @@
  * these types during evaluation.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DECISION_THRESHOLDS = exports.DEFAULT_GOVERNANCE_DEDUCTIONS = exports.DEFAULT_COVERAGE_MAX_SCORES = exports.DEFAULT_PROTOCOL_WEIGHTS = exports.DEFAULT_SEVERITY_DEDUCTIONS = exports.DEFAULT_DIMENSION_WEIGHTS = exports.TRUST_VIOLATION_REQUIRED_FIELDS = void 0;
+exports.DECISION_THRESHOLDS = exports.DEFAULT_GOVERNANCE_DEDUCTIONS = exports.DEFAULT_COVERAGE_MAX_SCORES = exports.DEFAULT_PROTOCOL_WEIGHTS = exports.DEFAULT_SEVERITY_DEDUCTIONS = exports.DEFAULT_DIMENSION_WEIGHTS = exports.OBSERVATION_RATE_FLOOR = exports.SECURITY_PROTOCOL_FLOOR = exports.SECURITY_PROTOCOLS = exports.TRUST_VIOLATION_REQUIRED_FIELDS = void 0;
 /** The 7 required fields for explainability completeness */
 exports.TRUST_VIOLATION_REQUIRED_FIELDS = [
     "severity",
@@ -20,6 +20,22 @@ exports.TRUST_VIOLATION_REQUIRED_FIELDS = [
     "fix",
     "policy_ref",
 ];
+// ── Decision Gates（§53 / R97） ──
+//
+// 背景（immich + nocodb 实测）：authentication 子协议 0 分（21 条 / 586 条违规）、
+// coverageConfidence 0% LOW、mappingCoverage 4%~8% LOW —— 三项独立的
+// 「我们其实没看到什么」指标全部触底，输出却仍是 83 / APPROVED / HIGH。
+// 根因是聚合层只有「分数 → 档位」一条路径，没有任何**下限**与**观察度门槛**。
+/** 安全相关协议：这些维度出现塌方时，不得给出「通过」结论 */
+exports.SECURITY_PROTOCOLS = [
+    "authentication",
+    "authorization",
+    "data_integrity",
+];
+/** 安全协议分数下限：任一条已观察的安全协议低于此分 ⇒ decision 不得为 APPROVED */
+exports.SECURITY_PROTOCOL_FLOOR = 50;
+/** 观察度门槛：coverage / mapping 命中率低于此值 ⇒ 视为「没看清楚」 */
+exports.OBSERVATION_RATE_FLOOR = 0.3;
 // ── Default Dimension Weights (from design doc) ──
 exports.DEFAULT_DIMENSION_WEIGHTS = {
     policyCompliance: 0.35,

package/package.json

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