progmune-runtime 2.1.6 → 3.2.0

package/dist/logistic-reward.test.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * P4.0: Logistic Reward Model Tests
+ *
+ * Verifying:
+ *   1. Model trains on telemetry data and converges
+ *   2. Feature importance is interpretable
+ *   3. Score produces valid probabilities [0,1]
+ *   4. Off-policy comparison shows improvement over baseline
+ *   5. Export/import roundtrip preserves weights
+ */
+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 logistic_reward_1 = require("./logistic-reward");
+const planner_telemetry_1 = require("./planner-telemetry");
+const LR_DIR = path.resolve(__dirname, "..", "test-logistic-reward");
+process.env.PROGMUNE_PROJECT_DIR = LR_DIR;
+fs.mkdirSync(LR_DIR, { recursive: true });
+fs.mkdirSync(path.join(LR_DIR, ".progmune_corpus", "telemetry"), { recursive: true });
+function seedTrainingData(telemetry, samples) {
+    // Pattern: safe repairs (close_file) are usually accepted + executed successfully
+    // Pattern: leaky repairs (skip close) are usually rejected or fail execution
+    for (let i = 0; i < samples; i++) {
+        const safe = i % 3 !== 0; // 2/3 are safe repairs
+        const fp = safe
+            ? (0, planner_telemetry_1.candidateFingerprint)("FileProtocol", ["open_file", "write_file", "close_file"], "resource_leak")
+            : (0, planner_telemetry_1.candidateFingerprint)("FileProtocol", ["open_file", "write_file"], "resource_leak");
+        const id = telemetry.recordDecision({
+            goal: `train goal ${i}`,
+            protocol: "FileProtocol", violationType: "resource_leak",
+            candidates: [
+                { candidateId: fp, source: "protocol", evidenceSources: ["protocol"],
+                    actions: safe ? ["open_file", "write_file", "close_file"] : ["open_file", "write_file"],
+                    explanation: safe ? "safe close" : "skip close" },
+            ],
+            selectedCandidateId: fp,
+        });
+        // Safe: 90% accepted + executed. Leaky: 80% rejected.
+        const acceptRoll = Math.random();
+        if (safe) {
+            const accepted = acceptRoll < 0.9;
+            telemetry.recordFeedback(id, {
+                decision: accepted ? "accepted" : "rejected",
+                executionResult: accepted ? { success: true, violations: [] } : { success: false, violations: ["resource_leak"] },
+                timestamp: Date.now(),
+            });
+        }
+        else {
+            const accepted = acceptRoll < 0.2;
+            telemetry.recordFeedback(id, {
+                decision: accepted ? "accepted" : "rejected",
+                executionResult: accepted ? { success: false, violations: ["resource_leak"] } : undefined,
+                timestamp: Date.now(),
+            });
+        }
+    }
+}
+(0, vitest_1.describe)("LogisticRewardModel", () => {
+    (0, vitest_1.it)("trains on telemetry data and converges", () => {
+        const telemetry = new planner_telemetry_1.PlannerTelemetry(path.join(LR_DIR, ".progmune_corpus", "telemetry", `lr-train-${Date.now()}.jsonl`));
+        seedTrainingData(telemetry, 200);
+        const model = logistic_reward_1.LogisticRewardModel.train(telemetry);
+        (0, vitest_1.expect)(model.isTrained).toBe(true);
+        (0, vitest_1.expect)(model.sampleCount).toBeGreaterThanOrEqual(50);
+        (0, vitest_1.expect)(model.finalLoss).toBeLessThan(1.0); // should be better than random
+        // Weights should be non-zero after training
+        (0, vitest_1.expect)(model.weights.some(w => Math.abs(w) > 1e-6)).toBe(true);
+        model.printWeights();
+    });
+    (0, vitest_1.it)("produces valid probability scores [0,1]", () => {
+        const telemetry = new planner_telemetry_1.PlannerTelemetry(path.join(LR_DIR, ".progmune_corpus", "telemetry", `lr-score-${Date.now()}.jsonl`));
+        seedTrainingData(telemetry, 100);
+        const model = logistic_reward_1.LogisticRewardModel.train(telemetry);
+        // Safe repair should score higher than leaky repair
+        const safeFeatures = {
+            protocolSafety: 1.0, historicalSuccessRate: 0.8, actionCount: 3,
+            latencyCost: 0.4, auditability: 0.75, corpusEvidence: 5, source: "protocol",
+        };
+        const leakyFeatures = {
+            protocolSafety: 0.3, historicalSuccessRate: 0.3, actionCount: 2,
+            latencyCost: 0.3, auditability: 0.4, corpusEvidence: 1, source: "corpus",
+        };
+        const safeScore = model.score(safeFeatures, { acceptanceRate: 0.85, executionSuccessRate: 0.9 });
+        const leakyScore = model.score(leakyFeatures, { acceptanceRate: 0.15, executionSuccessRate: 0.1 });
+        (0, vitest_1.expect)(safeScore).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(safeScore).toBeLessThanOrEqual(1);
+        (0, vitest_1.expect)(leakyScore).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(leakyScore).toBeLessThanOrEqual(1);
+        // Safe should score higher than leaky
+        (0, vitest_1.expect)(safeScore).toBeGreaterThan(leakyScore);
+    });
+    (0, vitest_1.it)("falls back gracefully with insufficient data", () => {
+        const telemetry = new planner_telemetry_1.PlannerTelemetry(path.join(LR_DIR, ".progmune_corpus", "telemetry", `lr-fallback-${Date.now()}.jsonl`));
+        // Only 5 samples — below minSamples=50
+        seedTrainingData(telemetry, 5);
+        const model = logistic_reward_1.LogisticRewardModel.train(telemetry);
+        (0, vitest_1.expect)(model.isTrained).toBe(false);
+        (0, vitest_1.expect)(model.sampleCount).toBe(5);
+        // Should still produce valid scores (weights are initialized to 0)
+        const score = model.score({ protocolSafety: 0.5, historicalSuccessRate: 0.5, actionCount: 2, latencyCost: 0.3, auditability: 0.5, corpusEvidence: 0, source: "protocol" }, { acceptanceRate: 0.5, executionSuccessRate: 0.5 });
+        (0, vitest_1.expect)(score).toBeCloseTo(0.5, 1); // sigmoid(0) = 0.5
+    });
+    (0, vitest_1.it)("feature importance is interpretable", () => {
+        const telemetry = new planner_telemetry_1.PlannerTelemetry(path.join(LR_DIR, ".progmune_corpus", "telemetry", `lr-importance-${Date.now()}.jsonl`));
+        seedTrainingData(telemetry, 150);
+        const model = logistic_reward_1.LogisticRewardModel.train(telemetry);
+        const importance = model.featureImportance();
+        (0, vitest_1.expect)(importance.length).toBe(7);
+        // Top features should have positive importance
+        (0, vitest_1.expect)(importance[0].importance).toBeGreaterThan(0);
+        model.printWeights();
+    });
+    (0, vitest_1.it)("export/import roundtrip preserves weights", () => {
+        const telemetry = new planner_telemetry_1.PlannerTelemetry(path.join(LR_DIR, ".progmune_corpus", "telemetry", `lr-export-${Date.now()}.jsonl`));
+        seedTrainingData(telemetry, 100);
+        const original = logistic_reward_1.LogisticRewardModel.train(telemetry);
+        const exported = original.exportWeights();
+        const imported = logistic_reward_1.LogisticRewardModel.importWeights(exported);
+        (0, vitest_1.expect)(imported.isTrained).toBe(true);
+        (0, vitest_1.expect)(imported.sampleCount).toBe(original.sampleCount);
+        (0, vitest_1.expect)(imported.weights).toEqual(original.weights);
+        (0, vitest_1.expect)(imported.bias).toBe(original.bias);
+        // Scores should be identical
+        const features = { protocolSafety: 0.7, historicalSuccessRate: 0.5, actionCount: 2, latencyCost: 0.3, auditability: 0.6, corpusEvidence: 3, source: "protocol" };
+        const stats = { acceptanceRate: 0.8, executionSuccessRate: 0.9 };
+        (0, vitest_1.expect)(imported.score(features, stats)).toBe(original.score(features, stats));
+    });
+});
+(0, vitest_1.describe)("Model Comparison", () => {
+    (0, vitest_1.it)("compares LogisticReward against baseline", () => {
+        const telemetry = new planner_telemetry_1.PlannerTelemetry(path.join(LR_DIR, ".progmune_corpus", "telemetry", `lr-compare-${Date.now()}.jsonl`));
+        seedTrainingData(telemetry, 300);
+        const comparisons = (0, logistic_reward_1.compareModels)(telemetry);
+        (0, vitest_1.expect)(comparisons.length).toBeGreaterThanOrEqual(1);
+        const lr = comparisons.find(c => c.model === "LogisticReward");
+        if (lr.trained) {
+            (0, vitest_1.expect)(lr.accuracy).toBeGreaterThan(0.5); // better than random
+            (0, vitest_1.expect)(lr.logLoss).toBeLessThan(1.0);
+        }
+        console.log("\n─── Model Comparison ───");
+        for (const c of comparisons) {
+            console.log(`  ${c.model.padEnd(22)} acc=${(c.accuracy * 100).toFixed(1)}%  logLoss=${c.logLoss.toFixed(4)}`);
+        }
+    });
+});

