progmune-runtime 2.1.5 → 3.2.0

package/dist/trust/explainability.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Phase 1: Explainability Binary Gate
+ *
+ * Checks every TrustViolation for complete 6-tuple evidence.
+ * If ANY violation is missing ANY required field → UNCERTAIN.
+ *
+ * This is a GATE, not a scored dimension. An unexplainable Trust Score
+ * is inherently untrustworthy and must be flagged rather than averaged in.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkExplainability = checkExplainability;
+exports.assertSixTuple = assertSixTuple;
+exports.isViolationComplete = isViolationComplete;
+const types_1 = require("./types");
+// ── Main Entry Point ──
+/**
+ * Binary gate: validates ALL violations have complete 6-tuple evidence.
+ *
+ * The 7 required fields (from the design doc):
+ *   severity, rule_id, file, function, evidence, why, fix, policy_ref
+ *
+ * @returns EXPLAINABLE if all violations are complete, UNCERTAIN otherwise
+ */
+function checkExplainability(violations) {
+    // Vacuous truth: no violations = explainable
+    if (!violations || violations.length === 0) {
+        return {
+            status: "EXPLAINABLE",
+            violationsChecked: 0,
+            violationsComplete: 0,
+        };
+    }
+    const missingFields = [];
+    let violationsComplete = 0;
+    for (let i = 0; i < violations.length; i++) {
+        const v = violations[i];
+        const missing = getMissingFields(v);
+        if (missing.length === 0) {
+            violationsComplete++;
+        }
+        else {
+            missingFields.push({ index: i, missing });
+        }
+    }
+    const status = missingFields.length === 0 ? "EXPLAINABLE" : "UNCERTAIN";
+    return {
+        status,
+        violationsChecked: violations.length,
+        violationsComplete,
+        missingFields: missingFields.length > 0 ? missingFields : undefined,
+    };
+}
+// ── Helpers ──
+/**
+ * Returns the list of required fields that are missing or empty in a violation.
+ */
+function getMissingFields(v) {
+    const missing = [];
+    for (const field of types_1.TRUST_VIOLATION_REQUIRED_FIELDS) {
+        const value = v[field];
+        if (value === undefined || value === null) {
+            missing.push(field);
+        }
+        else if (typeof value === "string" && value.trim() === "") {
+            missing.push(field);
+        }
+    }
+    return missing;
+}
+/**
+ * Type guard: checks if a partial violation object satisfies the full
+ * TrustViolation interface (all required fields present and non-empty).
+ */
+function assertSixTuple(v) {
+    if (!v)
+        return false;
+    return getMissingFields(v).length === 0;
+}
+/**
+ * Convenience: quickly check if a single violation is complete.
+ */
+function isViolationComplete(v) {
+    return getMissingFields(v).length === 0;
+}

package/dist/trust/formatters/ci.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * CI/CD output formatter — compact one-line summary for pipeline logs.
+ *
+ * Format: [PROGMUNE] <DECISION> score=<N> violations=<N> coverage=<N%> <LEVEL>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTrustCI = formatTrustCI;
+exports.ciExitCode = ciExitCode;
+function formatTrustCI(decision) {
+    const { overall, summary, dimensions } = decision;
+    const mc = overall.mappingCoverage;
+    const parts = [
+        "[PROGMUNE]",
+        overall.decision,
+        `score=${overall.score}`,
+        `violations=${summary.total}`,
+    ];
+    if (mc) {
+        parts.push(`coverage=${mc.rate}%`);
+    }
+    parts.push(`conf=${overall.confidence}`);
+    return parts.join(" ");
+}
+/**
+ * Returns the recommended CI exit code:
+ *   0 = APPROVED
+ *   2 = NEEDS_REVIEW
+ *   1 = BLOCKED
+ */
+function ciExitCode(decision) {
+    switch (decision.overall.decision) {
+        case "APPROVED":
+            return 0;
+        case "NEEDS_REVIEW":
+            return 2;
+        case "BLOCKED":
+            return 1;
+        default:
+            return 3;
+    }
+}

package/dist/trust/formatters/json.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Phase 1: Trust Report — JSON Formatter
+ *
+ * Machine-readable output for CI/CD pipelines.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTrustJSON = formatTrustJSON;
+function formatTrustJSON(decision, pretty) {
+    return JSON.stringify(decision, null, pretty !== false ? 2 : 0);
+}

