progmune-runtime 2.1.5 → 3.2.0

package/dist/difficulty-active.test.js

@@ -0,0 +1,198 @@
+"use strict";
+/**
+ * P3.7 + P3.8: Difficulty Map & Active Learning Tests
+ *
+ * Verifying:
+ *   1. TransitionStats computation from trajectory + telemetry data
+ *   2. Protocol difficulty ranking (critical/high/medium/low)
+ *   3. Active Learning importance scoring
+ *   4. Prioritized benchmark generation
+ *   5. End-to-end: difficulty → importance → prioritized 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 difficulty_map_1 = require("./difficulty-map");
+const active_learning_1 = require("./active-learning");
+// ═══════════════════════════════════════════════════════════════
+// Difficulty Map
+// ═══════════════════════════════════════════════════════════════
+function makeTrajectory(overrides = {}) {
+    return {
+        id: `t-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        timestamp: new Date().toISOString(),
+        protocol: "_global",
+        initialState: [],
+        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" },
+        ...overrides,
+    };
+}
+(0, vitest_1.describe)("Difficulty Map", () => {
+    (0, vitest_1.it)("computes transition stats from trajectories", () => {
+        const trajectories = [
+            makeTrajectory({ result: "success", trajectory: ["open_file", "write_file", "close_file"] }),
+            makeTrajectory({ result: "success", trajectory: ["open_file", "write_file", "close_file"] }),
+            makeTrajectory({ result: "violation", trajectory: ["open_file", "write_file"] }), // missing close
+            makeTrajectory({
+                result: "repair", trajectory: ["open_file", "write_file", "close_file"],
+                successRate: 1.0,
+                violation: { type: "resource_leak", failingStepIndex: 2, expectedStates: [], actualStates: ["FILE_OPEN"], fixPath: ["close_file"], description: "fix" },
+            }),
+        ];
+        const statsMap = (0, difficulty_map_1.buildDifficultyMap)(trajectories);
+        // FileProtocol should have stats
+        const fileKeys = [...statsMap.keys()].filter(k => k.startsWith("FileProtocol:"));
+        (0, vitest_1.expect)(fileKeys.length).toBeGreaterThan(0);
+        // open_file transition should have attempts
+        const openKey = "FileProtocol:INIT→FILE_OPEN";
+        const openStats = statsMap.get(openKey);
+        (0, vitest_1.expect)(openStats).toBeDefined();
+        (0, vitest_1.expect)(openStats.attempts).toBeGreaterThanOrEqual(3);
+        (0, vitest_1.expect)(openStats.failures).toBeGreaterThanOrEqual(1); // the violation
+        // close_file invalidation should be tracked
+        const closeInvKey = "FileProtocol:FILE_OPEN→∅";
+        const closeStats = statsMap.get(closeInvKey);
+        (0, vitest_1.expect)(closeStats).toBeDefined();
+    });
+    (0, vitest_1.it)("difficulty > 0 for transitions with failures", () => {
+        const trajectories = [
+            makeTrajectory({ result: "success", trajectory: ["verify_password", "generate_jwt", "create_session"] }),
+            makeTrajectory({ result: "violation", trajectory: ["verify_password"] }), // missing jwt
+            makeTrajectory({ result: "violation", trajectory: ["verify_password"] }),
+            makeTrajectory({ result: "violation", trajectory: ["verify_password"] }),
+        ];
+        const statsMap = (0, difficulty_map_1.buildDifficultyMap)(trajectories);
+        // The failures are on verify_password transitions (missing the rest)
+        // UNAUTHENTICATED→PASSWORD_VERIFIED should have failures from the violations
+        const vpKey = "AuthProtocol:UNAUTHENTICATED→PASSWORD_VERIFIED";
+        const vpStats = statsMap.get(vpKey);
+        (0, vitest_1.expect)(vpStats).toBeDefined();
+        (0, vitest_1.expect)(vpStats.attempts).toBeGreaterThanOrEqual(4); // 1 success + 3 violations
+        (0, vitest_1.expect)(vpStats.failures).toBeGreaterThanOrEqual(3);
+        (0, vitest_1.expect)(vpStats.difficulty).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("ranks protocols by difficulty", () => {
+        const trajectories = [
+            // FileProtocol: mostly successes
+            ...Array.from({ length: 10 }, () => makeTrajectory({ result: "success", trajectory: ["open_file", "write_file", "close_file"] })),
+            // AuthProtocol: many failures
+            makeTrajectory({ result: "violation", trajectory: ["verify_password"] }),
+            makeTrajectory({ result: "violation", trajectory: ["verify_password"] }),
+            makeTrajectory({ result: "violation", trajectory: ["generate_jwt"] }),
+        ];
+        const statsMap = (0, difficulty_map_1.buildDifficultyMap)(trajectories);
+        const ranking = (0, difficulty_map_1.rankProtocolsByDifficulty)(statsMap);
+        (0, vitest_1.expect)(ranking.length).toBeGreaterThanOrEqual(4); // P7.3: 9 protocol groups
+        // AuthProtocol should be highest difficulty
+        const auth = ranking.find(r => r.protocol === "AuthProtocol");
+        const file = ranking.find(r => r.protocol === "FileProtocol");
+        (0, vitest_1.expect)(auth.maxDifficulty).toBeGreaterThan(file.maxDifficulty);
+        (0, difficulty_map_1.printDifficultyDashboard)(statsMap, ranking);
+    });
+    (0, vitest_1.it)("empty data = all zeros", () => {
+        const statsMap = (0, difficulty_map_1.buildDifficultyMap)([]);
+        const ranking = (0, difficulty_map_1.rankProtocolsByDifficulty)(statsMap);
+        for (const r of ranking) {
+            (0, vitest_1.expect)(r.avgDifficulty).toBe(0);
+            (0, vitest_1.expect)(r.maxDifficulty).toBe(0);
+            (0, vitest_1.expect)(r.risk).toBe("low");
+        }
+    });
+});
+// ═══════════════════════════════════════════════════════════════
+// Active Learning
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("Active Learning", () => {
+    (0, vitest_1.it)("prioritizes gaps by importance (difficulty × usage × failure)", () => {
+        // Seed with skewed data: FileProtocol is easy, AuthProtocol is hard
+        const trajectories = [
+            // File: many successes, few failures → low difficulty
+            ...Array.from({ length: 20 }, () => makeTrajectory({ result: "success", trajectory: ["open_file", "write_file", "close_file"] })),
+            // Auth: many failures → high difficulty
+            ...Array.from({ length: 5 }, () => makeTrajectory({ result: "violation", trajectory: ["verify_password"] })),
+        ];
+        const report = (0, active_learning_1.generatePrioritizedBenchmarks)(trajectories);
+        (0, vitest_1.expect)(report.totalGaps).toBeGreaterThan(0);
+        (0, vitest_1.expect)(report.prioritized.length).toBeGreaterThan(0);
+        // Auth transitions should have higher importance than File transitions
+        // (auth has violations → higher difficulty)
+        const authCases = report.prioritized.filter(c => c.targetsTransition.rule.includes("password") || c.targetsTransition.rule.includes("jwt") || c.targetsTransition.rule.includes("session"));
+        const fileCases = report.prioritized.filter(c => c.targetsTransition.rule.includes("file") || c.targetsTransition.rule.includes("open") || c.targetsTransition.rule.includes("write") || c.targetsTransition.rule.includes("close"));
+        if (authCases.length > 0 && fileCases.length > 0) {
+            // Auth should have non-zero difficulty (has violations)
+            const authHasDifficulty = authCases.some(c => c.difficulty > 0);
+            (0, vitest_1.expect)(authHasDifficulty).toBe(true);
+        }
+        (0, active_learning_1.printActiveLearningReport)(report);
+    });
+    (0, vitest_1.it)("writes top-K priority benchmarks", () => {
+        const trajectories = [
+            ...Array.from({ length: 30 }, () => makeTrajectory({ result: "success", trajectory: ["open_file", "write_file", "close_file"] })),
+        ];
+        const report = (0, active_learning_1.generatePrioritizedBenchmarks)(trajectories);
+        const outDir = path.resolve(__dirname, "..", "test-active-learning");
+        const written = (0, active_learning_1.writeTopPriorityBenchmarks)(report, 8, outDir);
+        (0, vitest_1.expect)(written.length).toBeGreaterThanOrEqual(1);
+        // Verify files are valid JSON with importance scores
+        for (const fp of written) {
+            (0, vitest_1.expect)(fs.existsSync(fp)).toBe(true);
+            const content = JSON.parse(fs.readFileSync(fp, "utf-8"));
+            (0, vitest_1.expect)(content.source).toBe("active-learning");
+            (0, vitest_1.expect)(content.cases.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(content.cases.length).toBeLessThanOrEqual(8);
+            for (const c of content.cases) {
+                (0, vitest_1.expect)(c.importance).toBeGreaterThanOrEqual(0);
+                (0, vitest_1.expect)(c.difficulty).toBeGreaterThanOrEqual(0);
+            }
+        }
+    });
+    (0, vitest_1.it)("importance = 0 when no data (all gaps equal priority)", () => {
+        const report = (0, active_learning_1.generatePrioritizedBenchmarks)([]);
+        // With no data, all gaps have equal importance
+        // They're still generated, just not differentiated
+        (0, vitest_1.expect)(report.totalGaps).toBeGreaterThan(0);
+        for (const c of report.prioritized) {
+            (0, vitest_1.expect)(c.importance).toBeGreaterThanOrEqual(0);
+            (0, vitest_1.expect)(c.importance).toBeLessThanOrEqual(1);
+        }
+    });
+});

package/dist/difficulty-map.js

@@ -0,0 +1,244 @@
+"use strict";
+/**
+ * P3.7: Protocol Difficulty Map
+ *
+ * Answers: which transitions are hardest to learn?
+ *
+ * Uses Telemetry + Trajectory Corpus to compute per-transition statistics:
+ *   - How often does this transition appear in trajectories?
+ *   - When it fails, how often is it successfully repaired?
+ *   - What's the acceptance rate for repairs involving this transition?
+ *
+ * The difficulty score feeds into:
+ *   1. Active Learning (prioritize hard transitions for benchmark generation)
+ *   2. Reward Model (weight training samples by difficulty)
+ *   3. Coverage System (focus data acquisition on high-difficulty gaps)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDifficultyMap = buildDifficultyMap;
+exports.rankProtocolsByDifficulty = rankProtocolsByDifficulty;
+exports.printDifficultyDashboard = printDifficultyDashboard;
+const protocol_coverage_1 = require("./protocol-coverage");
+// ═══════════════════════════════════════════════════════════════
+// Difficulty Computation
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Compute difficulty for a single transition.
+ *
+ *   difficulty = (failureRate × 0.4) + (repairFailureRate × 0.4) + (rejectionRate × 0.2)
+ *
+ * Where:
+ *   - failureRate = failures / attempts (how often does it go wrong?)
+ *   - repairFailureRate = 1 - (repairSuccesses / repairs) (when fixed, how often does the fix fail?)
+ *   - rejectionRate = 1 - acceptanceRate (how often do users reject the repair?)
+ *
+ * A transition that always fails AND repairs never work AND users always reject = difficulty 1.0.
+ * A transition that never fails = difficulty 0.0.
+ */
+function computeDifficulty(stats) {
+    if (stats.attempts === 0)
+        return 0;
+    const failureRate = stats.failures / stats.attempts;
+    const repairFailureRate = stats.repairs > 0
+        ? 1 - (stats.repairSuccesses / stats.repairs)
+        : 0;
+    const rejectionRate = stats.repairs > 0
+        ? 1 - stats.acceptanceRate
+        : 0;
+    return failureRate * 0.4 + repairFailureRate * 0.4 + rejectionRate * 0.2;
+}
+function emptyStats(protocol, t) {
+    return {
+        protocol,
+        transition: `${t.from}→${t.to}`,
+        rule: t.rule,
+        type: t.type,
+        attempts: 0, successes: 0, failures: 0,
+        repairs: 0, repairSuccesses: 0,
+        acceptanceRate: 0, repairRate: 0, avgRepairSteps: 0, avgLatency: 0,
+        difficulty: 0,
+    };
+}
+/** Extract transition keys that appear in a trajectory. */
+function transitionsInTrajectory(traj, proto) {
+    const keys = [];
+    let current = new Set();
+    if (proto.initialState)
+        current.add(proto.initialState);
+    for (const fn of traj) {
+        const rule = proto.rules.get(fn);
+        if (!rule)
+            continue;
+        for (const pre of (rule.pre_states.length > 0 ? rule.pre_states : ["INIT"])) {
+            for (const post of rule.post_states) {
+                keys.push(`${pre}→${post}`);
+            }
+        }
+        if (rule.invalidate) {
+            for (const inv of rule.invalidate) {
+                keys.push(`${inv}→∅`);
+            }
+        }
+        if (rule.invalidate)
+            rule.invalidate.forEach(s => current.delete(s));
+        for (const post of rule.post_states)
+            current.add(post);
+    }
+    return keys;
+}
+/**
+ * Build a difficulty map from trajectory data and telemetry decisions.
+ */
+function buildDifficultyMap(trajectories, decisions) {
+    const protocols = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+    const statsMap = new Map();
+    // Initialize all transitions with empty stats
+    for (const proto of protocols) {
+        for (const t of proto.transitions) {
+            const key = `${proto.name}:${t.from}→${t.to}`;
+            statsMap.set(key, emptyStats(proto.name, t));
+        }
+    }
+    // Count from trajectories
+    for (const traj of trajectories) {
+        // Find matching protocol
+        for (const proto of protocols) {
+            const tKeys = transitionsInTrajectory(traj.trajectory, proto);
+            if (tKeys.length === 0)
+                continue;
+            const isViolation = traj.result === "violation";
+            const isRepair = traj.result === "repair";
+            const repairSuccess = isRepair && traj.successRate >= 0.5;
+            for (const tKey of tKeys) {
+                const key = `${proto.name}:${tKey}`;
+                const stats = statsMap.get(key);
+                if (!stats)
+                    continue;
+                stats.attempts++;
+                if (isViolation || (isRepair && !repairSuccess))
+                    stats.failures++;
+                else
+                    stats.successes++;
+                if (isRepair) {
+                    stats.repairs++;
+                    if (repairSuccess)
+                        stats.repairSuccesses++;
+                    if (traj.violation?.fixPath) {
+                        const totalSteps = (stats.avgRepairSteps * (stats.repairs - 1) + traj.violation.fixPath.length) / stats.repairs;
+                        stats.avgRepairSteps = totalSteps;
+                    }
+                }
+                if (traj.cost?.latency) {
+                    const totalLat = (stats.avgLatency * (stats.attempts - 1) + traj.cost.latency) / stats.attempts;
+                    stats.avgLatency = totalLat;
+                }
+            }
+        }
+    }
+    // Incorporate telemetry acceptance data if available
+    if (decisions) {
+        for (const d of decisions) {
+            if (!d.feedback || !d.selectedCandidateId)
+                continue;
+            const sel = d.candidates.find(c => c.candidateId === d.selectedCandidateId);
+            if (!sel)
+                continue;
+            // Map candidate actions to transitions
+            for (const proto of protocols) {
+                const tKeys = transitionsInTrajectory(sel.actions, proto);
+                for (const tKey of tKeys) {
+                    const key = `${proto.name}:${tKey}`;
+                    const stats = statsMap.get(key);
+                    if (!stats)
+                        continue;
+                    if (stats.repairs > 0) {
+                        const accepted = d.feedback.decision === "accepted" ? 1 : 0;
+                        stats.acceptanceRate = (stats.acceptanceRate * (stats.repairs - 1) + accepted) / stats.repairs;
+                    }
+                }
+            }
+        }
+    }
+    // Compute difficulty for each
+    for (const [key, stats] of statsMap) {
+        stats.difficulty = computeDifficulty(stats);
+        if (stats.failures > 0 && stats.repairs > 0) {
+            stats.repairRate = stats.repairSuccesses / stats.repairs;
+        }
+    }
+    return statsMap;
+}
+// ═══════════════════════════════════════════════════════════════
+// Protocol Aggregation
+// ═══════════════════════════════════════════════════════════════
+function rankProtocolsByDifficulty(statsMap) {
+    const protocols = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+    const result = [];
+    for (const proto of protocols) {
+        const entries = [];
+        for (const [key, stats] of statsMap) {
+            if (stats.protocol === proto.name)
+                entries.push(stats);
+        }
+        if (entries.length === 0) {
+            result.push({
+                protocol: proto.name, transitionCount: 0, avgDifficulty: 0,
+                maxDifficulty: 0, hardestTransition: "N/A", risk: "low",
+            });
+            continue;
+        }
+        const difficulties = entries.map(e => e.difficulty);
+        const avg = difficulties.reduce((s, d) => s + d, 0) / difficulties.length;
+        const max = Math.max(...difficulties);
+        const hardest = entries.find(e => e.difficulty === max);
+        let risk;
+        if (max > 0.5)
+            risk = "critical";
+        else if (max > 0.3)
+            risk = "high";
+        else if (max > 0.1)
+            risk = "medium";
+        else
+            risk = "low";
+        result.push({
+            protocol: proto.name,
+            transitionCount: entries.length,
+            avgDifficulty: avg,
+            maxDifficulty: max,
+            hardestTransition: hardest.transition,
+            risk,
+        });
+    }
+    return result.sort((a, b) => b.maxDifficulty - a.maxDifficulty);
+}
+// ═══════════════════════════════════════════════════════════════
+// Dashboard
+// ═══════════════════════════════════════════════════════════════
+function printDifficultyDashboard(statsMap, ranking) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   Protocol Difficulty Map                          ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log("─── Protocol Difficulty Ranking ───");
+    console.log("Protocol          AvgDiff  MaxDiff  HardestTransition");
+    console.log("──────────────────────────────────────────────────────");
+    for (const r of ranking) {
+        const icon = r.risk === "critical" ? "🔴" : r.risk === "high" ? "🟠" : r.risk === "medium" ? "🟡" : "🟢";
+        const avg = (r.avgDifficulty * 100).toFixed(0).padStart(3);
+        const max = (r.maxDifficulty * 100).toFixed(0).padStart(3);
+        console.log(`  ${r.protocol.padEnd(16)} ${avg}%   ${max}%   ${r.hardestTransition} ${icon}`);
+    }
+    console.log();
+    // Detail: hardest transitions
+    const hardTransitions = [...statsMap.values()]
+        .filter(s => s.difficulty > 0.3 && s.attempts > 0)
+        .sort((a, b) => b.difficulty - a.difficulty)
+        .slice(0, 10);
+    if (hardTransitions.length > 0) {
+        console.log("─── Hardest Transitions (top 10) ───");
+        for (const t of hardTransitions) {
+            const d = (t.difficulty * 100).toFixed(0);
+            console.log(`  ${t.protocol.padEnd(16)} ${t.transition.padEnd(30)} diff=${d}%  attempts=${t.attempts}  failures=${t.failures}  repairs=${t.repairs}`);
+        }
+        console.log();
+    }
+}

