progmune-runtime 2.1.6 → 3.2.0

package/dist/coverage-dashboard.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * P3.6: Coverage Dashboard
+ *
+ * Visualizes protocol coverage gaps, ranks protocols by risk,
+ * and generates acquisition priorities.
+ *
+ * The dashboard answers:
+ *   - Which protocols are fully observed? Which are data-poor?
+ *   - Where should we collect more data next?
+ *   - What transitions should we benchmark first?
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assessRisk = assessRisk;
+exports.generateCoverageDashboard = generateCoverageDashboard;
+exports.printCoverageDashboard = printCoverageDashboard;
+const protocol_coverage_1 = require("./protocol-coverage");
+const failure_corpus_1 = require("./failure-corpus");
+function assessRisk(report) {
+    const sc = report.stateCoverage.stateCoverage;
+    const tc = report.transitionCoverage.transitionCoverage;
+    const avg = (sc + tc) / 2;
+    let risk;
+    let recommendation;
+    if (avg < 0.25) {
+        risk = "critical";
+        recommendation = `Immediate: add ${report.transitionCoverage.missingTransitions.length} benchmark cases for uncovered transitions`;
+    }
+    else if (avg < 0.50) {
+        risk = "high";
+        recommendation = `Priority: focus on missing ${report.stateCoverage.missingStates.length} states and ${report.transitionCoverage.missingTransitions.length} transitions`;
+    }
+    else if (avg < 0.75) {
+        risk = "medium";
+        recommendation = `Fill remaining gaps: ${report.transitionCoverage.missingTransitions.length} transitions uncovered`;
+    }
+    else {
+        risk = "low";
+        recommendation = "Well-covered. Monitor for regressions.";
+    }
+    return {
+        protocol: report.protocol,
+        stateCoverage: sc,
+        transitionCoverage: tc,
+        trajectoryCount: report.trajectoryCount,
+        risk,
+        missingTransitionCount: report.transitionCoverage.missingTransitions.length,
+        recommendation,
+    };
+}
+function generateCoverageDashboard(trajectories) {
+    const trajs = trajectories || (0, failure_corpus_1.loadTrajectories)();
+    const protocols = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+    const reports = (0, protocol_coverage_1.analyzeAllCoverage)(protocols, trajs);
+    const risks = reports.map(assessRisk).sort((a, b) => a.transitionCoverage - b.transitionCoverage);
+    const totalStates = reports.reduce((s, r) => s + r.stateCoverage.totalStates, 0);
+    const visitedStates = reports.reduce((s, r) => s + r.stateCoverage.visitedStates, 0);
+    const totalTrans = reports.reduce((s, r) => s + r.transitionCoverage.totalTransitions, 0);
+    const visitedTrans = reports.reduce((s, r) => s + r.transitionCoverage.visitedTransitions, 0);
+    return {
+        reports,
+        riskRanking: risks,
+        overallStateCoverage: totalStates > 0 ? visitedStates / totalStates : 0,
+        overallTransitionCoverage: totalTrans > 0 ? visitedTrans / totalTrans : 0,
+        totalTrajectories: trajs.length,
+        criticalProtocols: risks.filter(r => r.risk === "critical" || r.risk === "high").length,
+    };
+}
+function printCoverageDashboard(dashboard) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   Protocol Coverage Dashboard                      ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Trajectories Analyzed: ${dashboard.totalTrajectories}`);
+    console.log(`Overall State Coverage:      ${(dashboard.overallStateCoverage * 100).toFixed(0)}%`);
+    console.log(`Overall Transition Coverage: ${(dashboard.overallTransitionCoverage * 100).toFixed(0)}%`);
+    console.log(`Critical/High Risk Protocols: ${dashboard.criticalProtocols}\n`);
+    console.log("─── By Protocol ───");
+    console.log("Protocol          State   Trans   Trajs  Risk");
+    console.log("────────────────────────────────────────────────");
+    for (const r of dashboard.riskRanking) {
+        const riskIcon = r.risk === "critical" ? "🔴" : r.risk === "high" ? "🟠" : r.risk === "medium" ? "🟡" : "🟢";
+        const sc = (r.stateCoverage * 100).toFixed(0).padStart(3);
+        const tc = (r.transitionCoverage * 100).toFixed(0).padStart(3);
+        console.log(`  ${r.protocol.padEnd(16)} ${sc}%   ${tc}%   ${String(r.trajectoryCount).padStart(4)}  ${riskIcon} ${r.risk}`);
+    }
+    console.log();
+    // Missing transitions detail for high-risk protocols
+    const criticalReports = dashboard.reports.filter(r => assessRisk(r).risk === "critical" || assessRisk(r).risk === "high");
+    if (criticalReports.length > 0) {
+        console.log("─── Highest Risk: Missing Transitions ───");
+        for (const r of criticalReports) {
+            const missing = r.transitionCoverage.missingTransitions.slice(0, 5);
+            if (missing.length === 0)
+                continue;
+            console.log(`\n  ${r.protocol} (${r.transitionCoverage.missingTransitions.length} missing):`);
+            for (const m of missing) {
+                console.log(`    ${m.from} → ${m.to}  (via ${m.rule})`);
+            }
+        }
+        console.log();
+    }
+    console.log("─── Recommendations ───");
+    for (const r of dashboard.riskRanking) {
+        if (r.risk === "critical" || r.risk === "high") {
+            console.log(`  ${r.protocol}: ${r.recommendation}`);
+        }
+    }
+    console.log();
+}

package/dist/coverage-system.test.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * P3.6: Coverage System Integration Tests
+ *
+ * Verifying:
+ *   1. Coverage engine correctly computes state/transition coverage
+ *   2. Dashboard visualizes gaps and risk ranking
+ *   3. Benchmark generator produces cases for uncovered transitions
+ *   4. End-to-end: analyze → generate → new cases
+ */
+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 vitest_1 = require("vitest");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const protocol_coverage_1 = require("./protocol-coverage");
+const coverage_dashboard_1 = require("./coverage-dashboard");
+const benchmark_generator_1 = require("./benchmark-generator");
+// ═══════════════════════════════════════════════════════════════
+// Coverage Engine
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("Coverage Engine", () => {
+    function makeFileRules() {
+        return new Map([
+            ["open_file", { pre_states: [], post_states: ["FILE_OPEN"] }],
+            ["write_file", { pre_states: ["FILE_OPEN"], post_states: ["FILE_DIRTY"] }],
+            ["close_file", { pre_states: ["FILE_OPEN", "FILE_DIRTY"], post_states: [], invalidate: ["FILE_OPEN", "FILE_DIRTY"] }],
+        ]);
+    }
+    const fileProto = (0, protocol_coverage_1.parseProtocolDefinition)("FileProtocol", makeFileRules(), "INIT");
+    (0, vitest_1.it)("computes full coverage when all transitions visited", () => {
+        const trajectories = [{
+                id: "t1", timestamp: new Date().toISOString(),
+                protocol: "FileProtocol", initialState: ["INIT"], finalState: [],
+                trajectory: ["open_file", "write_file", "close_file"],
+                result: "success", context: { nestingDepth: 0, exceptionHandled: false, insideLoop: false, branchCount: 0, asyncContext: false },
+                successRate: 1.0, metadata: { source: "human" },
+            }];
+        const report = (0, protocol_coverage_1.analyzeCoverage)(fileProto, trajectories);
+        (0, vitest_1.expect)(report.transitionCoverage.transitionCoverage).toBeGreaterThan(0.5);
+        (0, vitest_1.expect)(report.stateCoverage.stateCoverage).toBeGreaterThan(0.5);
+    });
+    (0, vitest_1.it)("detects uncovered transitions", () => {
+        const trajectories = [{
+                id: "t2", timestamp: new Date().toISOString(),
+                protocol: "FileProtocol", initialState: ["INIT"], finalState: [],
+                trajectory: ["open_file", "close_file"], // missing write_file
+                result: "success", context: { nestingDepth: 0, exceptionHandled: false, insideLoop: false, branchCount: 0, asyncContext: false },
+                successRate: 1.0, metadata: { source: "human" },
+            }];
+        const report = (0, protocol_coverage_1.analyzeCoverage)(fileProto, trajectories);
+        (0, vitest_1.expect)(report.transitionCoverage.missingTransitions.length).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("empty trajectories = zero coverage", () => {
+        const report = (0, protocol_coverage_1.analyzeCoverage)(fileProto, []);
+        (0, vitest_1.expect)(report.transitionCoverage.transitionCoverage).toBe(0);
+        (0, vitest_1.expect)(report.stateCoverage.stateCoverage).toBe(0);
+        (0, vitest_1.expect)(report.trajectoryCount).toBe(0);
+    });
+});
+// ═══════════════════════════════════════════════════════════════
+// Default Protocol Definitions
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("Default Protocol Definitions", () => {
+    (0, vitest_1.it)("loads all 9 protocol groups", () => {
+        const protocols = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+        (0, vitest_1.expect)(protocols.length).toBeGreaterThanOrEqual(9);
+        const names = protocols.map(p => p.name);
+        (0, vitest_1.expect)(names).toContain("FileProtocol");
+        (0, vitest_1.expect)(names).toContain("AuthProtocol");
+        (0, vitest_1.expect)(names).toContain("DBProtocol");
+        (0, vitest_1.expect)(names).toContain("IRProtocol");
+        (0, vitest_1.expect)(names).toContain("StatelessProtocol");
+        (0, vitest_1.expect)(names).toContain("TransactionProtocol");
+        (0, vitest_1.expect)(names).toContain("ConditionalProtocol");
+        (0, vitest_1.expect)(names).toContain("LoopProtocol");
+        (0, vitest_1.expect)(names).toContain("CrossProtocol");
+    });
+    (0, vitest_1.it)("each protocol (except stateless) has states and transitions", () => {
+        for (const p of (0, protocol_coverage_1.loadDefaultProtocolDefinitions)()) {
+            (0, vitest_1.expect)(p.states.length).toBeGreaterThan(0);
+            // StatelessProtocol has empty pre/post states → 0 acquire transitions
+            if (p.name === "StatelessProtocol") {
+                (0, vitest_1.expect)(p.transitions.length).toBeGreaterThanOrEqual(0);
+            }
+            else {
+                (0, vitest_1.expect)(p.transitions.length).toBeGreaterThan(0);
+            }
+        }
+    });
+    (0, vitest_1.it)("FileProtocol has open/write/close transitions", () => {
+        const file = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)().find(p => p.name === "FileProtocol");
+        const tKeys = file.transitions.map(t => `${t.from}→${t.to}`);
+        (0, vitest_1.expect)(tKeys).toContain("INIT→FILE_OPEN"); // open_file
+        (0, vitest_1.expect)(tKeys).toContain("FILE_OPEN→∅"); // close_file invalidates FILE_OPEN
+    });
+    (0, vitest_1.it)("AuthProtocol has auth lifecycle transitions", () => {
+        const auth = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)().find(p => p.name === "AuthProtocol");
+        const tKeys = auth.transitions.map(t => `${t.from}→${t.to}`);
+        (0, vitest_1.expect)(tKeys).toContain("UNAUTHENTICATED→PASSWORD_VERIFIED"); // verify_password
+        (0, vitest_1.expect)(tKeys).toContain("PASSWORD_VERIFIED→TOKEN_ISSUED"); // generate_jwt
+        (0, vitest_1.expect)(tKeys).toContain("TOKEN_ISSUED→SESSION_ACTIVE"); // create_session
+        (0, vitest_1.expect)(tKeys).toContain("SESSION_ACTIVE→UNAUTHENTICATED"); // logout
+    });
+});
+// ═══════════════════════════════════════════════════════════════
+// Coverage Dashboard
+// ═══════════════════════════════════════════════════════════════
+const GEN_DIR = path.resolve(__dirname, "..", "test-coverage-gen");
+process.env.PROGMUNE_PROJECT_DIR = GEN_DIR;
+fs.mkdirSync(GEN_DIR, { recursive: true });
+fs.mkdirSync(path.join(GEN_DIR, ".progmune_corpus", "trajectories"), { recursive: true });
+(0, vitest_1.describe)("Coverage Dashboard", () => {
+    (0, vitest_1.it)("generates dashboard from current trajectories", () => {
+        const dashboard = (0, coverage_dashboard_1.generateCoverageDashboard)([]);
+        (0, vitest_1.expect)(dashboard.reports.length).toBeGreaterThanOrEqual(9);
+        (0, vitest_1.expect)(dashboard.riskRanking.length).toBeGreaterThanOrEqual(9);
+        (0, vitest_1.expect)(dashboard.overallTransitionCoverage).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(dashboard.overallTransitionCoverage).toBeLessThanOrEqual(1);
+        (0, vitest_1.expect)(dashboard.criticalProtocols).toBeGreaterThanOrEqual(0);
+        (0, coverage_dashboard_1.printCoverageDashboard)(dashboard);
+    });
+    (0, vitest_1.it)("correctly ranks empty protocols as critical", () => {
+        const dashboard = (0, coverage_dashboard_1.generateCoverageDashboard)([]);
+        // With zero trajectories, all protocols should be critical or high risk
+        const emptyProtocols = dashboard.riskRanking.filter(r => r.trajectoryCount === 0);
+        for (const r of emptyProtocols) {
+            (0, vitest_1.expect)(r.stateCoverage).toBe(0);
+            (0, vitest_1.expect)(r.transitionCoverage).toBe(0);
+            (0, vitest_1.expect)(r.risk).toBe("critical");
+        }
+    });
+});
+// ═══════════════════════════════════════════════════════════════
+// Benchmark Generator
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("Benchmark Generator", () => {
+    (0, vitest_1.it)("generates cases for uncovered transitions", () => {
+        const generated = (0, benchmark_generator_1.generateMissingBenchmarks)([]);
+        // With zero trajectories, all protocols have uncovered transitions
+        (0, vitest_1.expect)(Object.keys(generated).length).toBeGreaterThanOrEqual(3);
+        // Each protocol should have generated cases
+        for (const [protocol, cases] of Object.entries(generated)) {
+            (0, vitest_1.expect)(cases.length).toBeGreaterThan(0);
+            for (const c of cases) {
+                (0, vitest_1.expect)(c.broken.length).toBeGreaterThan(0);
+                (0, vitest_1.expect)(c.expected.length).toBeGreaterThan(0);
+                (0, vitest_1.expect)(c.expected.length).toBeGreaterThan(c.broken.length);
+                (0, vitest_1.expect)(["resource_leak", "missing_prerequisite"]).toContain(c.violationType);
+            }
+        }
+    });
+    (0, vitest_1.it)("writes generated benchmarks to disk", () => {
+        const generated = (0, benchmark_generator_1.generateMissingBenchmarks)([]);
+        const outDir = path.resolve(GEN_DIR, "generated-benchmarks");
+        const written = (0, benchmark_generator_1.writeGeneratedBenchmarks)(generated, outDir);
+        (0, vitest_1.expect)(written.length).toBeGreaterThanOrEqual(3);
+        // Verify files exist and are valid JSON
+        for (const filepath of written) {
+            (0, vitest_1.expect)(fs.existsSync(filepath)).toBe(true);
+            const content = JSON.parse(fs.readFileSync(filepath, "utf-8"));
+            (0, vitest_1.expect)(content.cases.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(content.source).toBe("coverage-gap");
+        }
+    });
+    (0, vitest_1.it)("runs the full coverage→generation pipeline", () => {
+        const result = (0, benchmark_generator_1.runCoverageDrivenGeneration)();
+        (0, vitest_1.expect)(result.existingCases).toBeGreaterThanOrEqual(1); // from previous test writes
+        (0, vitest_1.expect)(result.generatedCases).toBeGreaterThanOrEqual(10);
+        (0, vitest_1.expect)(result.writtenFiles.length).toBeGreaterThanOrEqual(3);
+        console.log(`\nCoverage-Driven Generation: ${result.summary}`);
+    });
+});

package/dist/cross-repo-precision.js

@@ -0,0 +1,352 @@
+"use strict";
+/**
+ * P1: Cross-Repository Precision Runner
+ *
+ * Runs the full SSG precision pipeline (discover → validate → measure)
+ * on every benchmark repo that has labeled sequences.
+ *
+ * Produces:
+ *   benchmarks/reports/cross-repo-precision-<date>.json
+ *   benchmarks/reports/cross-repo-precision-latest.json
+ *
+ * Usage:
+ *   npx ts-node --transpile-only src/cross-repo-precision.ts
+ *   npx ts-node --transpile-only src/cross-repo-precision.ts --repos curl,libssh
+ */
+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"));
+// ═══════════════════════════════════════════════════════════════
+// Per-Repo Precision Runner
+// ═══════════════════════════════════════════════════════════════
+function runPrecisionForRepo(repoName) {
+    const benchmarksDir = path.resolve(process.cwd(), "benchmarks");
+    const labelFile = path.join(benchmarksDir, `${repoName}-labels.json`);
+    const empty = {
+        repo: repoName,
+        status: "no_labels",
+        total: 0,
+        cleanLabels: 0,
+        violationLabels: 0,
+        tp: 0, fp: 0, tn: 0, fn: 0,
+        precision: 0, recall: 0, f1: 0,
+        falsePositiveRate: 0, falseNegativeRate: 0,
+        rulesDiscovered: 0,
+        mismatches: [],
+    };
+    if (!fs.existsSync(labelFile)) {
+        empty.error = `No labels file: ${labelFile}`;
+        return empty;
+    }
+    let data;
+    try {
+        data = JSON.parse(fs.readFileSync(labelFile, "utf-8"));
+    }
+    catch (e) {
+        empty.status = "error";
+        empty.error = `Parse error: ${e}`;
+        return empty;
+    }
+    const labels = data.labels || {};
+    const sequences = data.sequences || {};
+    const labeledIndices = Object.keys(labels).map(Number);
+    if (labeledIndices.length === 0) {
+        empty.error = "No labeled sequences";
+        return empty;
+    }
+    // Count label distribution
+    let cleanLabels = 0;
+    let violationLabels = 0;
+    const cleanSeqs = [];
+    for (const idx of labeledIndices) {
+        if (labels[idx] === "clean") {
+            cleanLabels++;
+            if (sequences[idx])
+                cleanSeqs.push(sequences[idx]);
+        }
+        else if (labels[idx] === "violation") {
+            violationLabels++;
+        }
+    }
+    // Discover SSG rules from clean sequences
+    let rules;
+    let nsInit;
+    try {
+        const { discoverRulesFromSequences, validateSequenceWithSSG } = require("./ssg-precision");
+        const result = discoverRulesFromSequences(cleanSeqs);
+        rules = result.rules;
+        nsInit = result.nsInit;
+    }
+    catch (e) {
+        empty.status = "error";
+        empty.error = `Rule discovery failed: ${e}`;
+        return empty;
+    }
+    // Validate all labeled sequences
+    let tp = 0, fp = 0, tn = 0, fn = 0;
+    const mismatches = [];
+    for (const idx of labeledIndices) {
+        const expected = labels[idx];
+        const calls = sequences[idx] || [];
+        let detected;
+        try {
+            const { validateSequenceWithSSG } = require("./ssg-precision");
+            const result = validateSequenceWithSSG(calls, rules, nsInit);
+            detected = result.valid ? "clean" : "violation";
+        }
+        catch {
+            detected = "clean"; // Can't validate → assume clean (conservative)
+        }
+        if (expected === "violation" && detected === "violation")
+            tp++;
+        else if (expected === "clean" && detected === "violation")
+            fp++;
+        else if (expected === "clean" && detected === "clean")
+            tn++;
+        else if (expected === "violation" && detected === "clean")
+            fn++;
+        if (expected !== detected) {
+            mismatches.push({ index: idx, expected, got: detected, calls });
+        }
+    }
+    const total = labeledIndices.length;
+    const precision = tp + fp > 0 ? tp / (tp + fp) : 0;
+    const recall = tp + fn > 0 ? tp / (tp + fn) : 0;
+    const f1 = precision + recall > 0
+        ? 2 * precision * recall / (precision + recall)
+        : 0;
+    const fpr = fp + tn > 0 ? fp / (fp + tn) : 0;
+    const fnr = fn + tp > 0 ? fn / (fn + tp) : 0;
+    return {
+        repo: repoName,
+        status: "measured",
+        total,
+        cleanLabels,
+        violationLabels,
+        tp, fp, tn, fn,
+        precision, recall, f1,
+        falsePositiveRate: fpr,
+        falseNegativeRate: fnr,
+        rulesDiscovered: rules.size,
+        mismatches,
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// Report Generator
+// ═══════════════════════════════════════════════════════════════
+function generateReport(repoNames) {
+    const repos = repoNames.map(runPrecisionForRepo);
+    const measured = repos.filter(r => r.status === "measured");
+    let totalTP = 0, totalFP = 0, totalFN = 0, totalSamples = 0;
+    for (const r of measured) {
+        totalTP += r.tp;
+        totalFP += r.fp;
+        totalFN += r.fn;
+        totalSamples += r.total;
+    }
+    const macroF1 = measured.length > 0
+        ? measured.reduce((s, r) => s + r.f1, 0) / measured.length
+        : 0;
+    const microPrecision = totalTP + totalFP > 0
+        ? totalTP / (totalTP + totalFP)
+        : 0;
+    const microRecall = totalTP + totalFN > 0
+        ? totalTP / (totalTP + totalFN)
+        : 0;
+    const microF1 = microPrecision + microRecall > 0
+        ? 2 * microPrecision * microRecall / (microPrecision + microRecall)
+        : 0;
+    const sortedByF1 = [...measured].sort((a, b) => b.f1 - a.f1);
+    const bestRepo = sortedByF1.length > 0 ? sortedByF1[0].repo : "N/A";
+    const worstRepo = sortedByF1.length > 1
+        ? sortedByF1[sortedByF1.length - 1].repo
+        : "N/A";
+    const avgFPR = measured.length > 0
+        ? measured.reduce((s, r) => s + r.falsePositiveRate, 0) / measured.length
+        : 0;
+    const avgFNR = measured.length > 0
+        ? measured.reduce((s, r) => s + r.falseNegativeRate, 0) / measured.length
+        : 0;
+    let assessment = "INSUFFICIENT DATA";
+    if (measured.length >= 3) {
+        if (microF1 >= 0.80)
+            assessment = "PRODUCTION READY";
+        else if (microF1 >= 0.65)
+            assessment = "BETA QUALITY";
+        else if (microF1 >= 0.50)
+            assessment = "ALPHA — NEEDS MORE DATA";
+        else
+            assessment = "EARLY STAGE";
+    }
+    else if (measured.length >= 1) {
+        assessment = "PILOT — EXPAND LABELING";
+    }
+    return {
+        generated: new Date().toISOString(),
+        version: "3.2.0",
+        repos,
+        overall: {
+            reposMeasured: measured.length,
+            totalSamples,
+            totalTP,
+            totalFP,
+            totalFN,
+            macroF1,
+            microPrecision,
+            microRecall,
+            microF1,
+            bestRepo,
+            worstRepo,
+            assessment,
+            avgFPRate: avgFPR,
+            avgFNRate: avgFNR,
+        },
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// Formatting
+// ═══════════════════════════════════════════════════════════════
+function formatReport(report) {
+    const lines = [];
+    const C = { bold: "", dim: "", green: "", red: "", yellow: "", cyan: "", reset: "" };
+    lines.push("");
+    lines.push("╔══════════════════════════════════════════════════════════════╗");
+    lines.push("║     Progmune Cross-Repository Precision Benchmark            ║");
+    lines.push("╠══════════════════════════════════════════════════════════════╣");
+    lines.push(`║  Generated: ${report.generated}  ║`);
+    lines.push(`║  Version:   v${report.version}                                              ║`);
+    lines.push("╚══════════════════════════════════════════════════════════════╝");
+    lines.push("");
+    // Per-repo table
+    const header = "┌─────────────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┐";
+    const sep = "├─────────────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┤";
+    const footer = "└─────────────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┘";
+    lines.push(header);
+    lines.push("│ Repo            │    P  │    R  │   F1  │   FP% │   FN% │   N   │ Rules │");
+    lines.push(sep);
+    for (const repo of report.repos) {
+        if (repo.status !== "measured") {
+            const status = repo.status === "no_labels" ? "no labels" : "error";
+            lines.push(`│ ${repo.repo.padEnd(15)} │   ${"-".padStart(3)}  │   ${"-".padStart(3)}  │   ${"-".padStart(3)}  │   ${"-".padStart(3)}  │   ${"-".padStart(3)}  │ ${String(repo.total || 0).padStart(4)}  │   ${"-".padStart(3)}  │`);
+            continue;
+        }
+        const p = (repo.precision * 100).toFixed(0);
+        const r = (repo.recall * 100).toFixed(0);
+        const f = (repo.f1 * 100).toFixed(0);
+        const fpr = (repo.falsePositiveRate * 100).toFixed(0);
+        const fnr = (repo.falseNegativeRate * 100).toFixed(0);
+        // Color-code F1
+        let fDisplay = `${f}%`;
+        if (repo.f1 >= 0.7)
+            fDisplay = `${f}% ★`;
+        else if (repo.f1 >= 0.5)
+            fDisplay = `${f}%`;
+        lines.push(`│ ${repo.repo.padEnd(15)} │ ${p.padStart(3)}% │ ${r.padStart(3)}% │ ${fDisplay.padStart(5)} │ ${fpr.padStart(3)}% │ ${fnr.padStart(3)}% │ ${String(repo.total).padStart(4)}  │ ${String(repo.rulesDiscovered).padStart(4)}  │`);
+    }
+    lines.push(sep);
+    const o = report.overall;
+    const op = (o.microPrecision * 100).toFixed(0);
+    const or_ = (o.microRecall * 100).toFixed(0);
+    const of1 = (o.microF1 * 100).toFixed(0);
+    const maF1 = (o.macroF1 * 100).toFixed(0);
+    lines.push(`│ OVERALL (micro)  │ ${op.padStart(3)}% │ ${or_.padStart(3)}% │ ${of1.padStart(3)}% │ ${(o.avgFPRate * 100).toFixed(0).padStart(3)}% │ ${(o.avgFNRate * 100).toFixed(0).padStart(3)}% │ ${String(o.totalSamples).padStart(4)}  │       │`);
+    lines.push(`│ OVERALL (macro)  │       │       │ ${maF1.padStart(3)}% │       │       │       │       │`);
+    lines.push(footer);
+    lines.push("");
+    // Summary
+    lines.push(`Repos measured: ${o.reposMeasured}/${report.repos.length}`);
+    lines.push(`Best repo:      ${o.bestRepo}`);
+    lines.push(`Worst repo:     ${o.worstRepo}`);
+    lines.push(`Avg FP Rate:    ${(o.avgFPRate * 100).toFixed(1)}%`);
+    lines.push(`Avg FN Rate:    ${(o.avgFNRate * 100).toFixed(1)}%`);
+    lines.push(`Assessment:     ${o.assessment}`);
+    lines.push("");
+    // Mismatches detail
+    const reposWithMismatches = report.repos.filter(r => r.mismatches.length > 0);
+    if (reposWithMismatches.length > 0) {
+        lines.push("── Mismatch Details ──");
+        for (const repo of reposWithMismatches) {
+            lines.push(`  ${repo.repo}: ${repo.mismatches.length} mismatches`);
+            for (const m of repo.mismatches.slice(0, 5)) {
+                const tag = m.expected === "clean" ? "FP" : "FN";
+                lines.push(`    [${tag}] #${m.index}: expected ${m.expected}, got ${m.got}`);
+                lines.push(`           ${m.calls.join(" → ")}`);
+            }
+            if (repo.mismatches.length > 5) {
+                lines.push(`    ... and ${repo.mismatches.length - 5} more`);
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+// ═══════════════════════════════════════════════════════════════
+// Save
+// ═══════════════════════════════════════════════════════════════
+function saveReport(report) {
+    const reportsDir = path.resolve(process.cwd(), "benchmarks", "reports");
+    if (!fs.existsSync(reportsDir))
+        fs.mkdirSync(reportsDir, { recursive: true });
+    const date = new Date().toISOString().slice(0, 10);
+    const filePath = path.join(reportsDir, `cross-repo-precision-${date}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(report, null, 2));
+    const latestPath = path.join(reportsDir, "cross-repo-precision-latest.json");
+    fs.writeFileSync(latestPath, JSON.stringify(report, null, 2));
+    console.log(`Reports saved:`);
+    console.log(`  ${filePath}`);
+    console.log(`  ${latestPath}`);
+}
+// ═══════════════════════════════════════════════════════════════
+// Main
+// ═══════════════════════════════════════════════════════════════
+function main() {
+    const args = process.argv.slice(2);
+    const repoArg = args.find(a => a.startsWith("--repos="));
+    const repoNames = repoArg
+        ? repoArg.replace("--repos=", "").split(",")
+        : [
+            "curl",
+            "libssh",
+            "nginx",
+            "redis",
+            // Future: add "nghttp2", "apache", "openssl" when labels are available
+        ];
+    console.log(`Running precision measurement on ${repoNames.length} repos...`);
+    const report = generateReport(repoNames);
+    console.log(formatReport(report));
+    saveReport(report);
+}
+main();