package/dist/macro-graph.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * P5.0: Hierarchical Macro Graph
+ *
+ * Lifts MacroRepairs from a flat catalog into a composable skill graph.
+ * Each MacroNode is a "skill" with preconditions, actions, postconditions,
+ * and reward, enabling hierarchical planning.
+ *
+ * AlphaGo Zero analogy:
+ *   Primitive action = single function call
+ *   Macro = 定式 (joseki) — a proven sequence that achieves a known outcome
+ *   MacroGraph = opening book + pattern library
+ *
+ * Planner search depth is reduced by an order of magnitude when it
+ * can search macro nodes instead of individual actions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MacroGraphBuilder = void 0;
+const macro_repair_1 = require("./macro-repair");
+// ═══════════════════════════════════════════════════════════════
+// State Inference
+// ═══════════════════════════════════════════════════════════════
+/** Infer pre/post conditions — only preconditions NOT produced by the chain are true preconditions. */
+function inferConditions(actions, rules) {
+    const allPre = new Set();
+    const produced = new Set();
+    const invalidated = new Set();
+    let current = new Set();
+    for (const fn of actions) {
+        const rule = rules.get(fn);
+        if (!rule)
+            continue;
+        // Collect all preconditions needed at any step
+        for (const p of rule.pre_states) {
+            if (p.length > 0)
+                allPre.add(p);
+        }
+        // Apply: invalidate current, then produce
+        if (rule.invalidate)
+            rule.invalidate.forEach(s => { invalidated.add(s); current.delete(s); });
+        for (const p of rule.post_states) {
+            current.add(p);
+            produced.add(p);
+        }
+    }
+    // True preconditions: needed but NOT produced by any action in the chain
+    const preconditions = [...allPre].filter(p => !produced.has(p));
+    // Postconditions: active states + invalidated states
+    const postconditions = [...current, ...invalidated].filter(s => s.length > 0);
+    return { preconditions, postconditions };
+}
+// ═══════════════════════════════════════════════════════════════
+// Macro Graph Builder
+// ═══════════════════════════════════════════════════════════════
+class MacroGraphBuilder {
+    constructor() {
+        this._graph = { nodes: new Map(), edges: [] };
+    }
+    /**
+     * Learn macro nodes from telemetry data.
+     * Mines MacroRepairs and converts them into MacroNodes with state conditions.
+     */
+    learnMacros(telemetry, rules, minAcceptance = 0.7, minFrequency = 3) {
+        const macros = (0, macro_repair_1.mineMacroRepairs)(telemetry, minAcceptance, minFrequency);
+        for (const macro of macros) {
+            const { preconditions, postconditions } = inferConditions(macro.actions, rules);
+            const nodeId = macro.id;
+            if (this._graph.nodes.has(nodeId))
+                continue;
+            this._graph.nodes.set(nodeId, {
+                id: nodeId,
+                name: macro.actions.join(" → "),
+                protocol: macro.protocol,
+                preconditions,
+                actions: macro.actions,
+                postconditions,
+                reward: macro.acceptanceRate * 0.7 + macro.executionSuccessRate * 0.3,
+                frequency: macro.frequency,
+                source: macro,
+            });
+        }
+        // Link macros: find composable pairs (post of A matches pre of B)
+        this.linkMacros();
+        return this._graph;
+    }
+    /** Link macros into a composable graph based on state matching. */
+    linkMacros() {
+        const nodeList = [...this._graph.nodes.values()];
+        for (const a of nodeList) {
+            for (const b of nodeList) {
+                if (a.id === b.id)
+                    continue;
+                // Check if A's postconditions satisfy B's preconditions
+                const overlap = b.preconditions.filter(p => a.postconditions.includes(p));
+                if (overlap.length > 0 || a.postconditions.length === 0 || b.preconditions.length === 0) {
+                    this._graph.edges.push({
+                        from: a.id, to: b.id,
+                        frequency: Math.min(a.frequency, b.frequency),
+                        successRate: a.reward * b.reward,
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Compose a chain of macros from start state to goal state.
+     *
+     * Uses the macro graph to find multi-step skill chains,
+     * reducing the planner's search depth compared to action-level BFS.
+     */
+    compose(currentStates, targetStates, maxDepth = 5) {
+        const chains = [];
+        const currentSet = new Set(currentStates);
+        const targetSet = new Set(targetStates);
+        // Find macros whose preconditions are satisfied by current state
+        const startable = [...this._graph.nodes.values()].filter(n => n.preconditions.length === 0 || n.preconditions.every(p => currentSet.has(p)));
+        // BFS over macro nodes
+        const visited = new Set();
+        const queue = startable.map(m => ({ macros: [m], states: new Set([...currentStates, ...m.postconditions]), depth: 1 }));
+        while (queue.length > 0 && chains.length < 10) {
+            const { macros, states, depth } = queue.shift();
+            if (depth > maxDepth)
+                continue;
+            // Check if target reached
+            if (targetSet.size > 0 && targetStates.every(t => states.has(t))) {
+                chains.push(macros);
+                continue;
+            }
+            // Find next macro
+            for (const node of this._graph.nodes.values()) {
+                if (macros.some(m => m.id === node.id))
+                    continue; // no cycles
+                const preOk = node.preconditions.length === 0 || node.preconditions.every(p => states.has(p));
+                if (!preOk)
+                    continue;
+                const nextStates = new Set(states);
+                for (const p of node.postconditions)
+                    nextStates.add(p);
+                const key = macros.map(m => m.id).join("→") + "→" + node.id;
+                if (visited.has(key))
+                    continue;
+                visited.add(key);
+                queue.push({ macros: [...macros, node], states: nextStates, depth: depth + 1 });
+            }
+        }
+        // Sort by total reward
+        chains.sort((a, b) => {
+            const rewardA = a.reduce((s, m) => s + m.reward, 0) / a.length;
+            const rewardB = b.reduce((s, m) => s + m.reward, 0) / b.length;
+            return rewardB - rewardA;
+        });
+        return chains;
+    }
+    /** Get all macro chains from the graph. */
+    getAllMacroChains(maxDepth = 3) {
+        const chains = [];
+        const nodeList = [...this._graph.nodes.values()];
+        for (const start of nodeList) {
+            // Find chains starting from this node (using graph edges)
+            const visited = new Set();
+            const queue = [{ macros: [start], depth: 1 }];
+            while (queue.length > 0 && chains.length < 50) {
+                const { macros, depth } = queue.shift();
+                if (depth > maxDepth)
+                    continue;
+                if (macros.length > 1)
+                    chains.push(macros);
+                const last = macros[macros.length - 1];
+                const nextEdges = this._graph.edges.filter(e => e.from === last.id);
+                for (const edge of nextEdges) {
+                    const next = this._graph.nodes.get(edge.to);
+                    if (!next)
+                        continue;
+                    const key = macros.map(m => m.id).join("→") + "→" + next.id;
+                    if (visited.has(key))
+                        continue;
+                    visited.add(key);
+                    queue.push({ macros: [...macros, next], depth: depth + 1 });
+                }
+            }
+        }
+        chains.sort((a, b) => {
+            const rA = a.reduce((s, m) => s + m.reward, 0) / a.length;
+            const rB = b.reduce((s, m) => s + m.reward, 0) / b.length;
+            return rB - rA;
+        });
+        return chains;
+    }
+    get graph() { return this._graph; }
+    get nodeCount() { return this._graph.nodes.size; }
+    get edgeCount() { return this._graph.edges.length; }
+}
+exports.MacroGraphBuilder = MacroGraphBuilder;

package/dist/macro-repair.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * P4.6: Macro Repair Mining
+ *
+ * Mines high-acceptance trajectory patterns from Telemetry
+ * and converts them into reusable MacroRepair templates.
+ *
+ * A MacroRepair is a frequently-accepted action sequence that
+ * can be directly suggested as a repair candidate — serving
+ * as a fourth candidate source alongside Corpus/Protocol/Antibody.
+ *
+ * Example mined macro:
+ *   verify_password → generate_jwt → create_session
+ *   (acceptance: 92%, frequency: 45)
+ */
+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.mineMacroRepairs = mineMacroRepairs;
+exports.saveMacroRepairs = saveMacroRepairs;
+exports.loadMacroRepairs = loadMacroRepairs;
+exports.printMacroReport = printMacroReport;
+const planner_telemetry_1 = require("./planner-telemetry");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const MACRO_DIR = path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd(), ".progmune_corpus", "macros");
+function ensureDir(dir) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+}
+// ═══════════════════════════════════════════════════════════════
+// Mining
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Mine high-acceptance action sequences from telemetry data.
+ *
+ * Scans all decisions with feedback, groups by action signature,
+ * and identifies sequences that meet minimum acceptance + frequency thresholds.
+ */
+function mineMacroRepairs(telemetry, minAcceptance = 0.7, minFrequency = 3) {
+    const decisions = telemetry.all();
+    // Group by action signature + protocol
+    const groups = new Map();
+    for (const d of decisions) {
+        if (!d.feedback || !d.selectedCandidateId || !d.protocol)
+            continue;
+        const sel = d.candidates.find(c => c.candidateId === d.selectedCandidateId);
+        if (!sel || sel.actions.length === 0)
+            continue;
+        const key = `${d.protocol}:${sel.actions.join("→")}`;
+        const entry = groups.get(key);
+        if (entry) {
+            entry.count++;
+            if (d.feedback.decision === "accepted")
+                entry.accepted++;
+            else
+                entry.rejected++;
+            if (d.feedback.executionResult?.success === true)
+                entry.execSuccess++;
+            else if (d.feedback.executionResult?.success === false)
+                entry.execFailure++;
+            if (d.cost?.latencyMs)
+                entry.totalLatency += d.cost.latencyMs;
+            entry.goals.set(d.goal, (entry.goals.get(d.goal) || 0) + 1);
+            entry.violationTypes.set(d.violationType || "unknown", (entry.violationTypes.get(d.violationType || "unknown") || 0) + 1);
+        }
+        else {
+            groups.set(key, {
+                accepted: d.feedback.decision === "accepted" ? 1 : 0,
+                rejected: d.feedback.decision === "rejected" ? 1 : 0,
+                execSuccess: d.feedback.executionResult?.success === true ? 1 : 0,
+                execFailure: d.feedback.executionResult?.success === false ? 1 : 0,
+                totalLatency: d.cost?.latencyMs || 0,
+                count: 1,
+                goals: new Map([[d.goal, 1]]),
+                violationTypes: new Map([[d.violationType || "unknown", 1]]),
+            });
+        }
+    }
+    const macros = [];
+    for (const [key, entry] of groups) {
+        if (entry.count < minFrequency)
+            continue;
+        const totalFeedback = entry.accepted + entry.rejected;
+        const acceptanceRate = totalFeedback > 0 ? entry.accepted / totalFeedback : 0;
+        if (acceptanceRate < minAcceptance)
+            continue;
+        const execTotal = entry.execSuccess + entry.execFailure;
+        const executionSuccessRate = execTotal > 0 ? entry.execSuccess / execTotal : 0;
+        const [protocol, actionStr] = key.split(":");
+        const actions = actionStr.split("→");
+        const topGoal = [...entry.goals.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] || "unknown";
+        const topViolation = [...entry.violationTypes.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] || "unknown";
+        macros.push({
+            id: `macro-${(0, planner_telemetry_1.candidateFingerprint)(protocol, actions, topViolation)}`,
+            actions,
+            protocol,
+            violationType: topViolation,
+            acceptanceRate,
+            executionSuccessRate,
+            frequency: entry.count,
+            avgLatencyMs: entry.count > 0 ? entry.totalLatency / entry.count : 0,
+            goal: topGoal,
+        });
+    }
+    return macros.sort((a, b) => b.acceptanceRate - a.acceptanceRate);
+}
+/**
+ * Persist mined macros for reuse across sessions.
+ */
+function saveMacroRepairs(macros) {
+    ensureDir(MACRO_DIR);
+    const filepath = path.join(MACRO_DIR, `macros-${new Date().toISOString().slice(0, 10)}.json`);
+    fs.writeFileSync(filepath, JSON.stringify(macros, null, 2));
+    return filepath;
+}
+/**
+ * Load previously mined macros.
+ */
+function loadMacroRepairs() {
+    if (!fs.existsSync(MACRO_DIR))
+        return [];
+    const macros = [];
+    const files = fs.readdirSync(MACRO_DIR).filter(f => f.endsWith(".json"));
+    for (const file of files) {
+        try {
+            const data = JSON.parse(fs.readFileSync(path.join(MACRO_DIR, file), "utf-8"));
+            if (Array.isArray(data))
+                macros.push(...data);
+        }
+        catch { /* skip */ }
+    }
+    return macros.sort((a, b) => b.acceptanceRate - a.acceptanceRate);
+}
+function printMacroReport(macros) {
+    console.log("\n─── Macro Repair Mining Report ───");
+    console.log(`Mined ${macros.length} high-acceptance repair templates\n`);
+    if (macros.length === 0) {
+        console.log("  No macros meet the minimum thresholds. Collect more feedback data.");
+        return;
+    }
+    console.log("Top 10 Macros:");
+    console.log("Accept  ExecOk  Freq  Actions");
+    console.log("──────────────────────────────────────────────────");
+    for (const m of macros.slice(0, 10)) {
+        const acc = (m.acceptanceRate * 100).toFixed(0).padStart(4);
+        const exec = (m.executionSuccessRate * 100).toFixed(0).padStart(4);
+        const freq = String(m.frequency).padStart(4);
+        console.log(`  ${acc}%  ${exec}%  ${freq}  ${m.actions.join(" → ")}`);
+    }
+    console.log();
+}