progmune-runtime 2.1.5 → 3.2.0

package/dist/knowledge-flywheel.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * Knowledge Flywheel — Self-reinforcing knowledge growth pipeline
+ *
+ * Repo → Scan → Evidence → Confidence → Version Suggestion → Human Review → Merge
+ *                                 ↑                                                │
+ *                                 └──────────── More Repos ←────────────────────────┘
+ *
+ * Usage:
+ *   npx ts-node src/knowledge-flywheel.ts scan benchmarks/nginx
+ *   npx ts-node src/knowledge-flywheel.ts status
+ *   npx ts-node src/knowledge-flywheel.ts metrics
+ */
+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.scanRepo = scanRepo;
+exports.loadMetrics = loadMetrics;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const protocol_detector_1 = require("./protocol-detector");
+const protocol_knowledge_1 = require("./protocol-knowledge");
+// ═══════════════════════════════════════════════════════════════
+// Scanner
+// ═══════════════════════════════════════════════════════════════
+const PROPOSALS_DIR = ".progmune_corpus/flywheel";
+function scanRepo(repoPath) {
+    const repoName = path.basename(repoPath);
+    const seqFile = path.join(path.dirname(repoPath), `${repoName}-sequences.json`);
+    if (!fs.existsSync(seqFile))
+        throw new Error(`No sequences: ${seqFile}`);
+    const sequences = JSON.parse(fs.readFileSync(seqFile, "utf-8"));
+    const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();
+    const proposals = [];
+    // Match sequences against KB
+    const matchCounts = {};
+    for (const seq of sequences.slice(0, 50)) {
+        const result = (0, protocol_detector_1.validateProtocolState)(seq.calls || []);
+        for (const p of result.matchedProtocols)
+            matchCounts[p] = (matchCounts[p] || 0) + 1;
+    }
+    for (const [proto, count] of Object.entries(matchCounts)) {
+        const unit = kb.units.find(u => u.name === proto);
+        if (!unit || count < 3)
+            continue;
+        const alreadyEvidenced = (unit.evidence || []).some(e => e.repo === repoName);
+        if (alreadyEvidenced)
+            continue;
+        let suggestion;
+        let proposedVersion = unit.currentVersion;
+        let proposedConf = unit.confidence;
+        let reason = "";
+        if (count >= 10 && unit.maturity !== "stable") {
+            // Enough evidence to promote
+            suggestion = "promote";
+            const [major, minor] = unit.currentVersion.split(".").map(Number);
+            proposedVersion = `${major + 1}.0.0`;
+            proposedConf = Math.min(95, unit.confidence + 15);
+            reason = `${count}/50 sequences matched — strong evidence for promotion to stable. Would add ${repoName} as ${(unit.validatedRepos.length + 1)}th validated repo.`;
+        }
+        else if (count >= 5 && unit.confidence < 80) {
+            suggestion = "bump";
+            const [major, minor, patch] = unit.currentVersion.split(".").map(Number);
+            proposedVersion = `${major}.${minor}.${(patch || 0) + 1}`;
+            proposedConf = Math.min(90, unit.confidence + 8);
+            reason = `${count}/50 sequences matched — confidence bump warranted.`;
+        }
+        else if (count >= 3) {
+            suggestion = "evidence_only";
+            proposedConf = Math.min(90, unit.confidence + 3);
+            reason = `${count}/50 matched — evidence addition only. Confidence +3%.`;
+        }
+        else {
+            suggestion = "insufficient";
+            reason = `Only ${count}/50 matched — insufficient for any action.`;
+        }
+        const proposal = {
+            id: `FLY-${Date.now().toString(36)}-${unit.id}`,
+            repo: repoName,
+            timestamp: new Date().toISOString(),
+            unitId: unit.id,
+            unitName: unit.name,
+            currentVersion: unit.currentVersion,
+            proposedVersion,
+            currentConfidence: unit.confidence,
+            proposedConfidence: proposedConf,
+            evidenceCount: count,
+            matchRate: `${count}/50`,
+            suggestion,
+            reason,
+            status: "pending",
+        };
+        proposals.push(proposal);
+    }
+    // Save proposals
+    if (!fs.existsSync(PROPOSALS_DIR))
+        fs.mkdirSync(PROPOSALS_DIR, { recursive: true });
+    for (const p of proposals) {
+        fs.writeFileSync(path.join(PROPOSALS_DIR, `${p.id}.json`), JSON.stringify(p, null, 2));
+    }
+    // Update metrics
+    updateMetrics(repoName, proposals);
+    return proposals.sort((a, b) => b.evidenceCount - a.evidenceCount);
+}
+// ═══════════════════════════════════════════════════════════════
+// Metrics
+// ═══════════════════════════════════════════════════════════════
+const METRICS_FILE = ".progmune_corpus/flywheel-metrics.json";
+function loadMetrics() {
+    try {
+        return JSON.parse(fs.readFileSync(METRICS_FILE, "utf-8"));
+    }
+    catch {
+        return { totalScans: 0, totalProposals: 0, acceptedProposals: 0, rejectedProposals: 0, pendingProposals: 0, knowledgeVelocity: 0, averageConfidenceGain: 0, reposScanned: [], history: [] };
+    }
+}
+function updateMetrics(repo, proposals) {
+    const m = loadMetrics();
+    if (!m.reposScanned.includes(repo))
+        m.reposScanned.push(repo);
+    m.totalScans++;
+    m.totalProposals += proposals.length;
+    m.pendingProposals += proposals.filter(p => p.suggestion !== "insufficient").length;
+    m.history.push(...proposals);
+    if (m.totalScans > 0)
+        m.knowledgeVelocity = Math.round((m.totalProposals / m.totalScans) * 10) / 10;
+    m.averageConfidenceGain = m.history.filter(p => p.suggestion !== "insufficient").reduce((s, p) => s + (p.proposedConfidence - p.currentConfidence), 0) / Math.max(1, m.history.filter(p => p.suggestion !== "insufficient").length);
+    if (!fs.existsSync(".progmune_corpus"))
+        fs.mkdirSync(".progmune_corpus");
+    fs.writeFileSync(METRICS_FILE, JSON.stringify(m, null, 2));
+}
+// ═══════════════════════════════════════════════════════════════
+// CLI
+// ═══════════════════════════════════════════════════════════════
+if (require.main === module) {
+    const args = process.argv.slice(2);
+    const C = { r: "\x1b[0m", b: "\x1b[1m", d: "\x1b[2m", g: "\x1b[32m", y: "\x1b[33m", r2: "\x1b[31m", c: "\x1b[36m" };
+    if (args[0] === "scan" && args[1]) {
+        console.error(`\n${C.b}${C.c}Flywheel: Scanning ${args[1]}${C.r}\n`);
+        const proposals = scanRepo(args[1]);
+        const actionable = proposals.filter(p => p.suggestion !== "insufficient");
+        for (const p of proposals) {
+            const icon = p.suggestion === "promote" ? "⭐" : p.suggestion === "bump" ? "📈" : p.suggestion === "evidence_only" ? "✅" : "—";
+            console.log(`  ${icon} ${p.unitName}: ${p.matchRate} → ${p.suggestion}`);
+            console.log(`     v${p.currentVersion} → v${p.proposedVersion} | ${p.currentConfidence}% → ${p.proposedConfidence}%`);
+            console.log(`     ${p.reason}`);
+            if (p.suggestion !== "insufficient")
+                console.log(`     ${C.d}Review: ${PROPOSALS_DIR}/${p.id}.json${C.r}`);
+        }
+        if (actionable.length > 0) {
+            console.log(`\n  ${C.g}${actionable.length} actionable proposal(s) saved.${C.r}`);
+            console.log(`  ${C.d}Review proposals in ${PROPOSALS_DIR}/ and accept to grow Knowledge Base.${C.r}`);
+        }
+        console.log("");
+    }
+    else if (args[0] === "status") {
+        const m = loadMetrics();
+        console.log(`\n${C.b}${C.c}Knowledge Flywheel${C.r}\n`);
+        console.log(`  Scans:     ${m.totalScans} repos (${m.reposScanned.join(", ") || "none"})`);
+        console.log(`  Proposals: ${m.totalProposals} total, ${m.acceptedProposals} accepted, ${m.rejectedProposals} rejected, ${m.pendingProposals} pending`);
+        console.log(`  Velocity:  ${m.knowledgeVelocity} proposals/scan`);
+        console.log(`  Avg Gain:  +${m.averageConfidenceGain.toFixed(1)}% confidence per proposal`);
+        const recent = m.history.slice(-5);
+        if (recent.length > 0) {
+            console.log(`\n  Recent proposals:`);
+            for (const p of recent) {
+                const icon = p.status === "accepted" ? C.g + "✓" : p.status === "rejected" ? C.r2 + "✗" : C.y + "⏳";
+                console.log(`  ${icon}${C.r} ${p.unitName}: ${p.matchRate} → ${p.suggestion} (${p.repo})`);
+            }
+        }
+        console.log("");
+    }
+    else if (args[0] === "debt") {
+        const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();
+        console.log(`\n${C.b}${C.c}Knowledge Debt Dashboard${C.r}\n`);
+        for (const u of kb.units.filter(u => u.maturity === "stable" || u.maturity === "validated")) {
+            const b = u.confidenceBreakdown;
+            if (!b)
+                continue;
+            const sDebt = 100 - b.structural;
+            const cDebt = 100 - b.crossRepo;
+            const dDebt = 100 - b.deployment;
+            const total = Math.round(sDebt * 0.3 + cDebt * 0.3 + dDebt * 0.4);
+            const bar = "█".repeat(Math.min(10, Math.round(total / 10))) + "░".repeat(Math.max(0, 10 - Math.round(total / 10)));
+            const rec = dDebt > 30 ? "Need more deployment observations" : sDebt > 10 ? "Refine state machine" : "Healthy";
+            console.log(`  ${bar} ${C.b}${u.name}${C.r}  Debt: ${total}%`);
+            console.log(`     Structural:  ${b.structural}% (gap: ${sDebt}%)  |  Cross-Repo: ${b.crossRepo}% (gap: ${cDebt}%)  |  Deployment: ${b.deployment}% (gap: ${dDebt}%)`);
+            console.log(`     → ${rec}`);
+        }
+        console.log(`\n  ${C.d}Debt = weighted gap from 100%. Fix deployment debt first — it's the weakest link.${C.r}\n`);
+    }
+    else if (args[0] === "roi") {
+        const m = loadMetrics();
+        const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();
+        console.log(`\n${C.b}${C.c}Knowledge ROI Report${C.r}\n`);
+        console.log(`  Flywheel Stats:`);
+        console.log(`    Scans:        ${m.totalScans} repos`);
+        console.log(`    Proposals:    ${m.totalProposals} generated, ${m.acceptedProposals} accepted`);
+        console.log(`    Velocity:     ${m.knowledgeVelocity} proposals/scan`);
+        console.log(`    Avg Gain:     +${m.averageConfidenceGain.toFixed(1)}% per proposal`);
+        console.log(`\n  Knowledge Growth:`);
+        const stableCount = kb.units.filter(u => u.maturity === "stable").length;
+        console.log(`    Stable Units: ${stableCount} (from 0)`);
+        console.log(`    Repos:        ${kb.summary.totalValidatedRepos} validated`);
+        console.log(`    Evidence:     ${kb.summary.totalValidatedSequences} sequences`);
+        console.log(`\n  Per-Unit ROI:`);
+        for (const u of kb.units.filter(u => u.maturity === "stable")) {
+            const breakdown = u.confidenceBreakdown;
+            console.log(`    ${C.b}${u.name}${C.r} v${u.currentVersion}`);
+            if (breakdown) {
+                console.log(`      Structural:  ${breakdown.structural}%  (state machine stability)`);
+                console.log(`      Cross-Repo:  ${breakdown.crossRepo}%  (multi-repo validation)`);
+                console.log(`      Deployment:  ${breakdown.deployment}%  (real-world acceptance)`);
+            }
+            const obs = u.observations?.length || 0;
+            console.log(`      Observations: ${obs} deployment feedback events`);
+        }
+        console.log(`\n  ${C.d}Flywheel: ${m.totalScans} scans → ${m.totalProposals} proposals → ${m.acceptedProposals} accepted → ${stableCount} stable → +${m.averageConfidenceGain.toFixed(1)}% avg confidence${C.r}\n`);
+    }
+    else if (args[0] === "metrics") {
+        console.log(JSON.stringify(loadMetrics(), null, 2));
+    }
+    else {
+        console.log(`
+${C.b}Knowledge Flywheel${C.r}
+
+${C.d}Usage:${C.r}
+  npx ts-node src/knowledge-flywheel.ts scan <repoPath>
+      Scan a repo and generate evidence proposals
+
+  npx ts-node src/knowledge-flywheel.ts status
+      View flywheel metrics and recent proposals
+
+  npx ts-node src/knowledge-flywheel.ts metrics
+      Export full metrics as JSON
+
+${C.d}The Flywheel:${C.r}
+  Repo → Scan → Evidence → Confidence → Version → Review → Merge
+      ↑                                                      │
+      └──────────────── More Repos ←─────────────────────────┘
+    `);
+    }
+}