package/dist/trust/formatters/terminal.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Phase 1: Trust Report — Terminal Formatter
+ *
+ * Produces a human-readable Trust Report following the
+ * AI Trust Decision Model v1 template (design doc §7).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTrustTerminal = formatTrustTerminal;
+// ANSI escape codes (matching src/audit/formatters/terminal.ts style)
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const CYAN = "\x1b[36m";
+const WHITE = "\x1b[37m";
+const BOX_H = "─";
+const BOX_V = "│";
+const BOX_TL = "╔";
+const BOX_TR = "╗";
+const BOX_BL = "╚";
+const BOX_BR = "╝";
+const BOX_ML = "╠";
+const BOX_MR = "╣";
+function colorScore(score) {
+    if (score >= 80)
+        return `${GREEN}${score}${RESET}`;
+    if (score >= 60)
+        return `${YELLOW}${score}${RESET}`;
+    return `${RED}${score}${RESET}`;
+}
+function decisionEmoji(decision) {
+    switch (decision) {
+        case "APPROVED": return `${GREEN}✅ APPROVED${RESET}`;
+        case "NEEDS_REVIEW": return `${YELLOW}⚠️  NEEDS_REVIEW${RESET}`;
+        case "BLOCKED": return `${RED}❌ BLOCKED${RESET}`;
+        default: return decision;
+    }
+}
+function confidenceLabel(confidence) {
+    switch (confidence) {
+        case "HIGH": return `${GREEN}HIGH${RESET}`;
+        case "MEDIUM": return `${YELLOW}MEDIUM${RESET}`;
+        case "LOW": return `${RED}LOW${RESET}`;
+        case "UNCERTAIN": return `${RED}UNCERTAIN${RESET}`;
+        default: return confidence;
+    }
+}
+function formatTrustTerminal(decision) {
+    const { overall, dimensions, violations, violationTraces, summary, auditTrail } = decision;
+    const w = 68; // wider box for coverage data
+    const lines = [];
+    // Header
+    lines.push(`${BOLD}${BOX_TL}${BOX_H.repeat(w - 2)}${BOX_TR}${RESET}`);
+    lines.push(`${BOLD}${BOX_V}${RESET}  ${BOLD}Progmune Trust Report${RESET}${" ".repeat(w - 27)}${BOX_V}`);
+    lines.push(`${BOLD}${BOX_ML}${BOX_H.repeat(w - 2)}${BOX_MR}${RESET}`);
+    // Overall
+    const scoreStr = colorScore(overall.score);
+    const scoreLabel = overall.score >= 80 ? "HEALTHY" : overall.score >= 60 ? "CAUTION" : "AT RISK";
+    const scoreColor = overall.score >= 80 ? GREEN : overall.score >= 60 ? YELLOW : RED;
+    lines.push(`${BOX_V}  ${BOLD}Overall Trust Score  ${scoreStr} / 100           ${scoreColor}${scoreLabel}${RESET}  ${BOX_V}`);
+    lines.push(`${BOX_V}  ${BOLD}Decision             ${decisionEmoji(overall.decision)}${" ".repeat(Math.max(0, 14 - overall.decision.length))}         ${BOX_V}`);
+    lines.push(`${BOX_V}  ${BOLD}Confidence           ${confidenceLabel(overall.confidence)}${" ".repeat(24)}${BOX_V}`);
+    // Phase 1: Coverage-based confidence (quantified)
+    if (overall.coverageConfidence) {
+        const cc = overall.coverageConfidence;
+        const ccColor = cc.level === "HIGH" ? GREEN : cc.level === "MEDIUM" ? YELLOW : RED;
+        lines.push(`${BOX_V}${" ".repeat(w - 2)}${BOX_V}`);
+        lines.push(`${BOX_V}  ${BOLD}Coverage Confidence${RESET}  ${ccColor}${cc.score}%${RESET} ${DIM}±${cc.margin}%${RESET}   ${ccColor}${cc.level}${RESET}${" ".repeat(Math.max(0, w - 48))}${BOX_V}`);
+        lines.push(`${BOX_V}  ${DIM}${cc.summary.slice(0, w - 5)}${RESET}`);
+    }
+    lines.push(`${BOX_V}${" ".repeat(w - 2)}${BOX_V}`);
+    // Key Findings
+    lines.push(`${BOX_ML}${BOX_H.repeat(w - 2)}${BOX_MR}`);
+    lines.push(`${BOX_V}  ${BOLD}Key Findings${RESET}${" ".repeat(w - 17)}${BOX_V}`);
+    lines.push(`${BOX_V}${" ".repeat(w - 2)}${BOX_V}`);
+    if (summary.critical > 0) {
+        lines.push(`${BOX_V}  ${RED}❌  ${summary.critical} Critical policy violation(s)${RESET}${" ".repeat(Math.max(0, w - 38))}${BOX_V}`);
+    }
+    else {
+        lines.push(`${BOX_V}  ${GREEN}✅  0 Critical policy violations${RESET}${" ".repeat(w - 36)}${BOX_V}`);
+    }
+    if (dimensions.protocolSafety.score >= 90) {
+        lines.push(`${BOX_V}  ${GREEN}✅  Protocol safety verified${RESET}${" ".repeat(w - 31)}${BOX_V}`);
+    }
+    else if (dimensions.protocolSafety.score >= 70) {
+        lines.push(`${BOX_V}  ${YELLOW}⚠️   Protocol safety — issues detected${RESET}${" ".repeat(w - 41)}${BOX_V}`);
+    }
+    else {
+        lines.push(`${BOX_V}  ${RED}❌  Protocol safety degraded${RESET}${" ".repeat(w - 30)}${BOX_V}`);
+    }
+    if (dimensions.governanceIntegrity.score >= 95) {
+        lines.push(`${BOX_V}  ${GREEN}✅  Governance chain complete${RESET}${" ".repeat(w - 31)}${BOX_V}`);
+    }
+    else {
+        lines.push(`${BOX_V}  ${RED}❌  Governance integrity issues${RESET}${" ".repeat(w - 34)}${BOX_V}`);
+    }
+    if (summary.high > 0 || summary.medium > 0) {
+        lines.push(`${BOX_V}  ${YELLOW}⚠️   ${summary.high} High, ${summary.medium} Medium severity issue(s) require attention${RESET}${" ".repeat(Math.max(0, w - 62))}${BOX_V}`);
+    }
+    lines.push(`${BOX_V}${" ".repeat(w - 2)}${BOX_V}`);
+    // Evidence section
+    if (violations.length > 0) {
+        lines.push(`${BOX_ML}${BOX_H.repeat(w - 2)}${BOX_MR}`);
+        lines.push(`${BOX_V}  ${BOLD}Evidence${RESET}${" ".repeat(w - 13)}${BOX_V}`);
+        lines.push(`${BOX_V}${" ".repeat(w - 2)}${BOX_V}`);
+        for (let vi = 0; vi < Math.min(violations.length, 10); vi++) {
+            const v = violations[vi];
+            const trace = violationTraces?.[vi];
+            const sevIcon = v.severity === "critical" ? "❌" : v.severity === "high" ? "⚠️ " : v.severity === "medium" ? "●" : "○";
+            const sevColor = v.severity === "critical" ? RED : v.severity === "high" ? YELLOW : CYAN;
+            lines.push(`${BOX_V}  ${sevColor}${sevIcon} ${v.rule_id.padEnd(12).slice(0, 12)}${RESET} ${BOLD}${v.severity.toUpperCase()}${RESET}`);
+            lines.push(`${BOX_V}  ${DIM}${v.message.slice(0, w - 5)}${RESET}`);
+            lines.push(`${BOX_V}  ${DIM}Evidence: ${v.evidence.slice(0, w - 14)}${RESET}`);
+            // Phase 3: Violation trace (reasoning chain)
+            if (trace && trace.steps.length > 0) {
+                const violStep = trace.steps.find((s) => s.label && s.action);
+                if (violStep) {
+                    lines.push(`${BOX_V}  ${DIM}Trace:   ${violStep.action} → ${violStep.preState} → ${violStep.explanation.slice(0, 30)}${RESET}`);
+                }
+                if (trace.fixPath.length > 0) {
+                    lines.push(`${BOX_V}  ${DIM}Fix:     ${trace.fixPath.join(" → ").slice(0, w - 13)}${RESET}`);
+                }
+                if (trace.estimatedReadingTimeMinutes) {
+                    lines.push(`${BOX_V}  ${DIM}Reading: ~${trace.estimatedReadingTimeMinutes}min${RESET}`);
+                }
+            }
+            else {
+                lines.push(`${BOX_V}  ${DIM}Fix:     ${v.fix.slice(0, w - 13)}${RESET}`);
+            }
+            lines.push(`${BOX_V}  ${DIM}Policy:  ${v.policy_ref}${RESET}`);
+            lines.push(`${BOX_V}${" ".repeat(w - 2)}${BOX_V}`);
+        }
+        if (violations.length > 10) {
+            lines.push(`${BOX_V}  ${DIM}... and ${violations.length - 10} more violation(s)${RESET}${" ".repeat(Math.max(0, w - 32))}${BOX_V}`);
+            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}`);
+    lines.push(`${BOX_V}${" ".repeat(w - 2)}${BOX_V}`);
+    lines.push(`${BOX_V}  Commit          ${auditTrail.commit.slice(0, 24).padEnd(24)} ${BOX_V}`);
+    lines.push(`${BOX_V}  Policy Version   ${auditTrail.policyVersion.padEnd(24)} ${BOX_V}`);
+    lines.push(`${BOX_V}  Engine Version   ${auditTrail.engineVersion.padEnd(24)} ${BOX_V}`);
+    lines.push(`${BOX_V}  Generated At     ${auditTrail.generatedAt.slice(0, 19).padEnd(24)} ${BOX_V}`);
+    lines.push(`${BOX_V}  Reproducible     ${auditTrail.reproducible ? "Yes" : "No"}                        ${BOX_V}`);
+    lines.push(`${BOLD}${BOX_BL}${BOX_H.repeat(w - 2)}${BOX_BR}${RESET}`);
+    return lines.join("\n") + "\n";
+}

package/dist/trust/index.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Phase 1: Trust Module — Public API
+ *
+ * Re-exports all public types and functions from the Trust Engine.
+ */
+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 = exports.formatTrustJSON = exports.formatTrustTerminal = exports.countViolationsBySeverity = exports.determineConfidence = exports.determineDecision = exports.calculateOverallScore = exports.scoreGovernanceIntegrity = exports.scoreVerificationCoverage = exports.scoreProtocolSafety = exports.scorePolicyCompliance = exports.isViolationComplete = exports.assertSixTuple = exports.checkExplainability = exports.evaluateTrust = void 0;
+// Engine
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "evaluateTrust", { enumerable: true, get: function () { return engine_1.evaluateTrust; } });
+// Explainability
+var explainability_1 = require("./explainability");
+Object.defineProperty(exports, "checkExplainability", { enumerable: true, get: function () { return explainability_1.checkExplainability; } });
+Object.defineProperty(exports, "assertSixTuple", { enumerable: true, get: function () { return explainability_1.assertSixTuple; } });
+Object.defineProperty(exports, "isViolationComplete", { enumerable: true, get: function () { return explainability_1.isViolationComplete; } });
+// Score Calculator
+var score_calculator_1 = require("./score-calculator");
+Object.defineProperty(exports, "scorePolicyCompliance", { enumerable: true, get: function () { return score_calculator_1.scorePolicyCompliance; } });
+Object.defineProperty(exports, "scoreProtocolSafety", { enumerable: true, get: function () { return score_calculator_1.scoreProtocolSafety; } });
+Object.defineProperty(exports, "scoreVerificationCoverage", { enumerable: true, get: function () { return score_calculator_1.scoreVerificationCoverage; } });
+Object.defineProperty(exports, "scoreGovernanceIntegrity", { enumerable: true, get: function () { return score_calculator_1.scoreGovernanceIntegrity; } });
+Object.defineProperty(exports, "calculateOverallScore", { enumerable: true, get: function () { return score_calculator_1.calculateOverallScore; } });
+Object.defineProperty(exports, "determineDecision", { enumerable: true, get: function () { return score_calculator_1.determineDecision; } });
+Object.defineProperty(exports, "determineConfidence", { enumerable: true, get: function () { return score_calculator_1.determineConfidence; } });
+Object.defineProperty(exports, "countViolationsBySeverity", { enumerable: true, get: function () { return score_calculator_1.countViolationsBySeverity; } });
+// Formatters
+var terminal_1 = require("./formatters/terminal");
+Object.defineProperty(exports, "formatTrustTerminal", { enumerable: true, get: function () { return terminal_1.formatTrustTerminal; } });
+var json_1 = require("./formatters/json");
+Object.defineProperty(exports, "formatTrustJSON", { enumerable: true, get: function () { return json_1.formatTrustJSON; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "TRUST_VIOLATION_REQUIRED_FIELDS", { enumerable: true, get: function () { return types_1.TRUST_VIOLATION_REQUIRED_FIELDS; } });
+Object.defineProperty(exports, "DEFAULT_DIMENSION_WEIGHTS", { enumerable: true, get: function () { return types_1.DEFAULT_DIMENSION_WEIGHTS; } });
+Object.defineProperty(exports, "DEFAULT_SEVERITY_DEDUCTIONS", { enumerable: true, get: function () { return types_1.DEFAULT_SEVERITY_DEDUCTIONS; } });
+Object.defineProperty(exports, "DEFAULT_PROTOCOL_WEIGHTS", { enumerable: true, get: function () { return types_1.DEFAULT_PROTOCOL_WEIGHTS; } });
+Object.defineProperty(exports, "DEFAULT_COVERAGE_MAX_SCORES", { enumerable: true, get: function () { return types_1.DEFAULT_COVERAGE_MAX_SCORES; } });
+Object.defineProperty(exports, "DEFAULT_GOVERNANCE_DEDUCTIONS", { enumerable: true, get: function () { return types_1.DEFAULT_GOVERNANCE_DEDUCTIONS; } });
+Object.defineProperty(exports, "DECISION_THRESHOLDS", { enumerable: true, get: function () { return types_1.DECISION_THRESHOLDS; } });

package/dist/trust/phase1-verify.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * Phase 1 MVP Verification Script
+ *
+ * Tests the API → Protocol Semantic Mapper + Domain Validator
+ * against all 25 B-class FPs from the curl benchmark.
+ *
+ * Expected outcome: all 25 FPs correctly classified as CLEAN,
+ * proving that the semantic mapping layer eliminates B-class FPs.
+ *
+ * Run: npx ts-node --transpile-only src/trust/phase1-verify.ts
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ═══════════════════════════════════════════════════════════════
+// Inline the mapper and validator imports (avoid module resolution issues)
+// ═══════════════════════════════════════════════════════════════
+// We need to import from the mapper — use require for simplicity
+const { mapSequenceToSemantic, isKnownProtocolDomain, mapApiToSemantic, } = require("./api-semantic-mapper");
+const { validateSemanticSequence, batchValidateSequences, } = require("./protocol-domain-validator");
+// ═══════════════════════════════════════════════════════════════
+// B-class FP indices from our Phase 0 analysis
+// ═══════════════════════════════════════════════════════════════
+const B_CLASS_INDICES = new Set([
+    4, 5, 11, 12, 15, 31, 34, 36, 42, 47, 48, 51, 52,
+    55, 56, 60, 62, 63, 66, 67, 70, 78, 79, 81, 88,
+]);
+function loadBenchmarkData() {
+    const benchPath = path.resolve(__dirname, "../../benchmarks/reports/cross-repo-precision-latest.json");
+    const data = JSON.parse(fs.readFileSync(benchPath, "utf-8"));
+    const curl = data.repos.find((r) => r.repo === "curl");
+    const mismatches = curl.mismatches.filter((m) => m.expected === "clean" && m.got === "violation");
+    return {
+        fps: mismatches.filter((m) => B_CLASS_INDICES.has(m.index)),
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// Main Validation
+// ═══════════════════════════════════════════════════════════════
+function main() {
+    console.log("═══════════════════════════════════════════════════════");
+    console.log("  Phase 1 MVP — B 类 FP 消除验证");
+    console.log("═══════════════════════════════════════════════════════");
+    console.log("");
+    const { fps } = loadBenchmarkData();
+    console.log(`加载 B 类 FP: ${fps.length} 个`);
+    console.log("");
+    // ── Individual FP analysis ──
+    let eliminatedCount = 0;
+    let stillFlaggedCount = 0;
+    const stillFlagged = [];
+    const problematicMappings = [];
+    for (const fp of fps) {
+        const semantic = mapSequenceToSemantic(fp.calls);
+        // Filter noise domains for display
+        const significantSteps = semantic.steps.filter((s) => s.domain !== "util" && s.domain !== "mem_util" && s.domain !== "str_util");
+        const validation = validateSemanticSequence(semantic);
+        if (validation.valid) {
+            eliminatedCount++;
+        }
+        else {
+            stillFlaggedCount++;
+            stillFlagged.push(fp);
+        }
+        // Check for problematic mappings (util fallbacks that should be known)
+        for (const step of semantic.steps) {
+            if (step.domain === "util" && step.source === "lookup") {
+                // Only flag if it's a significant-looking API (not a common word)
+                if (step.api.length > 3 && !/^(buffer|bytes|block|files|directories|size|seek|writing|secrets|handshake|allowed|conditions|status|keys|accessed|delay|secret|startup|argument|info|time|proc|set|get|part|chars|name|type|state|data|list|are|hostname|scheme|literal|failed)$/i.test(step.api)) {
+                    problematicMappings.push({
+                        api: step.api,
+                        reason: `API "${step.api}" maps to "util" — may need a mapping rule`,
+                    });
+                }
+            }
+        }
+    }
+    // ── Results ──
+    console.log("── 判定结果 ──");
+    console.log(`  ✅ 正确判定为 CLEAN: ${eliminatedCount}/${fps.length} (${(eliminatedCount / fps.length * 100).toFixed(1)}%)`);
+    console.log(`  ❌ 仍然误报:       ${stillFlaggedCount}/${fps.length} (${(stillFlaggedCount / fps.length * 100).toFixed(1)}%)`);
+    console.log("");
+    if (stillFlagged.length > 0) {
+        console.log("── 仍然误报的 FP ──");
+        for (const fp of stillFlagged) {
+            const semantic = mapSequenceToSemantic(fp.calls);
+            const validation = validateSemanticSequence(semantic);
+            console.log(`  idx=${fp.index}: ${validation.reason}`);
+            const domains = [...new Set(semantic.steps.map((s) => s.domain))];
+            console.log(`    domains: ${domains.join(", ")}`);
+            console.log(`    primary: ${semantic.primaryDomain}`);
+        }
+        console.log("");
+    }
+    // ── Per-FP details ──
+    console.log("── 逐条详情 ──");
+    for (const fp of fps) {
+        const semantic = mapSequenceToSemantic(fp.calls);
+        const validation = validateSemanticSequence(semantic);
+        const status = validation.valid ? "✅ CLEAN" : "❌ FLAGGED";
+        console.log(`  ${status}  idx=${fp.index}  primary=${semantic.primaryDomain || "none"}  groups=${validation.groups.join(",") || "none"}`);
+    }
+    console.log("");
+    // ── Problematic mappings ──
+    if (problematicMappings.length > 0) {
+        console.log("── 需要关注的映射 (映射为 util 的重要 API) ──");
+        const unique = new Set(problematicMappings.map(m => m.api));
+        for (const api of [...unique].sort()) {
+            console.log(`  ⚠️  ${api}`);
+        }
+        console.log("");
+    }
+    // ── Overall Phase 1 assessment ──
+    console.log("═══════════════════════════════════════════════════════");
+    console.log("  Phase 1 MVP 判定");
+    console.log("═══════════════════════════════════════════════════════");
+    console.log("");
+    const passThreshold = 20; // Phase 0 threshold: ≥20/25
+    if (eliminatedCount >= passThreshold) {
+        console.log(`  ✅ 通过！${eliminatedCount}/${fps.length} B 类 FP 被消除 (阈值: ${passThreshold})`);
+        console.log("");
+        console.log("  Phase 1 MVP 验证成功。语义映射层可以有效消除 B 类 FP。");
+        if (eliminatedCount === fps.length) {
+            console.log("  100% 消除率 — 所有 B 类 FP 都被正确识别为 CLEAN。");
+        }
+        console.log("");
+        console.log("  下一步:");
+        console.log("  1. 将映射层集成到 Trust Engine (修改 engine.ts)");
+        console.log("  2. 在 curl 完整基准测试上验证精度提升");
+        console.log("  3. Phase 2: 添加 C 类 FP 处理");
+    }
+    else {
+        console.log(`  ❌ 未通过。${eliminatedCount}/${fps.length} < 阈值 ${passThreshold}`);
+        console.log("  需要检查映射表和域验证逻辑。");
+    }
+}
+main();