progmune-runtime 2.1.6 → 3.2.0

package/dist/ablation-study.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * P7.0: Ablation Study — Does Software Physics Survive Without Scaffolding?
+ *
+ * The ultimate test: remove all hand-crafted scaffolding and measure
+ * whether Redis ↔ SQLite structural similarity survives.
+ *
+ * Three ablations:
+ *   1. Remove Function Synonym Mapping → measure cross-repo similarity
+ *   2. Remove Hand-crafted Protocol Rules → measure cross-domain F1
+ *   3. Remove ALL scaffolding → measure pure structural clustering
+ *
+ * Key question: 67% → ? when synonyms are removed?
+ *   >50% = genuinely learned structure
+ *   <10% = just classifying by name
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAblationStudy = runAblationStudy;
+exports.printAblationReport = printAblationReport;
+const software_physics_1 = require("./experimental/software-physics");
+const function_synonyms_1 = require("./function-synonyms");
+const generalization_test_1 = require("./generalization.test");
+const FULL_SCAFFOLDING = { useSynonyms: true, useHandRules: true, useKnownPatterns: true };
+const NO_SYNONYMS = { useSynonyms: false, useHandRules: true, useKnownPatterns: true };
+const NO_HAND_RULES = { useSynonyms: true, useHandRules: false, useKnownPatterns: true };
+const NO_SCAFFOLDING = { useSynonyms: false, useHandRules: false, useKnownPatterns: false };
+// ═══════════════════════════════════════════════════════════════
+// Cross-Repo Similarity Under Ablation
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Measure Redis ↔ SQLite similarity with and without function synonyms.
+ *
+ * With synonyms: "createClient" and "sqlite3_open" normalize to canonical forms.
+ * Without synonyms: raw function names are used.
+ */
+function measureRepoSimilarity(config) {
+    const redisFns = config.useSynonyms
+        ? software_physics_1.KNOWN_REPO_SIGNATURES["Redis"].map(function_synonyms_1.normalizeFunctionName)
+        : software_physics_1.KNOWN_REPO_SIGNATURES["Redis"];
+    const sqliteFns = config.useSynonyms
+        ? software_physics_1.KNOWN_REPO_SIGNATURES["SQLite"].map(function_synonyms_1.normalizeFunctionName)
+        : software_physics_1.KNOWN_REPO_SIGNATURES["SQLite"];
+    const redis = (0, software_physics_1.analyzeRepoPhysics)("Redis", redisFns);
+    const sqlite = (0, software_physics_1.analyzeRepoPhysics)("SQLite", sqliteFns);
+    const comp = (0, software_physics_1.compareRepoPhysics)(redis, sqlite);
+    return comp.similarity;
+}
+// ═══════════════════════════════════════════════════════════════
+// Cross-Domain F1 Under Ablation
+// ═══════════════════════════════════════════════════════════════
+function measureCrossDomainF1(config) {
+    const families = Object.keys(generalization_test_1.PROTOCOL_FAMILIES);
+    const results = [];
+    for (const family of families) {
+        if (config.useKnownPatterns) {
+            const r = (0, generalization_test_1.runFamilyIsolation)(family);
+            results.push(r.crossDomainF1);
+        }
+        else {
+            // Without known patterns: use pure structural clustering on raw names
+            const testFns = generalization_test_1.PROTOCOL_FAMILIES[family];
+            const trainFamilies = families.filter(f => f !== family);
+            const trainFns = trainFamilies.flatMap(f => generalization_test_1.PROTOCOL_FAMILIES[f]);
+            const rawTest = config.useSynonyms ? testFns.map(function_synonyms_1.normalizeFunctionName) : testFns;
+            const rawTrain = config.useSynonyms ? trainFns.map(function_synonyms_1.normalizeFunctionName) : trainFns;
+            // Structural match: do test functions share any structural property with train?
+            let matched = 0;
+            for (const tf of rawTest) {
+                const hasMatch = rawTrain.some(trf => {
+                    const tLen = tf.length;
+                    const trLen = trf.length;
+                    return Math.abs(tLen - trLen) <= 3; // similar length = structural similarity
+                });
+                if (hasMatch)
+                    matched++;
+            }
+            results.push(rawTest.length > 0 ? matched / rawTest.length : 0);
+        }
+    }
+    return results.reduce((s, r) => s + r, 0) / results.length;
+}
+function runAblationStudy() {
+    const baseline = {
+        repoSimilarity: measureRepoSimilarity(FULL_SCAFFOLDING),
+        crossDomainF1: measureCrossDomainF1(FULL_SCAFFOLDING),
+    };
+    const noSynonyms = {
+        repoSimilarity: measureRepoSimilarity(NO_SYNONYMS),
+        crossDomainF1: measureCrossDomainF1(NO_SYNONYMS),
+        similarityDrop: baseline.repoSimilarity - measureRepoSimilarity(NO_SYNONYMS),
+    };
+    const noHandRules = {
+        crossDomainF1: measureCrossDomainF1(NO_HAND_RULES),
+    };
+    const noScaffolding = {
+        repoSimilarity: measureRepoSimilarity(NO_SCAFFOLDING),
+        crossDomainF1: measureCrossDomainF1(NO_SCAFFOLDING),
+    };
+    // Verdict: if similarity survives without synonyms, structure is learned
+    const survivalRate = noSynonyms.repoSimilarity / Math.max(0.01, baseline.repoSimilarity);
+    const verdict = survivalRate > 0.8 ? "structure_learned" :
+        survivalRate > 0.4 ? "partial" :
+            "name_memorized";
+    return { baseline, noSynonyms, noHandRules, noScaffolding, verdict };
+}
+function printAblationReport(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   P7.0 Ablation Study                               ║");
+    console.log("║   Does Software Physics survive scaffolding removal?║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log("─── Baseline (full scaffolding) ───");
+    console.log(`  Repo Similarity:  ${(report.baseline.repoSimilarity * 100).toFixed(0)}%`);
+    console.log(`  Cross-Domain F1:  ${(report.baseline.crossDomainF1 * 100).toFixed(0)}%`);
+    console.log();
+    console.log("─── Ablation 1: Remove Synonyms ───");
+    console.log(`  Repo Similarity:  ${(report.noSynonyms.repoSimilarity * 100).toFixed(0)}%`);
+    console.log(`  Cross-Domain F1:  ${(report.noSynonyms.crossDomainF1 * 100).toFixed(0)}%`);
+    console.log(`  Similarity Drop:  ${(report.noSynonyms.similarityDrop * 100).toFixed(0)}%`);
+    console.log();
+    console.log("─── Ablation 2: Remove Hand Rules ───");
+    console.log(`  Cross-Domain F1:  ${(report.noHandRules.crossDomainF1 * 100).toFixed(0)}%`);
+    console.log();
+    console.log("─── Ablation 3: Remove ALL Scaffolding ───");
+    console.log(`  Repo Similarity:  ${(report.noScaffolding.repoSimilarity * 100).toFixed(0)}%`);
+    console.log(`  Cross-Domain F1:  ${(report.noScaffolding.crossDomainF1 * 100).toFixed(0)}%`);
+    console.log();
+    const survivalRate = (report.noSynonyms.repoSimilarity / Math.max(0.01, report.baseline.repoSimilarity) * 100).toFixed(0);
+    console.log(`─── Verdict ───`);
+    console.log(`  Survival Rate:    ${survivalRate}%`);
+    console.log(`  Classification:   ${report.verdict.toUpperCase()}`);
+    console.log();
+    if (report.verdict === "structure_learned") {
+        console.log("  ✅ Software Physics survives without name scaffolding.");
+        console.log("     The system genuinely learns protocol STRUCTURE.");
+    }
+    else if (report.verdict === "partial") {
+        console.log("  ⚠️  Partial survival. Some structure is learned, some is name-dependent.");
+    }
+    else {
+        console.log("  ❌ Similarity collapses without synonyms.");
+        console.log("     The system primarily memorizes function names.");
+    }
+    console.log();
+}

package/dist/ablation-study.test.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * P7.0: Ablation Study Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const ablation_study_1 = require("./ablation-study");
+(0, vitest_1.describe)("P7.0 Ablation Study", () => {
+    (0, vitest_1.it)("measures repo similarity with and without synonyms", () => {
+        const report = (0, ablation_study_1.runAblationStudy)();
+        (0, vitest_1.expect)(report.baseline.repoSimilarity).toBeGreaterThan(0);
+        (0, vitest_1.expect)(report.noSynonyms.repoSimilarity).toBeGreaterThanOrEqual(0);
+        // The key metric: how much similarity survives without synonyms
+        const survivalRate = report.noSynonyms.repoSimilarity / Math.max(0.01, report.baseline.repoSimilarity);
+        console.log(`Survival rate (without synonyms): ${(survivalRate * 100).toFixed(0)}%`);
+        (0, ablation_study_1.printAblationReport)(report);
+    });
+});

package/dist/action-runtime.js

@@ -85,7 +85,9 @@ function executeActionCode(code) {
                 return true;
             }
         });
