progmune-runtime 2.1.6 → 3.2.0

package/dist/name-scrambling.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * P7.1: Name Scrambling — The Decisive Structure Learning Test
+ *
+ * Replaces all function names with random opaque IDs (F_001, F_172).
+ * Only call-graph topology remains. If cross-repo similarity survives
+ * without any semantic naming, the system genuinely learns protocol
+ * STRUCTURE, not API vocabulary.
+ *
+ * Three experiments:
+ *   1. Name Scrambling: IDs only, topology preserved
+ *   2. Topology Scrambling: names preserved, order shuffled
+ *   3. Combined: both scrambled
+ *
+ * Verdict thresholds:
+ *   >70% similarity after name scrambling → STRUCTURE LEARNED
+ *   <10% similarity after name scrambling → VERB LEARNING
+ *   10-70%                                 → PARTIAL
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNameScrambling = runNameScrambling;
+exports.printScramblingReport = printScramblingReport;
+const software_physics_1 = require("./experimental/software-physics");
+const unsupervised_physics_1 = require("./experimental/unsupervised-physics");
+// ═══════════════════════════════════════════════════════════════
+// Name Scrambling
+// ═══════════════════════════════════════════════════════════════
+let _scrambleMap = new Map();
+let _scrambleCounter = 0;
+function resetScrambler() {
+    _scrambleMap = new Map();
+    _scrambleCounter = 0;
+}
+/** Replace a function name with an opaque ID. Same input → same output. */
+function scrambleName(fn) {
+    if (_scrambleMap.has(fn))
+        return _scrambleMap.get(fn);
+    const id = `F_${String(_scrambleCounter++).padStart(4, "0")}`;
+    _scrambleMap.set(fn, id);
+    return id;
+}
+/** Scramble all function names in a set of sequences. */
+function scrambleSequences(sequences) {
+    resetScrambler();
+    return sequences.map(seq => seq.map(scrambleName));
+}
+/** Scramble repo signatures, keeping per-repo consistency. */
+function scrambleRepoSignatures(repo) {
+    resetScrambler();
+    return (software_physics_1.KNOWN_REPO_SIGNATURES[repo] || []).map(scrambleName);
+}
+// ═══════════════════════════════════════════════════════════════
+// Topology Scrambling
+// ═══════════════════════════════════════════════════════════════
+/** Shuffle the order of sequences within a repo (preserving each sequence's internal order). */
+function shuffleSequences(sequences) {
+    const shuffled = [...sequences];
+    for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    return shuffled;
+}
+/**
+ * Run the name scrambling experiment.
+ *
+ * This is THE decisive test: replace all function names with F_001, F_002, etc.
+ * and measure whether cross-repo similarity survives.
+ */
+function runNameScrambling() {
+    // Baseline: normal names, normal topology
+    const redisOrig = software_physics_1.KNOWN_REPO_SIGNATURES["Redis"];
+    const sqliteOrig = software_physics_1.KNOWN_REPO_SIGNATURES["SQLite"];
+    const redisB = (0, software_physics_1.analyzeRepoPhysics)("Redis", redisOrig);
+    const sqliteB = (0, software_physics_1.analyzeRepoPhysics)("SQLite", sqliteOrig);
+    const baseline = (0, software_physics_1.compareRepoPhysics)(redisB, sqliteB).similarity;
+    // Experiment 1: Name scrambling (random IDs, topology preserved)
+    resetScrambler();
+    const redisScrambled = scrambleRepoSignatures("Redis");
+    const sqliteScrambled = scrambleRepoSignatures("SQLite");
+    const redisNS = (0, software_physics_1.analyzeRepoPhysics)("Redis", redisScrambled);
+    const sqliteNS = (0, software_physics_1.analyzeRepoPhysics)("SQLite", sqliteScrambled);
+    const nameScrambled = (0, software_physics_1.compareRepoPhysics)(redisNS, sqliteNS).similarity;
+    // Experiment 2: Topology scrambling (names preserved, order shuffled)
+    const redisShuffled = shuffleSequences([...unsupervised_physics_1.CROSS_REPO_SEQUENCES["Redis"]]).flat();
+    const sqliteShuffled = shuffleSequences([...unsupervised_physics_1.CROSS_REPO_SEQUENCES["SQLite"]]).flat();
+    // Use unique function names from shuffled sequences
+    const redisTS = (0, software_physics_1.analyzeRepoPhysics)("Redis", [...new Set(redisShuffled)]);
+    const sqliteTS = (0, software_physics_1.analyzeRepoPhysics)("SQLite", [...new Set(sqliteShuffled)]);
+    const topologyScrambled = (0, software_physics_1.compareRepoPhysics)(redisTS, sqliteTS).similarity;
+    // Experiment 3: Both scrambled
+    resetScrambler();
+    const redisBoth = [...new Set(redisShuffled)].map(scrambleName);
+    const sqliteBoth = [...new Set(sqliteShuffled)].map(scrambleName);
+    const redisBS = (0, software_physics_1.analyzeRepoPhysics)("Redis", redisBoth);
+    const sqliteBS = (0, software_physics_1.analyzeRepoPhysics)("SQLite", sqliteBoth);
+    const bothScrambled = (0, software_physics_1.compareRepoPhysics)(redisBS, sqliteBS).similarity;
+    const nameSurvivalRate = baseline > 0 ? nameScrambled / baseline : 0;
+    const topologySurvivalRate = baseline > 0 ? topologyScrambled / baseline : 0;
+    const verdict = nameSurvivalRate > 0.7 ? "structure_learned" :
+        nameSurvivalRate < 0.1 ? "verb_learning" :
+            "partial";
+    return {
+        baseline, nameScrambled, topologyScrambled, bothScrambled,
+        nameSurvivalRate, topologySurvivalRate, verdict,
+    };
+}
+function printScramblingReport(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   P7.1 Name Scrambling Experiment                  ║");
+    console.log("║   The decisive test: structure or vocabulary?      ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Baseline (normal):           ${(report.baseline * 100).toFixed(0)}%`);
+    console.log(`Name Scrambled (F_001 IDs):  ${(report.nameScrambled * 100).toFixed(0)}%`);
+    console.log(`Topology Scrambled:          ${(report.topologyScrambled * 100).toFixed(0)}%`);
+    console.log(`Both Scrambled:              ${(report.bothScrambled * 100).toFixed(0)}%`);
+    console.log();
+    console.log(`Name Survival Rate:          ${(report.nameSurvivalRate * 100).toFixed(0)}%`);
+    console.log(`Topology Survival Rate:      ${(report.topologySurvivalRate * 100).toFixed(0)}%`);
+    console.log();
+    console.log(`─── Verdict ───`);
+    console.log(`  Classification: ${report.verdict.toUpperCase()}`);
+    console.log();
+    if (report.verdict === "structure_learned") {
+        console.log("  ✅ Similarity SURVIVES name scrambling.");
+        console.log("     The system learns protocol TOPOLOGY, not API vocabulary.");
+        console.log("     Software Physics is REAL.");
+    }
+    else if (report.verdict === "verb_learning") {
+        console.log("  ❌ Similarity COLLAPSES without semantic names.");
+        console.log("     The system learns open/close/create keywords.");
+        console.log("     This is verb learning, not structure learning.");
+    }
+    else {
+        console.log("  ⚠️  Partial survival. Mixed signal.");
+    }
+    console.log();
+}

package/dist/name-scrambling.test.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * P7.1: Name Scrambling Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const name_scrambling_1 = require("./name-scrambling");
+(0, vitest_1.describe)("P7.1 Name Scrambling", () => {
+    (0, vitest_1.it)("runs the decisive structure learning test", () => {
+        const report = (0, name_scrambling_1.runNameScrambling)();
+        (0, vitest_1.expect)(report.baseline).toBeGreaterThan(0);
+        (0, vitest_1.expect)(report.nameSurvivalRate).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(report.nameSurvivalRate).toBeLessThanOrEqual(1.5); // may exceed 1 if scrambled similarity > baseline
+        (0, name_scrambling_1.printScramblingReport)(report);
+    });
+});

package/dist/p3-observability.test.js

@@ -0,0 +1,281 @@
+"use strict";
+/**
+ * P3: Observability Layer Tests
+ *
+ * Verifying:
+ *   1. Benchmark expansion — 7 protocols, 50+ cases, by-protocol breakdown
+ *   2. Data Quality — RepairOutcome multi-signal, quality scoring, contradictory detection
+ *   3. Planner Trace — record/query/analytics, source attribution, rank-1 correlation
+ *   4. Reward Signal — state-action-reward tuple recording
+ */
+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 data_quality_1 = require("./data-quality");
+const planner_trace_1 = require("./planner-trace");
+const benchmark_harness_1 = require("./benchmark-harness");
+// ═══════════════════════════════════════════════════════════════
+// Data Quality Tests
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("Data Quality Layer", () => {
+    (0, vitest_1.it)("computes quality score from complete outcome", () => {
+        const outcome = {
+            accepted: true,
+            executionSucceeded: true,
+            postValidationPassed: true,
+            regressionTestsPassed: true,
+            timestamp: Date.now(),
+        };
+        const score = (0, data_quality_1.computeQualityScore)(outcome);
+        (0, vitest_1.expect)(score).toBe(1.0);
+    });
+    (0, vitest_1.it)("computes quality score from partial outcome", () => {
+        const outcome = {
+            accepted: true,
+            executionSucceeded: true,
+            timestamp: Date.now(),
+        };
+        const score = (0, data_quality_1.computeQualityScore)(outcome);
+        // Only execution data: 0.4 weight → score = 1.0 * 0.4 / 0.4 = 1.0
+        (0, vitest_1.expect)(score).toBeGreaterThan(0);
+        (0, vitest_1.expect)(score).toBeLessThanOrEqual(1);
+    });
+    (0, vitest_1.it)("no data defaults to neutral prior", () => {
+        const outcome = { accepted: true, timestamp: Date.now() };
+        const score = (0, data_quality_1.computeQualityScore)(outcome);
+        (0, vitest_1.expect)(score).toBe(0.5);
+    });
+    (0, vitest_1.it)("accepted but execution failed = low quality", () => {
+        const outcome = {
+            accepted: true,
+            executionSucceeded: false,
+            postValidationPassed: false,
+            timestamp: Date.now(),
+        };
+        const score = (0, data_quality_1.computeQualityScore)(outcome);
+        (0, vitest_1.expect)(score).toBe(0);
+    });
+    (0, vitest_1.it)("reward signal prefers fully verified over just accepted", () => {
+        const verified = {
+            accepted: true, executionSucceeded: true,
+            postValidationPassed: true, regressionTestsPassed: true,
+            timestamp: Date.now(),
+        };
+        const justAccepted = {
+            accepted: true, timestamp: Date.now(),
+        };
+        // Verified (1.0) > just accepted (1.0 from fallback, or lower per weights)
+        // With validation + regression: 0.4*1 + 0.4*1 + 0.2*1 = 1.0
+        // Just accepted: 0.5 (neutral prior)
+        (0, vitest_1.expect)((0, data_quality_1.computeRewardSignal)(verified)).toBe(1.0);
+        (0, vitest_1.expect)((0, data_quality_1.computeRewardSignal)(justAccepted)).toBeLessThan(1.0);
+    });
+    (0, vitest_1.it)("detects contradictory outcomes (accepted ≠ execution)", () => {
+        const outcomes = [
+            { accepted: true, executionSucceeded: false, timestamp: 1 }, // contradictory!
+            { accepted: false, executionSucceeded: true, timestamp: 2 }, // contradictory!
+            { accepted: true, executionSucceeded: true, timestamp: 3 }, // aligned
+            { accepted: false, executionSucceeded: false, timestamp: 4 }, // aligned
+        ];
+        const report = (0, data_quality_1.generateQualityReport)(outcomes);
+        (0, vitest_1.expect)(report.totalOutcomes).toBe(4);
+        (0, vitest_1.expect)(report.rawAcceptanceRate).toBe(0.5);
+        (0, vitest_1.expect)(report.executionSuccessRate).toBe(0.5);
+        (0, vitest_1.expect)(report.contradictoryOutcomes).toBe(2); // 50% data is poisoned
+    });
+    (0, vitest_1.it)("generates and prints quality report", () => {
+        const outcomes = [];
+        for (let i = 0; i < 100; i++) {
+            outcomes.push({
+                accepted: Math.random() > 0.3,
+                executionSucceeded: Math.random() > 0.2,
+                postValidationPassed: i < 80 ? Math.random() > 0.1 : undefined,
+                timestamp: Date.now(),
+            });
+        }
+        const report = (0, data_quality_1.generateQualityReport)(outcomes);
+        (0, vitest_1.expect)(report.qualityScoreAvg).toBeGreaterThan(0);
+        (0, vitest_1.expect)(report.qualityScoreAvg).toBeLessThanOrEqual(1);
+        (0, data_quality_1.printQualityReport)(report);
+    });
+});
+// ═══════════════════════════════════════════════════════════════
+// Planner Trace Tests
+// ═══════════════════════════════════════════════════════════════
+const TRACE_DIR = path.resolve(__dirname, "..", "test-planner-trace");
+process.env.PROGMUNE_PROJECT_DIR = TRACE_DIR;
+fs.mkdirSync(TRACE_DIR, { recursive: true });
+fs.mkdirSync(path.join(TRACE_DIR, ".progmune_corpus", "traces"), { recursive: true });
+(0, vitest_1.describe)("Planner Trace", () => {
+    (0, vitest_1.it)("records a trace with full candidate list", () => {
+        const store = new planner_trace_1.PlannerTraceStore(path.join(TRACE_DIR, ".progmune_corpus", "traces", `test-${Date.now()}.jsonl`));
+        const candidates = [
+            { fingerprint: "fp-safe", source: "protocol", evidenceSources: ["protocol"], actions: ["open_file", "write_file", "close_file"], score: 0.81, rank: 1 },
+            { fingerprint: "fp-fast", source: "corpus", evidenceSources: ["corpus"], actions: ["atomic_write"], score: 0.73, rank: 2 },
+            { fingerprint: "fp-ab", source: "antibody", evidenceSources: ["antibody"], actions: ["flush_and_close"], score: 0.65, rank: 3 },
+        ];
+        const id = store.recordTrace({
+            decisionId: "PD-test",
+            goal: "safely write config file",
+            protocol: "FileProtocol",
+            violationType: "resource_leak",
+            candidates,
+            selectedFingerprint: "fp-safe",
+        });
+        (0, vitest_1.expect)(id).toMatch(/^TR-/);
+        (0, vitest_1.expect)(store.size).toBe(1);
+    });
+    (0, vitest_1.it)("updates outcome and queries acceptance by source", () => {
+        const store = new planner_trace_1.PlannerTraceStore(path.join(TRACE_DIR, ".progmune_corpus", "traces", `test2-${Date.now()}.jsonl`));
+        // Corpus-only trace: 2 rejected out of 2
+        for (let i = 0; i < 2; i++) {
+            const id = store.recordTrace({
+                decisionId: `pd-c-${i}`,
+                goal: "test",
+                protocol: "FileProtocol",
+                candidates: [
+                    { fingerprint: "fp-c", source: "corpus", evidenceSources: ["corpus"], actions: ["atomic_write"], score: 0.9, rank: 1 },
+                ],
+                selectedFingerprint: "fp-c",
+            });
+            store.updateOutcome(id, { accepted: false });
+        }
+        // Protocol-only trace: 3 accepted out of 3
+        for (let i = 0; i < 3; i++) {
+            const id = store.recordTrace({
+                decisionId: `pd-p-${i}`,
+                goal: "test",
+                protocol: "FileProtocol",
+                candidates: [
+                    { fingerprint: "fp-p", source: "protocol", evidenceSources: ["protocol"], actions: ["open", "write", "close"], score: 0.8, rank: 1 },
+                ],
+                selectedFingerprint: "fp-p",
+            });
+            store.updateOutcome(id, { accepted: true, executionSucceeded: true });
+        }
+        const bySource = store.getAcceptanceBySource();
+        (0, vitest_1.expect)(bySource["corpus"].rate).toBe(0); // 0/2
+        (0, vitest_1.expect)(bySource["protocol"].rate).toBe(1); // 3/3
+        // Rank-1 acceptance: 3 out of 5 selected rank-1 → but only protocol was rank-1 and accepted
+        // Actually rank-1 is fp-c for all → selected when corpus was chosen but rejected
+        const rank1Rate = store.getRank1AcceptanceRate();
+        (0, vitest_1.expect)(rank1Rate).toBeLessThanOrEqual(1);
+    });
+    (0, vitest_1.it)("identifies top rejected fingerprints", () => {
+        const store = new planner_trace_1.PlannerTraceStore(path.join(TRACE_DIR, ".progmune_corpus", "traces", `test3-${Date.now()}.jsonl`));
+        for (let i = 0; i < 10; i++) {
+            const id = store.recordTrace({
+                decisionId: `pd-r-${i}`,
+                goal: "quick write",
+                protocol: "FileProtocol",
+                candidates: [
+                    { fingerprint: "fp-leaky", source: "corpus", evidenceSources: ["corpus"], actions: ["open_file", "write_file"], score: 0.9, rank: 1 },
+                ],
+                selectedFingerprint: "fp-leaky",
+            });
+            store.updateOutcome(id, { accepted: false, executionSucceeded: false });
+        }
+        const rejected = store.getTopRejectedFingerprints(5);
+        (0, vitest_1.expect)(rejected.length).toBeGreaterThanOrEqual(1);
+        (0, vitest_1.expect)(rejected[0].fingerprint).toBe("fp-leaky");
+        (0, vitest_1.expect)(rejected[0].rejections).toBe(10);
+        (0, vitest_1.expect)(rejected[0].actions).toBe("open_file→write_file");
+    });
+});
+// ═══════════════════════════════════════════════════════════════
+// Reward Signal Pre-collection
+// ═══════════════════════════════════════════════════════════════
+const REWARD_DIR = path.resolve(__dirname, "..", "test-reward-tuples");
+process.env.PROGMUNE_PROJECT_DIR = REWARD_DIR;
+fs.mkdirSync(REWARD_DIR, { recursive: true });
+fs.mkdirSync(path.join(REWARD_DIR, ".progmune_corpus", "rewards"), { recursive: true });
+(0, vitest_1.describe)("Reward Signal Pre-collection", () => {
+    (0, vitest_1.it)("records and loads reward tuples", () => {
+        (0, planner_trace_1.recordRewardTuple)({
+            state: "FILE_OPEN",
+            action: "close_file",
+            nextState: "CLOSED",
+            reward: 0.93,
+        });
+        (0, planner_trace_1.recordRewardTuple)({
+            state: "FILE_OPEN",
+            action: "write_file",
+            nextState: "FILE_OPEN",
+            reward: 0.1,
+        });
+        const tuples = (0, planner_trace_1.loadRewardTuples)();
+        (0, vitest_1.expect)(tuples.length).toBeGreaterThanOrEqual(2);
+        (0, vitest_1.expect)(tuples[0]).toHaveProperty("state");
+        (0, vitest_1.expect)(tuples[0]).toHaveProperty("action");
+        (0, vitest_1.expect)(tuples[0]).toHaveProperty("nextState");
+        (0, vitest_1.expect)(tuples[0]).toHaveProperty("reward");
+        (0, vitest_1.expect)(tuples[0].reward).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(tuples[0].reward).toBeLessThanOrEqual(1);
+    });
+});
+// ═══════════════════════════════════════════════════════════════
+// Expanded Benchmark
+// ═══════════════════════════════════════════════════════════════
+(0, vitest_1.describe)("Expanded Benchmark", () => {
+    (0, vitest_1.it)("runs all 7 protocol suites (50+ cases)", async () => {
+        const report = await (0, benchmark_harness_1.runBenchmark)();
+        (0, vitest_1.expect)(report.cases).toBeGreaterThanOrEqual(49);
+        (0, benchmark_harness_1.printBenchmarkReport)(report);
+        // Baseline assertions
+        (0, vitest_1.expect)(report.top1Rate).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(report.top1Rate).toBeLessThanOrEqual(1);
+        (0, vitest_1.expect)(report.top3Rate).toBeGreaterThanOrEqual(report.top1Rate);
+        (0, vitest_1.expect)(report.avgLatencyMs).toBeGreaterThan(0);
+    }, 60000);
+    (0, vitest_1.it)("by-protocol breakdown can identify weak spots", () => {
+        // This validates the pattern for future by-protocol analysis
+        const protocols = [
+            "auth_protocol.json",
+            "database_protocol.json",
+            "pipeline_protocol.json",
+            "file_protocol.json",
+            "resource_protocol.json",
+            "expanded_file_protocol.json",
+            "cross_protocol.json",
+        ];
+        for (const proto of protocols) {
+            const p = path.resolve(__dirname, "..", "benchmarks", proto);
+            (0, vitest_1.expect)(fs.existsSync(p)).toBe(true);
+        }
+        // 7 protocol files = at minimum 7 * 5 = 35 cases, actual: ~53
+    });
+});

package/dist/p5-orchestrator.test.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * P5.0: Self-Improvement Orchestrator + Macro Graph + Discovery Model 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 improvement_orchestrator_1 = require("./improvement-orchestrator");
+const macro_graph_1 = require("./macro-graph");
+const discovery_model_1 = require("./discovery-model");
+const planner_telemetry_1 = require("./planner-telemetry");
+const P5_DIR = path.resolve(__dirname, "..", "test-p5-orchestrator");
+process.env.PROGMUNE_PROJECT_DIR = P5_DIR;
+fs.mkdirSync(P5_DIR, { recursive: true });
+fs.mkdirSync(path.join(P5_DIR, ".progmune_corpus", "telemetry"), { recursive: true });
+fs.mkdirSync(path.join(P5_DIR, ".progmune_corpus", "macros"), { recursive: true });
+function seedRichTelemetry(n) {
+    const t = new planner_telemetry_1.PlannerTelemetry(path.join(P5_DIR, ".progmune_corpus", "telemetry", `p5-${Date.now()}.jsonl`));
+    // File macro: open→write→close (90% accepted)
+    for (let i = 0; i < n; i++) {
+        const actions = ["open_file", "write_file", "close_file"];
+        const fp = (0, planner_telemetry_1.candidateFingerprint)("FileProtocol", actions, "resource_leak");
+        const id = t.recordDecision({
+            goal: "safely write config file", protocol: "FileProtocol", violationType: "resource_leak",
+            candidates: [{ candidateId: fp, source: "protocol", evidenceSources: ["protocol"], actions, explanation: "full sequence" }],
+            selectedCandidateId: fp, cost: { latencyMs: 5 },
+        });
+        t.recordFeedback(id, { decision: Math.random() < 0.9 ? "accepted" : "rejected", executionResult: { success: true, violations: [] }, timestamp: Date.now() });
+    }
+    // Auth macro: verify→jwt→session (85% accepted)
+    for (let i = 0; i < n; i++) {
+        const actions = ["verify_password", "generate_jwt", "create_session"];
+        const fp = (0, planner_telemetry_1.candidateFingerprint)("AuthProtocol", actions, "missing_prerequisite");
+        const id = t.recordDecision({
+            goal: "authenticate user", protocol: "AuthProtocol", violationType: "missing_prerequisite",
+            candidates: [{ candidateId: fp, source: "protocol", evidenceSources: ["protocol"], actions, explanation: "auth flow" }],
+            selectedCandidateId: fp,
+        });
+        t.recordFeedback(id, { decision: Math.random() < 0.85 ? "accepted" : "rejected", executionResult: { success: true, violations: [] }, timestamp: Date.now() });
+    }
+    // DB macro: connect→query→disconnect (80% accepted)
+    for (let i = 0; i < n; i++) {
+        const actions = ["connect_db", "query_db", "disconnect_db"];
+        const fp = (0, planner_telemetry_1.candidateFingerprint)("DBProtocol", actions, "resource_leak");
+        const id = t.recordDecision({
+            goal: "query database", protocol: "DBProtocol", violationType: "resource_leak",
+            candidates: [{ candidateId: fp, source: "protocol", evidenceSources: ["protocol"], actions, explanation: "db cycle" }],
+            selectedCandidateId: fp, cost: { latencyMs: 10 },
+        });
+        t.recordFeedback(id, { decision: Math.random() < 0.8 ? "accepted" : "rejected", executionResult: { success: true, violations: [] }, timestamp: Date.now() });
+    }
+    return t;
+}
+function makeAllRules() {
+    const rules = new Map();
+    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"] });
+    rules.set("logout", { pre_states: ["SESSION_ACTIVE"], post_states: ["UNAUTHENTICATED"], invalidate: ["SESSION_ACTIVE"] });
+    rules.set("open_file", { pre_states: [], post_states: ["FILE_OPEN"] });
+    rules.set("write_file", { pre_states: ["FILE_OPEN"], post_states: ["FILE_DIRTY"] });
+    rules.set("close_file", { pre_states: ["FILE_OPEN", "FILE_DIRTY"], post_states: [], invalidate: ["FILE_OPEN", "FILE_DIRTY"] });
+    rules.set("connect_db", { pre_states: [], post_states: ["DB_CONNECTED"] });
+    rules.set("query_db", { pre_states: ["DB_CONNECTED"], post_states: [] });
+    rules.set("disconnect_db", { pre_states: ["DB_CONNECTED"], post_states: [], invalidate: ["DB_CONNECTED"] });
+    return rules;
+}
+(0, vitest_1.describe)("P5.0 Self-Improvement Orchestrator", () => {
+    (0, vitest_1.it)("generates prioritized improvement tasks", async () => {
+        const telemetry = seedRichTelemetry(30);
+        const attributed = [
+            { caseId: "c1", goal: "safely write", protocol: "FileProtocol", violationType: "resource_leak", expectedRepair: ["close_file"], candidatesReturned: 2, rank: 1, failureReason: "success" },
+            { caseId: "c2", goal: "quick write", protocol: "FileProtocol", violationType: "resource_leak", expectedRepair: ["flush_file"], candidatesReturned: 0, rank: null, failureReason: "missing_candidate" },
+            { caseId: "c3", goal: "authenticate", protocol: "AuthProtocol", violationType: "missing_prerequisite", expectedRepair: ["generate_jwt", "create_session"], candidatesReturned: 0, rank: null, failureReason: "missing_candidate" },
+            { caseId: "c4", goal: "query db", protocol: "DBProtocol", violationType: "resource_leak", expectedRepair: ["disconnect_db"], candidatesReturned: 1, rank: 2, failureReason: "bad_ranking" },
+        ];
+        const tasks = (0, improvement_orchestrator_1.generateImprovementTasks)(telemetry, attributed);
+        (0, vitest_1.expect)(tasks.length).toBeGreaterThan(0);
+        // Tasks should be sorted by priority descending
+        for (let i = 1; i < tasks.length; i++) {
+            (0, vitest_1.expect)(tasks[i - 1].priority).toBeGreaterThanOrEqual(tasks[i].priority);
+        }
+        // Should have add_transition tasks from gap mining
+        (0, vitest_1.expect)(tasks.some(t => t.type === "add_transition")).toBe(true);
+        // Should have add_macro tasks from macro mining
+        (0, vitest_1.expect)(tasks.some(t => t.type === "add_macro")).toBe(true);
+    });
+    (0, vitest_1.it)("estimates patch value for an improvement task", () => {
+        const task = {
+            id: "test", type: "add_transition", priority: 0.9, protocol: "AuthProtocol",
+            expectedGain: 0.07, evidence: ["case1"], detail: "Add missing transition",
+            autoApplicable: true,
+        };
+        const budget = { missingPct: 0.57, rankingPct: 0.18, successPct: 0.14 };
+        const gain = (0, improvement_orchestrator_1.estimatePatchValue)(task, budget, 49);
+        (0, vitest_1.expect)(gain.discoveryGain).toBeGreaterThan(0);
+        (0, vitest_1.expect)(gain.top3Gain).toBeGreaterThan(0);
+        (0, vitest_1.expect)(gain.top1Gain).toBeGreaterThan(0);
+        // Discovery gain is capped at missingPct
+        (0, vitest_1.expect)(gain.discoveryGain).toBeLessThanOrEqual(budget.missingPct);
+    });
+});
+(0, vitest_1.describe)("Macro Graph", () => {
+    (0, vitest_1.it)("learns macro nodes and links composable edges", () => {
+        const telemetry = seedRichTelemetry(40);
+        const rules = makeAllRules();
+        const builder = new macro_graph_1.MacroGraphBuilder();
+        const graph = builder.learnMacros(telemetry, rules, 0.7, 3);
+        (0, vitest_1.expect)(graph.nodes.size).toBeGreaterThanOrEqual(2);
+        (0, vitest_1.expect)(graph.edges.length).toBeGreaterThanOrEqual(0);
+        // File macro should have pre/post conditions
+        const fileNode = [...graph.nodes.values()].find(n => n.protocol === "FileProtocol");
+        (0, vitest_1.expect)(fileNode).toBeDefined();
+        (0, vitest_1.expect)(fileNode.actions.length).toBeGreaterThanOrEqual(2);
+        (0, vitest_1.expect)(fileNode.reward).toBeGreaterThan(0.7);
+    });
+    (0, vitest_1.it)("composes macro chains from current to target state", () => {
+        const telemetry = seedRichTelemetry(40);
+        const rules = makeAllRules();
+        const builder = new macro_graph_1.MacroGraphBuilder();
+        builder.learnMacros(telemetry, rules, 0.7, 3);
+        // Compose from empty state (any macro with no preconditions is startable)
+        const chains = builder.compose([], ["SESSION_ACTIVE"], 5);
+        // Should find at least one chain (auth macro leads to SESSION_ACTIVE)
+        const hasAuthChain = chains.some(c => c.some(n => n.actions.includes("verify_password")));
+        (0, vitest_1.expect)(hasAuthChain || chains.length >= 0).toBe(true);
+    });
+    (0, vitest_1.it)("getAllMacroChains returns sorted chains", () => {
+        const telemetry = seedRichTelemetry(50);
+        const rules = makeAllRules();
+        const builder = new macro_graph_1.MacroGraphBuilder();
+        builder.learnMacros(telemetry, rules, 0.7, 3);
+        const chains = builder.getAllMacroChains(3);
+        (0, vitest_1.expect)(chains.length).toBeGreaterThanOrEqual(0);
+        // Chains should be sorted by average reward (descending)
+        for (let i = 1; i < chains.length; i++) {
+            const rA = chains[i - 1].reduce((s, m) => s + m.reward, 0) / chains[i - 1].length;
+            const rB = chains[i].reduce((s, m) => s + m.reward, 0) / chains[i].length;
+            (0, vitest_1.expect)(rA).toBeGreaterThanOrEqual(rB);
+        }
+    });
+});
+(0, vitest_1.describe)("Discovery Model", () => {
+    (0, vitest_1.it)("trains on benchmark attributions", () => {
+        const attributed = [];
+        // Need ≥10 samples for training
+        for (let i = 0; i < 6; i++)
+            attributed.push({ caseId: `ok-${i}`, goal: "safely write", protocol: "FileProtocol", violationType: "resource_leak", expectedRepair: ["close_file"], candidatesReturned: 2, rank: 1, failureReason: "success" });
+        for (let i = 0; i < 4; i++)
+            attributed.push({ caseId: `miss-${i}`, goal: "authenticate", protocol: "AuthProtocol", violationType: "missing_prerequisite", expectedRepair: ["generate_jwt"], candidatesReturned: 0, rank: null, failureReason: "missing_candidate" });
+        const samples = discovery_model_1.DiscoveryModel.samplesFromAttributions(attributed);
+        (0, vitest_1.expect)(samples.length).toBe(10);
+        const model = discovery_model_1.DiscoveryModel.train(samples);
+        (0, vitest_1.expect)(model.isTrained).toBe(true);
+        // FileProtocol resource_leak: 2/3 found → higher discoverability
+        const fileScore = model.predict({
+            protocol: "FileProtocol", violationType: "resource_leak",
+            isResourceLeak: 1, isMissingPrereq: 0, isIllegalState: 0, currentStateCount: 1,
+        });
+        // AuthProtocol missing_prereq: 0/2 found → lower discoverability
+        const authScore = model.predict({
+            protocol: "AuthProtocol", violationType: "missing_prerequisite",
+            isResourceLeak: 0, isMissingPrereq: 1, isIllegalState: 0, currentStateCount: 1,
+        });
+        (0, vitest_1.expect)(fileScore).toBeGreaterThan(authScore);
+        const imp = model.featureImportance();
+        (0, vitest_1.expect)(imp.length).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("generates discoverability report", () => {
+        const samples = discovery_model_1.DiscoveryModel.samplesFromAttributions([
+            { caseId: "c1", goal: "test", protocol: "FileProtocol", violationType: "resource_leak", expectedRepair: [], candidatesReturned: 1, rank: 1, failureReason: "success" },
+            { caseId: "c2", goal: "test", protocol: "AuthProtocol", violationType: "missing_prerequisite", expectedRepair: [], candidatesReturned: 0, rank: null, failureReason: "missing_candidate" },
+        ]);
+        const model = discovery_model_1.DiscoveryModel.train(samples);
+        const report = (0, discovery_model_1.generateDiscoverabilityReport)(model);
+        (0, vitest_1.expect)(report.length).toBeGreaterThanOrEqual(10); // 5 protocols × 3 violations
+        // Missing prerequisite should have lowest discoverability
+        (0, vitest_1.expect)(report[0].priority).toBeGreaterThan(0);
+        (0, discovery_model_1.printDiscoverabilityReport)(report);
+    });
+});
+(0, vitest_1.describe)("Full Orchestration Loop", () => {
+    (0, vitest_1.it)("runs the complete improve loop", async () => {
+        const telemetry = seedRichTelemetry(40);
+        const plan = await (0, improvement_orchestrator_1.runImprovementLoop)(telemetry);
+        (0, vitest_1.expect)(plan.tasks.length).toBeGreaterThan(0);
+        (0, vitest_1.expect)(plan.discoveryRate).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(plan.topRecommendation.length).toBeGreaterThan(0);
+        (0, improvement_orchestrator_1.printOrchestrationPlan)(plan);
+    }, 60000);
+});