package/dist/discovery-analytics.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * P4.7: Discovery Analytics
+ *
+ * Makes DiscoveryRate a first-class KPI alongside Top-1/Top-3.
+ *
+ * Discovery Rate = fraction of benchmark cases where at least one
+ * correct candidate was found (regardless of ranking).
+ *
+ * Tracks:
+ *   - Discovery Rate by Protocol
+ *   - Discovery Rate by Violation Type
+ *   - Discovery Rate by Goal
+ *   - Trend over time (with timestamps)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeDiscoveryMetrics = computeDiscoveryMetrics;
+exports.generateFullAnalyticsReport = generateFullAnalyticsReport;
+exports.printDiscoveryDashboard = printDiscoveryDashboard;
+const evaluation_campaign_1 = require("./evaluation-campaign");
+const macro_repair_1 = require("./macro-repair");
+/**
+ * Compute discovery metrics from benchmark attributions.
+ *
+ * "Discovered" = at least one candidate was found (failureReason != "missing_candidate").
+ */
+function computeDiscoveryMetrics(attributed) {
+    const total = attributed.length;
+    const byProtocol = {};
+    const byViolation = {};
+    const byGoal = {};
+    for (const a of attributed) {
+        const discovered = a.failureReason !== "missing_candidate" && a.failureReason !== "bad_protocol_model";
+        // By protocol
+        const proto = a.protocol || "unknown";
+        if (!byProtocol[proto])
+            byProtocol[proto] = { total: 0, discovered: 0 };
+        byProtocol[proto].total++;
+        if (discovered)
+            byProtocol[proto].discovered++;
+        // By violation
+        const viol = a.violationType || "unknown";
+        if (!byViolation[viol])
+            byViolation[viol] = { total: 0, discovered: 0 };
+        byViolation[viol].total++;
+        if (discovered)
+            byViolation[viol].discovered++;
+        // By goal (first 2 words)
+        const goalKey = a.goal.split(" ").slice(0, 3).join(" ");
+        if (!byGoal[goalKey])
+            byGoal[goalKey] = { total: 0, discovered: 0 };
+        byGoal[goalKey].total++;
+        if (discovered)
+            byGoal[goalKey].discovered++;
+    }
+    const toRates = (rec) => Object.fromEntries(Object.entries(rec).map(([k, v]) => [k, v.total > 0 ? v.discovered / v.total : 0]));
+    return {
+        overall: total > 0 ? attributed.filter(a => a.failureReason !== "missing_candidate").length / total : 0,
+        byProtocol: toRates(byProtocol),
+        byViolation: toRates(byViolation),
+        byGoal: toRates(byGoal),
+        totalCases: total,
+    };
+}
+async function generateFullAnalyticsReport(telemetry) {
+    const attributed = await (0, evaluation_campaign_1.runFailureAttribution)();
+    const discovery = computeDiscoveryMetrics(attributed);
+    const macros = (0, macro_repair_1.mineMacroRepairs)(telemetry);
+    const missing = attributed.filter(a => a.failureReason === "missing_candidate").length;
+    const ranking = attributed.filter(a => a.failureReason === "bad_ranking").length;
+    const success = attributed.filter(a => a.failureReason === "success").length;
+    const total = attributed.length;
+    return {
+        timestamp: new Date().toISOString(),
+        discovery,
+        macroCount: macros.length,
+        topMacros: macros.slice(0, 5),
+        errorBudget: {
+            missingPct: total > 0 ? missing / total : 0,
+            rankingPct: total > 0 ? ranking / total : 0,
+            successPct: total > 0 ? success / total : 0,
+        },
+    };
+}
+function printDiscoveryDashboard(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   Discovery Analytics Dashboard                    ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Timestamp:    ${report.timestamp}`);
+    console.log(`Total Cases:  ${report.discovery.totalCases}`);
+    console.log();
+    // Discovery Rate
+    const dr = (report.discovery.overall * 100).toFixed(0);
+    console.log(`⭐ Discovery Rate: ${dr}%`);
+    console.log();
+    // Error Budget
+    console.log("─── Error Budget ───");
+    console.log(`  Missing Candidate: ${(report.errorBudget.missingPct * 100).toFixed(0)}%`);
+    console.log(`  Bad Ranking:       ${(report.errorBudget.rankingPct * 100).toFixed(0)}%`);
+    console.log(`  Success:           ${(report.errorBudget.successPct * 100).toFixed(0)}%`);
+    console.log();
+    // By Protocol
+    console.log("─── Discovery by Protocol ───");
+    for (const [proto, rate] of Object.entries(report.discovery.byProtocol).sort((a, b) => b[1] - a[1])) {
+        const pct = (rate * 100).toFixed(0).padStart(3);
+        const bar = "█".repeat(Math.round(rate * 20));
+        console.log(`  ${proto.padEnd(16)} ${pct}% ${bar}`);
+    }
+    console.log();
+    // By Violation
+    console.log("─── Discovery by Violation ───");
+    for (const [viol, rate] of Object.entries(report.discovery.byViolation).sort((a, b) => b[1] - a[1])) {
+        console.log(`  ${viol.padEnd(22)} ${(rate * 100).toFixed(0)}%`);
+    }
+    console.log();
+    // Macros
+    if (report.topMacros.length > 0) {
+        console.log("─── Top Macros ───");
+        for (const m of report.topMacros) {
+            console.log(`  ${m.actions.join(" → ")}  (accept: ${(m.acceptanceRate * 100).toFixed(0)}%, freq: ${m.frequency})`);
+        }
+        console.log(`  Total macros mined: ${report.macroCount}`);
+        console.log();
+    }
+}