-        const wrappedCode = `with(vars) { ${code} }`;
+        // Strip TypeScript 'as Type' annotations — JS sandbox, not TS
+        const jsCode = code.replace(/\{\}\s+as\s+\w+(\[\])?/g, '{}');
+        const wrappedCode = `with(vars) { ${jsCode} }`;
         const fn = new Function('vars', ...apiNames, wrappedCode);
         fn(proxyVars, ...apiValues);
         return root.actions;

package/dist/active-learning.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * P3.8: Active Learning Benchmark Generator
+ *
+ * Prioritizes data acquisition by importance, not just coverage.
+ *
+ * Coverage analysis tells you WHAT is missing.
+ * Difficulty analysis tells you HOW HARD it is.
+ * Active Learning tells you WHAT TO GENERATE FIRST.
+ *
+ * Importance score:
+ *   importance = difficulty × protocolUsage × failureFrequency
+ *
+ * This ensures we generate benchmarks for the transitions that:
+ *   1. Are hardest to get right (high difficulty)
+ *   2. Appear most often in real usage (high protocol frequency)
+ *   3. Cause the most failures (high failure count)
+ *
+ * Data flow:
+ *   Coverage Gaps + Difficulty Map → Importance Ranking → Prioritized Generation
+ */
+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 });
+exports.generatePrioritizedBenchmarks = generatePrioritizedBenchmarks;
+exports.writeTopPriorityBenchmarks = writeTopPriorityBenchmarks;
+exports.printActiveLearningReport = printActiveLearningReport;
+const benchmark_generator_1 = require("./benchmark-generator");
+const difficulty_map_1 = require("./difficulty-map");
+const failure_corpus_1 = require("./failure-corpus");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ═══════════════════════════════════════════════════════════════
+// Importance Scoring
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Compute protocol usage frequency from trajectory counts.
+ */
+function computeProtocolUsage(trajectories) {
+    const counts = {};
+    for (const t of trajectories) {
+        const proto = t.protocol === "_global" ? "FileProtocol" : t.protocol;
+        counts[proto] = (counts[proto] || 0) + 1;
+    }
+    const total = Math.max(1, trajectories.length);
+    for (const k of Object.keys(counts)) {
+        counts[k] /= total;
+    }
+    return counts;
+}
+/**
+ * Score a missing transition by importance.
+ *
+ *   importance = difficulty × protocolUsage × failureFrequency
+ *
+ * All three dimensions normalized to [0,1].
+ */
+function scoreImportance(transition, protocol, statsMap, protocolUsage) {
+    const key = `${protocol}:${transition.from}→${transition.to}`;
+    const stats = statsMap.get(key);
+    const difficulty = (stats && stats.attempts > 0) ? stats.difficulty : 0.5; // unknown = medium difficulty
+    const usage = protocolUsage[protocol] ?? 0.1;
+    const failureCount = stats?.failures ?? 0;
+    const failureNorm = Math.min(1, failureCount / 10); // cap at 10+
+    const importance = difficulty * usage * (0.3 + 0.7 * failureNorm);
+    return { importance, difficulty, protocolUsage: usage, failureCount };
+}
+// ═══════════════════════════════════════════════════════════════
+// Prioritized Generation
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Generate benchmarks prioritized by importance.
+ *
+ * Instead of generating all uncovered transitions equally,
+ * this ranks them by how valuable each data point would be
+ * for future learning.
+ */
+function generatePrioritizedBenchmarks(trajectories, decisions) {
+    const trajs = trajectories || (0, failure_corpus_1.loadTrajectories)();
+    const statsMap = (0, difficulty_map_1.buildDifficultyMap)(trajs, decisions);
+    const protocolUsage = computeProtocolUsage(trajs);
+    // Get all uncovered transitions with their generated cases
+    const allGenerated = (0, benchmark_generator_1.generateMissingBenchmarks)(trajs);
+    const prioritized = [];
+    const byProtocol = {};
+    for (const [protocol, cases] of Object.entries(allGenerated)) {
+        const protocolCases = [];
+        for (const c of cases) {
+            const { importance, difficulty, protocolUsage: usage, failureCount } = scoreImportance(c.targetsTransition, protocol, statsMap, protocolUsage);
+            const pc = {
+                ...c,
+                importance,
+                difficulty,
+                protocolUsage: usage,
+                failureCount,
+            };
+            protocolCases.push(pc);
+        }
+        protocolCases.sort((a, b) => b.importance - a.importance);
+        byProtocol[protocol] = protocolCases;
+        prioritized.push(...protocolCases);
+    }
+    prioritized.sort((a, b) => b.importance - a.importance);
+    return {
+        totalGaps: prioritized.length,
+        prioritized,
+        byProtocol,
+    };
+}
+/**
+ * Write only the top-K most important benchmarks.
+ */
+function writeTopPriorityBenchmarks(report, topK = 10, outputDir) {
+    const outDir = outputDir || path.resolve(__dirname, "..", "benchmarks", "priority");
+    if (!fs.existsSync(outDir))
+        fs.mkdirSync(outDir, { recursive: true });
+    const top = report.prioritized.slice(0, topK);
+    const written = [];
+    // Group by protocol for organized output
+    const grouped = {};
+    for (const c of top) {
+        const proto = c.targetsTransition.rule.includes("file") ? "FileProtocol" :
+            c.targetsTransition.rule.includes("auth") || c.targetsTransition.rule.includes("password") || c.targetsTransition.rule.includes("jwt") || c.targetsTransition.rule.includes("session") || c.targetsTransition.rule.includes("logout") ? "AuthProtocol" :
+                c.targetsTransition.rule.includes("db") || c.targetsTransition.rule.includes("connect") || c.targetsTransition.rule.includes("query") ? "DBProtocol" :
+                    "IRProtocol";
+        if (!grouped[proto])
+            grouped[proto] = [];
+        grouped[proto].push(c);
+    }
+    for (const [protocol, cases] of Object.entries(grouped)) {
+        const filename = `priority_${protocol.toLowerCase()}_${new Date().toISOString().slice(0, 10)}.json`;
+        const filepath = path.join(outDir, filename);
+        fs.writeFileSync(filepath, JSON.stringify({
+            generatedAt: new Date().toISOString(),
+            protocol,
+            topK,
+            source: "active-learning",
+            cases: cases.map(({ importance, difficulty, protocolUsage, failureCount, ...rest }) => ({
+                ...rest,
+                importance, difficulty,
+            })),
+        }, null, 2));
+        written.push(filepath);
+    }
+    return written;
+}
+// ═══════════════════════════════════════════════════════════════
+// Report
+// ═══════════════════════════════════════════════════════════════
+function printActiveLearningReport(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   Active Learning: Prioritized Benchmarks          ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Total Gaps:            ${report.totalGaps}`);
+    console.log(`Prioritized Generated: ${report.prioritized.length}\n`);
+    if (report.prioritized.length === 0) {
+        console.log("All transitions covered. No gaps to prioritize.\n");
+        return;
+    }
+    console.log("─── Top 10 Priority Benchmarks ───");
+    console.log("Import  Diff    Protocol       Transition");
+    console.log("────────────────────────────────────────────────────");
+    for (const c of report.prioritized.slice(0, 10)) {
+        const imp = (c.importance * 100).toFixed(0).padStart(4);
+        const diff = (c.difficulty * 100).toFixed(0).padStart(4);
+        console.log(`  ${imp}%  ${diff}%   ${c.targetsTransition.rule.padEnd(16)} ${c.targetsTransition.from}→${c.targetsTransition.to}`);
+    }
+    console.log();
+    // Per-protocol summary
+    console.log("─── Per Protocol ───");
+    for (const [proto, cases] of Object.entries(report.byProtocol)) {
+        const top = cases.slice(0, 3);
+        const totalImp = cases.reduce((s, c) => s + c.importance, 0);
+        console.log(`  ${proto}: ${cases.length} gaps, top importance: ${(totalImp * 100).toFixed(0)}%`);
+        for (const c of top) {
+            console.log(`    ${c.targetsTransition.from}→${c.targetsTransition.to} (importance: ${(c.importance * 100).toFixed(0)}%)`);
+        }
+    }
+    console.log();
+}

package/dist/analytics.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * P2.5: Repair Acceptance Dashboard
+ *
+ * Queries the telemetry layer to produce structured reports
+ * on which strategies, protocols, goals, and repair patterns
+ * perform best. This is the feedback loop that powers P4 Reward Model.
+ *
+ * Usage:
+ *   import { printDashboard } from "./analytics";
+ *   printDashboard(telemetry);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStrategyStats = getStrategyStats;
+exports.getProtocolStats = getProtocolStats;
+exports.getGoalStats = getGoalStats;
+exports.getTopAcceptedRepairs = getTopAcceptedRepairs;
+exports.getTopRejectedRepairs = getTopRejectedRepairs;
+exports.generateDashboard = generateDashboard;
+exports.getRepairAdoptionRate = getRepairAdoptionRate;
+exports.printDashboard = printDashboard;
+function getStrategyStats(telemetry) {
+    const bySource = telemetry.getAcceptanceBySource();
+    return Object.entries(bySource)
+        .map(([strategy, s]) => ({
+        strategy,
+        total: s.total,
+        accepted: s.accepted,
+        rate: s.rate,
+    }))
+        .sort((a, b) => b.rate - a.rate);
+}
+function getProtocolStats(telemetry) {
+    const byProtocol = telemetry.getAcceptanceByProtocol();
+    return Object.entries(byProtocol)
+        .map(([protocol, s]) => ({
+        protocol,
+        total: s.total,
+        accepted: s.accepted,
+        rate: s.rate,
+    }))
+        .sort((a, b) => b.rate - a.rate);
+}
+function getGoalStats(telemetry) {
+    const byGoal = telemetry.getAcceptanceByGoal();
+    return Object.entries(byGoal)
+        .map(([goal, s]) => ({
+        goal,
+        total: s.total,
+        accepted: s.accepted,
+        rate: s.rate,
+    }))
+        .sort((a, b) => b.rate - a.rate);
+}
+function getTopAcceptedRepairs(telemetry, k) {
+    return telemetry.getTopAcceptedRepairs(k);
+}
+function getTopRejectedRepairs(telemetry, k) {
+    return telemetry.getTopRejectedRepairs(k);
+}
+function generateDashboard(telemetry) {
+    const summary = telemetry.getSummaryStats();
+    return {
+        summary: {
+            totalDecisions: telemetry.size,
+            withFeedback: telemetry.withFeedback,
+            overallAcceptanceRate: telemetry.getAcceptanceRate(),
+            adoptionRate: getRepairAdoptionRate(telemetry),
+            accepted: summary.accepted,
+            rejected: summary.rejected,
+            modified: summary.modified,
+        },
+        byStrategy: getStrategyStats(telemetry),
+        byProtocol: getProtocolStats(telemetry),
+        topAccepted: getTopAcceptedRepairs(telemetry, 5),
+        topRejected: getTopRejectedRepairs(telemetry, 5),
+    };
+}
+/**
+ * Repair Adoption Rate — the most important KPI.
+ *
+ * "Of all repairs the planner proposed, how many did the user actually accept?"
+ * This matters more than Top-1 accuracy because users don't care
+ * what the algorithm thinks is right — they care what they're willing to use.
+ */
+function getRepairAdoptionRate(telemetry) {
+    const summary = telemetry.getSummaryStats();
+    const total = summary.accepted + summary.rejected;
+    if (total === 0)
+        return 0;
+    return summary.accepted / total;
+}
+/**
+ * Print a human-readable acceptance dashboard to stdout.
+ */
+function printDashboard(telemetry) {
+    const report = generateDashboard(telemetry);
+    console.log("\n╔══════════════════════════════════════════╗");
+    console.log("║   Repair Acceptance Dashboard            ║");
+    console.log("╚══════════════════════════════════════════╝\n");
+    console.log(`Total Decisions:     ${report.summary.totalDecisions}`);
+    console.log(`With Feedback:       ${report.summary.withFeedback}`);
+    console.log(`Acceptance Rate:     ${(report.summary.overallAcceptanceRate * 100).toFixed(1)}%`);
+    console.log(`Repair Adoption:     ${(report.summary.adoptionRate * 100).toFixed(1)}%  (${report.summary.accepted} accepted / ${report.summary.rejected} rejected / ${report.summary.modified} modified)\n`);
+    if (report.byStrategy.length > 0) {
+        console.log("─── By Strategy ───");
+        console.log("Strategy          Acceptance");
+        console.log("──────────────────────────────");
+        for (const s of report.byStrategy) {
+            const pct = (s.rate * 100).toFixed(0).padStart(3);
+            console.log(`  ${s.strategy.padEnd(16)} ${pct}%  (${s.accepted}/${s.total})`);
+        }
+        console.log();
+    }
+    if (report.byProtocol.length > 0) {
+        console.log("─── By Protocol ───");
+        console.log("Protocol          Acceptance");
+        console.log("──────────────────────────────");
+        for (const p of report.byProtocol) {
+            const pct = (p.rate * 100).toFixed(0).padStart(3);
+            console.log(`  ${p.protocol.padEnd(16)} ${pct}%  (${p.accepted}/${p.total})`);
+        }
+        console.log();
+    }
+    if (report.topAccepted.length > 0) {
+        console.log("─── Top Accepted Repairs ───");
+        for (const r of report.topAccepted) {
+            console.log(`  ${r.actions}`);
+            console.log(`    goal: ${r.goal} | count: ${r.count} | rate: ${(r.rate * 100).toFixed(0)}%\n`);
+        }
+    }
+    if (report.topRejected.length > 0) {
+        console.log("─── Top Rejected Repairs ───");
+        for (const r of report.topRejected) {
+            console.log(`  ${r.actions}`);
+            console.log(`    goal: ${r.goal} | count: ${r.count} | rate: ${(r.rate * 100).toFixed(0)}%\n`);
+        }
+    }
+}