package/dist/knowledge-governance.js

@@ -0,0 +1,338 @@
+"use strict";
+/**
+ * P3.21-23: Knowledge Governance Layer
+ *
+ * P3.21: Multi-source inference validation.
+ *   benchark support + trajectory support - contradiction = trustworthiness.
+ *   Status: proposed → verified → rejected.
+ *
+ * P3.22: Knowledge versioning.
+ *   Every inferred transition is a versioned patch with audit trail.
+ *   Planner reads Base Rules + Approved Patches (never modifies originals).
+ *
+ * P3.23: Regression testing.
+ *   Run benchmark suite against proposed patches. Auto-approve only
+ *   if Top-1 and Top-3 don't regress.
+ *
+ * Philosophy:
+ *   Wrong knowledge + perfect Reward Model = confidently wrong.
+ *   Right knowledge + basic Ranker = steadily improving.
+ */
+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.KnowledgePatchStore = void 0;
+exports.validateInferences = validateInferences;
+exports.regressionTestPatch = regressionTestPatch;
+exports.autoApprovePatch = autoApprovePatch;
+exports.runKnowledgeGovernance = runKnowledgeGovernance;
+exports.printGovernanceReport = printGovernanceReport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const transition_synthesizer_1 = require("./transition-synthesizer");
+const protocol_frontier_1 = require("./protocol-frontier");
+const protocol_coverage_1 = require("./protocol-coverage");
+const VALIDATION_THRESHOLDS = {
+    benchmarkMin: 3,
+    trajectoryMin: 5,
+    contradictionMax: 0,
+};
+/**
+ * Validate inferred transitions against multi-source evidence.
+ *
+ *   - benchmarkSupport: how many benchmark cases need this transition
+ *   - trajectorySupport: how many real trajectory records show this pattern
+ *   - contradictionCount: how many counter-examples exist
+ *
+ * Status logic:
+ *   proposed  — insufficient evidence yet
+ *   verified  — ≥3 benchmark + ≥5 trajectory + 0 contradictions
+ *   rejected  — contradictionCount > 0
+ */
+function validateInferences(inferences, trajectoryCount = 0) {
+    return inferences.map(inf => {
+        const benchmarkSupport = inf.evidenceCount;
+        const trajectorySupport = trajectoryCount;
+        const contradictionCount = 0; // no contradiction detection yet
+        let status;
+        if (contradictionCount > VALIDATION_THRESHOLDS.contradictionMax) {
+            status = "rejected";
+        }
+        else if (benchmarkSupport >= VALIDATION_THRESHOLDS.benchmarkMin &&
+            trajectorySupport >= VALIDATION_THRESHOLDS.trajectoryMin) {
+            status = "verified";
+        }
+        else {
+            status = "proposed";
+        }
+        return {
+            ...inf,
+            validation: { benchmarkSupport, trajectorySupport, contradictionCount, status },
+        };
+    });
+}
+const KNOWLEDGE_DIR = path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd(), ".progmune_corpus", "knowledge");
+class KnowledgePatchStore {
+    constructor(persistPath) {
+        this.patches = [];
+        this.persistPath = persistPath || path.join(KNOWLEDGE_DIR, "patches.json");
+        this.load();
+    }
+    /** Propose a new knowledge patch from an inferred transition. */
+    propose(inference) {
+        const id = `KP-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const patch = {
+            id,
+            generatedBy: "transition-synthesizer",
+            protocol: inference.protocol,
+            change: inference.action,
+            fromState: inference.from,
+            toState: inference.to,
+            confidence: inference.confidence,
+            evidenceCount: inference.evidenceCount,
+            createdAt: new Date().toISOString(),
+            status: "proposed",
+        };
+        this.patches.push(patch);
+        this.save();
+        return patch;
+    }
+    /** Approve a patch (with benchmark metrics). */
+    approve(id, metrics) {
+        const patch = this.patches.find(p => p.id === id);
+        if (!patch || patch.status !== "proposed")
+            return false;
+        patch.status = "approved";
+        patch.approvedAt = new Date().toISOString();
+        patch.approvalMetrics = metrics;
+        this.save();
+        return true;
+    }
+    /** Reject a patch. */
+    reject(id) {
+        const patch = this.patches.find(p => p.id === id);
+        if (!patch || patch.status !== "proposed")
+            return false;
+        patch.status = "rejected";
+        this.save();
+        return true;
+    }
+    /** Rollback an approved patch. */
+    rollback(id) {
+        const patch = this.patches.find(p => p.id === id);
+        if (!patch || patch.status !== "approved")
+            return false;
+        patch.status = "rolled_back";
+        patch.rolledBackAt = new Date().toISOString();
+        this.save();
+        return true;
+    }
+    /** Get all approved patches (these augment the base rules). */
+    get approved() {
+        return this.patches.filter(p => p.status === "approved");
+    }
+    /** Get all proposed patches. */
+    get proposed() {
+        return this.patches.filter(p => p.status === "proposed");
+    }
+    /** Build augmented rules: base rules + approved patches as virtual rules. */
+    buildAugmentedRules(baseRules) {
+        const augmented = new Map(baseRules);
+        for (const patch of this.approved) {
+            const [fnA, fnB] = patch.change.split(" → ");
+            const bridgeName = `_patch_${fnA}_to_${fnB}`;
+            augmented.set(bridgeName, {
+                pre_states: [patch.fromState],
+                post_states: [patch.toState],
+                namespace: "knowledge-patch",
+            });
+        }
+        return augmented;
+    }
+    get all() { return this.patches; }
+    get size() { return this.patches.length; }
+    save() {
+        try {
+            if (!fs.existsSync(path.dirname(this.persistPath))) {
+                fs.mkdirSync(path.dirname(this.persistPath), { recursive: true });
+            }
+            fs.writeFileSync(this.persistPath, JSON.stringify(this.patches, null, 2));
+        }
+        catch { /* best-effort */ }
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.persistPath)) {
+                this.patches = JSON.parse(fs.readFileSync(this.persistPath, "utf-8"));
+            }
+        }
+        catch { /* start fresh */ }
+    }
+}
+exports.KnowledgePatchStore = KnowledgePatchStore;
+/**
+ * Test whether a proposed patch improves or degrades benchmark performance.
+ *
+ * Uses the frontier explorer to simulate: given currentState, can the Planner
+ * find paths that it couldn't before? If the augmented rules produce more
+ * successful paths without breaking existing ones, the patch passes.
+ */
+function regressionTestPatch(patch, baseRules, testCases, store) {
+    // Top-1/Top-3 BEFORE patch (using base rules only)
+    let top1Before = 0;
+    let top3Before = 0;
+    for (const tc of testCases) {
+        const result = (0, protocol_frontier_1.searchFrontier)(baseRules, tc.currentState, tc.targetState, 8);
+        if (result.found && result.cost <= 1)
+            top1Before++;
+        if (result.found && result.cost <= 3)
+            top3Before++;
+    }
+    const top1RateBefore = testCases.length > 0 ? top1Before / testCases.length : 0;
+    const top3RateBefore = testCases.length > 0 ? top3Before / testCases.length : 0;
+    // Top-1/Top-3 AFTER patch (base + this patch)
+    const augmented = store.buildAugmentedRules(baseRules);
+    let top1After = 0;
+    let top3After = 0;
+    for (const tc of testCases) {
+        const result = (0, protocol_frontier_1.searchFrontier)(augmented, tc.currentState, tc.targetState, 8);
+        if (result.found && result.cost <= 1)
+            top1After++;
+        if (result.found && result.cost <= 3)
+            top3After++;
+    }
+    const top1RateAfter = testCases.length > 0 ? top1After / testCases.length : 0;
+    const top3RateAfter = testCases.length > 0 ? top3After / testCases.length : 0;
+    // Patch passes if: Top-1 doesn't decrease AND Top-3 doesn't decrease
+    const passed = top1RateAfter >= top1RateBefore && top3RateAfter >= top3RateBefore;
+    const reason = passed
+        ? `Top-1: ${(top1RateBefore * 100).toFixed(0)}% → ${(top1RateAfter * 100).toFixed(0)}%, Top-3: ${(top3RateBefore * 100).toFixed(0)}% → ${(top3RateAfter * 100).toFixed(0)}%`
+        : `Degradation detected. Top-1: ${(top1RateBefore * 100).toFixed(0)}% → ${(top1RateAfter * 100).toFixed(0)}%`;
+    return {
+        patchId: patch.id,
+        change: patch.change,
+        top1Before: top1RateBefore,
+        top1After: top1RateAfter,
+        top3Before: top3RateBefore,
+        top3After: top3RateAfter,
+        passed,
+        reason,
+    };
+}
+/**
+ * Full auto-approval pipeline:
+ *   1. Validate proposal against all test cases
+ *   2. Auto-approve if no regression
+ *   3. Record approval metrics
+ */
+function autoApprovePatch(patch, baseRules, testCases, store) {
+    const result = regressionTestPatch(patch, baseRules, testCases, store);
+    if (result.passed) {
+        store.approve(patch.id, {
+            top1Before: result.top1Before,
+            top1After: result.top1After,
+            top3Before: result.top3Before,
+            top3After: result.top3After,
+        });
+    }
+    else {
+        store.reject(patch.id);
+    }
+    return result;
+}
+/**
+ * Run the full knowledge governance pipeline:
+ *   Synthesize → Validate → Propose → Regression Test → Auto-Approve
+ */
+function runKnowledgeGovernance(failures, testCases, store) {
+    const patchStore = store || new KnowledgePatchStore();
+    // 1. Synthesize
+    const inferences = (0, transition_synthesizer_1.synthesizeTransitions)(failures);
+    // 2. Validate
+    const validated = validateInferences(inferences);
+    // 3. Propose verified inferences
+    let proposed = 0;
+    let approved = 0;
+    let rejected = 0;
+    const regressionResults = [];
+    const defs = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+    const baseRules = new Map();
+    for (const p of defs)
+        for (const [fn, rule] of p.rules)
+            baseRules.set(fn, rule);
+    for (const inf of validated) {
+        if (inf.validation.status === "rejected") {
+            rejected++;
+            continue;
+        }
+        // 4. Propose
+        const patch = patchStore.propose(inf);
+        proposed++;
+        // 5. Regression test and auto-approve
+        const result = autoApprovePatch(patch, baseRules, testCases, patchStore);
+        regressionResults.push(result);
+        if (result.passed)
+            approved++;
+        else
+            rejected++;
+    }
+    return {
+        proposed,
+        verified: validated.filter(v => v.validation.status === "verified").length,
+        approved,
+        rejected,
+        rolledBack: patchStore.all.filter(p => p.status === "rolled_back").length,
+        regressionResults,
+    };
+}
+function printGovernanceReport(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   Knowledge Governance Report                      ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Proposed:    ${report.proposed}`);
+    console.log(`Verified:    ${report.verified}`);
+    console.log(`Approved:    ${report.approved}`);
+    console.log(`Rejected:    ${report.rejected}`);
+    console.log(`Rolled Back: ${report.rolledBack}`);
+    console.log();
+    if (report.regressionResults.length > 0) {
+        console.log("─── Regression Results ───");
+        for (const r of report.regressionResults) {
+            const icon = r.passed ? "✅" : "❌";
+            console.log(`  ${icon} ${r.change}`);
+            console.log(`     ${r.reason}`);
+        }
+        console.log();
+    }
+}