progmune-runtime 2.1.6 → 3.2.0

package/dist/autonomous-patch.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * P5.3: Autonomous Patch Generation
+ *
+ * Closes the self-improvement loop by auto-generating goal templates
+ * and knowledge patches from the Skill Library.
+ *
+ * Loop: Skill Library → Goal Templates → Knowledge Patches
+ *       → Regression Test → Auto-Approve → Deploy
+ *
+ * This is the final piece of the autonomous Meta-Learning System.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePatchesFromSkills = generatePatchesFromSkills;
+exports.generateTemplatesFromSkills = generateTemplatesFromSkills;
+exports.runAutonomousPipeline = runAutonomousPipeline;
+exports.printAutonomousReport = printAutonomousReport;
+const knowledge_governance_1 = require("./knowledge-governance");
+const knowledge_governance_2 = require("./knowledge-governance");
+const protocol_coverage_1 = require("./protocol-coverage");
+/**
+ * Generate knowledge patches from high-confidence skills.
+ *
+ * For each skill with success rate > threshold, creates:
+ *   1. A proposed KnowledgePatch
+ *   2. Runs regression test
+ *   3. Auto-approves if no regression
+ *
+ * @returns Results for each skill processed
+ */
+function generatePatchesFromSkills(library, telemetry, patchStore, minSuccessRate = 0.85) {
+    const store = patchStore || new knowledge_governance_1.KnowledgePatchStore();
+    const results = [];
+    // Load protocol rules for regression testing
+    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);
+    // Build test cases: for each skill, verify Frontier can find the skill's actions
+    const testCases = [];
+    for (const skill of library.all()) {
+        testCases.push({
+            currentState: skill.preconditions,
+            targetState: skill.effects.length > 0 ? [skill.effects[0]] : [],
+        });
+    }
+    for (const skill of library.all()) {
+        if (skill.successRate < minSuccessRate) {
+            results.push({
+                skillId: skill.id,
+                skillGoal: skill.goal,
+                status: "skipped",
+                reason: `Success rate ${(skill.successRate * 100).toFixed(0)}% < ${(minSuccessRate * 100).toFixed(0)}% threshold`,
+            });
+            continue;
+        }
+        // Check if already proposed
+        const existing = store.all.find(p => p.change === skill.macro.join(" → "));
+        if (existing) {
+            results.push({
+                skillId: skill.id, skillGoal: skill.goal, patchId: existing.id,
+                status: existing.status === "approved" ? "approved" : "skipped",
+                reason: `Already ${existing.status}`,
+            });
+            continue;
+        }
+        // Propose patch: this skill's macro as a virtual rule
+        const patch = store.propose({
+            from: skill.preconditions[0] || "INIT",
+            to: skill.effects[0] || "COMPLETED",
+            action: skill.macro.join(" → "),
+            protocol: skill.protocol,
+            confidence: skill.successRate,
+            evidenceCount: skill.frequency,
+            examples: [skill.goal],
+            validation: {
+                benchmarkSupport: skill.frequency,
+                trajectorySupport: skill.frequency,
+                contradictionCount: 0,
+                status: "verified",
+            },
+        });
+        results.push({
+            skillId: skill.id,
+            skillGoal: skill.goal,
+            patchId: patch.id,
+            status: "generated",
+            reason: `Proposed from skill (${(skill.successRate * 100).toFixed(0)}% success, ${skill.frequency} samples)`,
+        });
+        // Run regression test
+        const regResult = (0, knowledge_governance_2.regressionTestPatch)(patch, baseRules, testCases, store);
+        if (regResult.passed) {
+            store.approve(patch.id, {
+                top1Before: regResult.top1Before,
+                top1After: regResult.top1After,
+                top3Before: regResult.top3Before,
+                top3After: regResult.top3After,
+            });
+            results[results.length - 1].status = "approved";
+        }
+        else {
+            store.reject(patch.id);
+            results[results.length - 1].status = "rejected";
+        }
+    }
+    return results;
+}
+/**
+ * Auto-generate goal templates from skills.
+ *
+ * Converts each skill's action sequence into a regex pattern
+ * that matches related natural language goals.
+ */
+function generateTemplatesFromSkills(library) {
+    return library.all().map(skill => {
+        // Generate a regex pattern from the action names
+        const keywords = skill.macro
+            .flatMap(fn => fn.split("_"))
+            .filter(w => w.length > 2)
+            .filter(w => !["then", "file", "the"].includes(w));
+        const pattern = keywords.join(".*");
+        return {
+            pattern,
+            protocol: skill.protocol,
+            actions: skill.macro,
+            skillId: skill.id,
+            successRate: skill.successRate,
+        };
+    });
+}
+/**
+ * Run the full autonomous patch generation pipeline.
+ *
+ *   Skill Library → Templates + Patches → Regression → Approve
+ */
+function runAutonomousPipeline(library, telemetry, patchStore) {
+    const store = patchStore || new knowledge_governance_1.KnowledgePatchStore();
+    const patchResults = generatePatchesFromSkills(library, telemetry, store);
+    const templates = generateTemplatesFromSkills(library);
+    const approved = patchResults.filter(r => r.status === "approved").length;
+    const rejected = patchResults.filter(r => r.status === "rejected").length;
+    return {
+        skills: library.size,
+        patchesGenerated: patchResults.length,
+        patchesApproved: approved,
+        patchesRejected: rejected,
+        templatesGenerated: templates.length,
+        summary: approved > 0
+            ? `${approved} patches auto-approved. ${templates.length} templates generated. System is self-extending.`
+            : `No patches met the approval threshold. ${templates.length} templates generated.`,
+    };
+}
+function printAutonomousReport(report, results) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   P5.3 Autonomous Patch Generation                 ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Skills in Library:   ${report.skills}`);
+    console.log(`Patches Generated:   ${report.patchesGenerated}`);
+    console.log(`Patches Approved:    ${report.patchesApproved}`);
+    console.log(`Patches Rejected:    ${report.patchesRejected}`);
+    console.log(`Templates Generated: ${report.templatesGenerated}`);
+    console.log();
+    console.log(`Summary: ${report.summary}`);
+    console.log();
+    if (results && results.length > 0) {
+        console.log("─── Patch Details ───");
+        for (const r of results) {
+            const icon = r.status === "approved" ? "✅" : r.status === "rejected" ? "❌" : r.status === "skipped" ? "⏭️" : "📝";
+            console.log(`  ${icon} ${r.skillGoal}`);
+            console.log(`     ${r.reason}`);
+        }
+        console.log();
+    }
+}

package/dist/autonomous-patch.test.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * P5.3: Autonomous Patch Generation Tests
+ */
+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 skill_library_1 = require("./skill-library");
+const autonomous_patch_1 = require("./autonomous-patch");
+const knowledge_governance_1 = require("./knowledge-governance");
+const planner_telemetry_1 = require("./planner-telemetry");
+const AUTO_DIR = path.resolve(__dirname, "..", "test-autonomous-patch");
+process.env.PROGMUNE_PROJECT_DIR = AUTO_DIR;
+fs.mkdirSync(AUTO_DIR, { recursive: true });
+fs.mkdirSync(path.join(AUTO_DIR, ".progmune_corpus", "telemetry"), { recursive: true });
+fs.mkdirSync(path.join(AUTO_DIR, ".progmune_corpus", "knowledge"), { recursive: true });
+function seedLibrary(telemetry, rules) {
+    // File skill: 90% acceptance
+    for (let i = 0; i < 30; i++) {
+        const a = ["open_file", "write_file", "close_file"];
+        const fp = (0, planner_telemetry_1.candidateFingerprint)("FileProtocol", a, "resource_leak");
+        const id = telemetry.recordDecision({
+            goal: "safely write config file", protocol: "FileProtocol", violationType: "resource_leak",
+            candidates: [{ candidateId: fp, source: "protocol", evidenceSources: ["protocol"], actions: a, explanation: "full" }],
+            selectedCandidateId: fp, cost: { latencyMs: 5 },
+        });
+        telemetry.recordFeedback(id, { decision: Math.random() < 0.92 ? "accepted" : "rejected", executionResult: { success: true, violations: [] }, timestamp: Date.now() });
+    }
+    // Auth skill: 88% acceptance
+    for (let i = 0; i < 30; i++) {
+        const a = ["verify_password", "generate_jwt", "create_session"];
+        const fp = (0, planner_telemetry_1.candidateFingerprint)("AuthProtocol", a, "missing_prerequisite");
+        const id = telemetry.recordDecision({
+            goal: "authenticate user", protocol: "AuthProtocol", violationType: "missing_prerequisite",
+            candidates: [{ candidateId: fp, source: "protocol", evidenceSources: ["protocol"], actions: a, explanation: "auth" }],
+            selectedCandidateId: fp,
+        });
+        telemetry.recordFeedback(id, { decision: Math.random() < 0.88 ? "accepted" : "rejected", executionResult: { success: true, violations: [] }, timestamp: Date.now() });
+    }
+    const r = rules;
+    const lib = new skill_library_1.SkillLibrary();
+    lib.learn(telemetry, r);
+    return lib;
+}
+(0, vitest_1.describe)("Autonomous Patch Generation", () => {
+    (0, vitest_1.it)("generates patches from high-confidence skills", () => {
+        const rules = new Map();
+        rules.set("open_file", { pre_states: [], post_states: ["FILE_OPEN"] });
+        rules.set("write_file", { pre_states: ["FILE_OPEN"], post_states: [] });
+        rules.set("close_file", { pre_states: ["FILE_OPEN"], post_states: [], invalidate: ["FILE_OPEN"] });
+        rules.set("verify_password", { pre_states: ["UNAUTHENTICATED"], post_states: ["PASSWORD_VERIFIED"] });
+        rules.set("generate_jwt", { pre_states: ["PASSWORD_VERIFIED"], post_states: ["TOKEN_ISSUED"], invalidate: ["PASSWORD_VERIFIED"] });
+        rules.set("create_session", { pre_states: ["TOKEN_ISSUED"], post_states: ["SESSION_ACTIVE"], invalidate: ["TOKEN_ISSUED"] });
+        const telemetry = new planner_telemetry_1.PlannerTelemetry(path.join(AUTO_DIR, ".progmune_corpus", "telemetry", `auto-${Date.now()}.jsonl`));
+        const lib = seedLibrary(telemetry, rules);
+        (0, vitest_1.expect)(lib.size).toBeGreaterThanOrEqual(2);
+        const store = new knowledge_governance_1.KnowledgePatchStore(path.join(AUTO_DIR, ".progmune_corpus", "knowledge", `auto-patches-${Date.now()}.json`));
+        const results = (0, autonomous_patch_1.generatePatchesFromSkills)(lib, telemetry, store, 0.85);
+        (0, vitest_1.expect)(results.length).toBeGreaterThanOrEqual(1);
+        // File skill (92%) should be approved; Auth skill (88%) also above threshold
+        const approved = results.filter(r => r.status === "approved");
+        (0, vitest_1.expect)(approved.length).toBeGreaterThanOrEqual(1);
+        (0, autonomous_patch_1.printAutonomousReport)({ skills: lib.size, patchesGenerated: results.length, patchesApproved: approved.length, patchesRejected: results.filter(r => r.status === "rejected").length, templatesGenerated: 0, summary: "" }, results);
+    });
+    (0, vitest_1.it)("generates templates from skills", () => {
+        const rules = new Map();
+        rules.set("open_file", { pre_states: [], post_states: ["FILE_OPEN"] });
+        rules.set("write_file", { pre_states: ["FILE_OPEN"], post_states: [] });
+        rules.set("close_file", { pre_states: ["FILE_OPEN"], post_states: [], invalidate: ["FILE_OPEN"] });
+        const telemetry = new planner_telemetry_1.PlannerTelemetry(path.join(AUTO_DIR, ".progmune_corpus", "telemetry", `tmpl-${Date.now()}.jsonl`));
+        const lib = seedLibrary(telemetry, rules);
+        const templates = (0, autonomous_patch_1.generateTemplatesFromSkills)(lib);
+        (0, vitest_1.expect)(templates.length).toBeGreaterThanOrEqual(1);
+        // Template pattern should contain file operation keywords
+        (0, vitest_1.expect)(templates.some(t => t.pattern.includes("open") && t.pattern.includes("write"))).toBe(true);
+    });
+    (0, vitest_1.it)("runs full autonomous pipeline", () => {
+        const rules = new Map();
+        rules.set("open_file", { pre_states: [], post_states: ["FILE_OPEN"] });
+        rules.set("write_file", { pre_states: ["FILE_OPEN"], post_states: [] });
+        rules.set("close_file", { pre_states: ["FILE_OPEN"], post_states: [], invalidate: ["FILE_OPEN"] });
+        rules.set("verify_password", { pre_states: ["UNAUTHENTICATED"], post_states: ["PASSWORD_VERIFIED"] });
+        rules.set("generate_jwt", { pre_states: ["PASSWORD_VERIFIED"], post_states: ["TOKEN_ISSUED"], invalidate: ["PASSWORD_VERIFIED"] });
+        rules.set("create_session", { pre_states: ["TOKEN_ISSUED"], post_states: ["SESSION_ACTIVE"], invalidate: ["TOKEN_ISSUED"] });
+        const telemetry = new planner_telemetry_1.PlannerTelemetry(path.join(AUTO_DIR, ".progmune_corpus", "telemetry", `full-${Date.now()}.jsonl`));
+        const lib = seedLibrary(telemetry, rules);
+        const store = new knowledge_governance_1.KnowledgePatchStore(path.join(AUTO_DIR, ".progmune_corpus", "knowledge", `full-patches-${Date.now()}.json`));
+        const report = (0, autonomous_patch_1.runAutonomousPipeline)(lib, telemetry, store);
+        (0, vitest_1.expect)(report.skills).toBeGreaterThanOrEqual(2);
+        (0, vitest_1.expect)(report.patchesApproved).toBeGreaterThanOrEqual(1);
+        (0, vitest_1.expect)(report.templatesGenerated).toBeGreaterThanOrEqual(2);
+        (0, autonomous_patch_1.printAutonomousReport)(report);
+    });
+});

package/dist/badge/badge-server.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Governance Badge Server — embeddable SVG badges for README
+ *
+ * Usage:
+ *   npx ts-node src/badge/badge-server.ts
+ *   PROGMUNE_BADGE_PORT=3500 npx ts-node src/badge/badge-server.ts
+ *
+ * Badge URLs:
+ *   /badge/knowledge          — Knowledge Base status
+ *   /badge/protocols          — Stable protocol count
+ *   /badge/coverage           — Repository coverage
+ *   /badge/confidence         — Average confidence
+ */
+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 http = __importStar(require("http"));
+const protocol_knowledge_1 = require("../protocol-knowledge");
+const evidence_repository_1 = require("../evidence-repository");
+const PORT = parseInt(process.env.PROGMUNE_BADGE_PORT || "3500", 10);
+function svgBadge(label, value, color) {
+    const lw = label.length * 7 + 12;
+    const vw = value.length * 7 + 12;
+    const tw = lw + vw;
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${tw}" height="20">
+  <linearGradient id="bg" x2="0" y2="100%"><stop offset="0" stop-color="#444"/><stop offset="1" stop-color="#333"/></linearGradient>
+  <rect width="${tw}" height="20" rx="3" fill="url(#bg)"/>
+  <rect width="${lw}" height="20" rx="3" fill="#555"/>
+  <rect x="${lw}" width="${vw}" height="20" rx="3" fill="${color}"/>
+  <rect x="${lw}" width="12" height="20" fill="${color}"/>
+  <text x="${lw / 2}" y="14" fill="#ccc" font-family="sans-serif" font-size="10" text-anchor="middle">${label}</text>
+  <text x="${lw + vw / 2}" y="14" fill="#fff" font-family="sans-serif" font-size="10" text-anchor="middle" font-weight="bold">${value}</text>
+</svg>`;
+}
+const server = http.createServer((req, res) => {
+    const url = req.url || "/";
+    const kb = (0, protocol_knowledge_1.buildKnowledgeBase)();
+    const er = (0, evidence_repository_1.buildEvidenceRepository)();
+    res.writeHead(200, { "Content-Type": "image/svg+xml", "Cache-Control": "max-age=300", "Access-Control-Allow-Origin": "*" });
+    if (url === "/badge/knowledge") {
+        res.end(svgBadge("Knowledge Base", `v${kb.version}`, "#0891b2"));
+    }
+    else if (url === "/badge/protocols") {
+        const n = kb.summary.byMaturity["stable"];
+        res.end(svgBadge("Protocols", `${n} stable`, n >= 3 ? "#22c55e" : "#f59e0b"));
+    }
+    else if (url === "/badge/coverage") {
+        res.end(svgBadge("Repos", `${er.summary.totalRepos} validated`, "#8b5cf6"));
+    }
+    else if (url === "/badge/confidence") {
+        res.end(svgBadge("Confidence", `${kb.summary.averageConfidence}%`, kb.summary.averageConfidence >= 70 ? "#22c55e" : "#f59e0b"));
+    }
+    else if (url === "/" || url === "") {
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(`<!DOCTYPE html><html><head><title>Progmune Badges</title><style>
+body{font-family:sans-serif;max-width:600px;margin:40px auto;padding:20px;background:#0a0a0a;color:#d4d4d4}
+h1{color:#fff}pre{background:#111;padding:16px;border-radius:8px;font-size:12px}</style></head><body>
+<h1>Progmune Governance Badges</h1>
+${["knowledge", "protocols", "coverage", "confidence"].map(b => `<p><img src="/badge/${b}"><br><pre>&lt;img src="http://localhost:${PORT}/badge/${b}"&gt;</pre></p>`).join("")}
+</body></html>`);
+    }
+    else {
+        res.end(svgBadge("Progmune", "Governance", "#0891b2"));
+    }
+});
+server.listen(PORT, () => console.error(`\n  Badge Server: http://localhost:${PORT}\n`));