progmune-runtime 2.1.6 → 3.2.0

package/dist/rule-specificity.js

@@ -0,0 +1,254 @@
+"use strict";
+/**
+ * Sprint 13: Rule Specificity Analyzer — attack RULE_TOO_BROAD.
+ *
+ * Not "optimize VI." Not "add features."
+ * Identify the weakest rules and fix them. One sprint, one root cause.
+ *
+ * Target: RULE_TOO_BROAD 61% → 45%
+ *
+ * How it works:
+ *   1. Load SSG rules from benchmark data
+ *   2. Score each rule by discriminative power (specificity, cross-repo, FP rate)
+ *   3. Rank weakest rules → these are the FP factories
+ *   4. Suggest concrete fixes (add pre_states, add post_states, add invalidate)
+ *   5. Output Sprint 13 backlog
+ *
+ * Usage:
+ *   npx ts-node --transpile-only src/rule-specificity.ts
+ *   npx ts-node --transpile-only src/rule-specificity.ts --repo curl
+ */
+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.generateSprint13Backlog = generateSprint13Backlog;
+exports.formatSprint13Backlog = formatSprint13Backlog;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const auto_protocol_synthesizer_1 = require("./auto-protocol-synthesizer");
+/**
+ * Score a single rule's discriminative power.
+ *
+ * Weak rules have:
+ *   - Empty pre_states (matches ANY state)
+ *   - Single or no post_states (no meaningful state transition)
+ *   - No invalidate (no resource management)
+ */
+function scoreRule(fn, rule, fnFrequency) {
+    const preCount = rule.pre_states.length;
+    const postCount = rule.post_states.length;
+    const hasInvalidate = (rule.invalidate || []).length > 0;
+    // Specificity: more pre/post states = more specific = fewer FPs
+    // 0 states = 0 points, 1-2 = 30, 3-4 = 60, 5+ = 100
+    const totalStates = preCount + postCount + (hasInvalidate ? 1 : 0);
+    const specificityScore = Math.min(100, totalStates * 20);
+    // Cross-repo: not applicable at rule level — use frequency as proxy
+    const freq = fnFrequency.get(fn) || 1;
+    const crossRepoScore = Math.min(100, freq * 5); // 20+ occurrences = full score
+    // FP contribution estimate: lower specificity → more FPs
+    const fpContribution = Math.max(1, Math.round((100 - specificityScore) / 10));
+    // Diagnose weakness
+    let weakness = "";
+    let suggestedFix = "";
+    if (preCount === 0 && postCount === 0) {
+        weakness = "No states — matches everything";
+        suggestedFix = "Add at least 1 pre_state and 1 post_state";
+    }
+    else if (preCount === 0) {
+        weakness = "Empty pre_states — matches any initial state";
+        suggestedFix = "Add pre_state from call context (what must be true before this call?)";
+    }
+    else if (postCount === 0 && !hasInvalidate) {
+        weakness = "No post_states or invalidate — no state transition";
+        suggestedFix = "Add post_state (what changes after this call?) or invalidate (what does it release?)";
+    }
+    else if (totalStates <= 2) {
+        weakness = `Only ${totalStates} state${totalStates > 1 ? 's' : ''} — too broad`;
+        suggestedFix = `Add ${3 - totalStates} more pre/post/invalidate states`;
+    }
+    else {
+        weakness = "Adequate specificity but still producing FPs";
+        suggestedFix = "Add negative evidence (forbidden transitions) or context filter";
+    }
+    // Priority
+    let priority = "P2";
+    if (specificityScore <= 20)
+        priority = "P0";
+    else if (specificityScore <= 40)
+        priority = "P1";
+    return {
+        function: fn,
+        specificityScore,
+        crossRepoScore,
+        fpContribution,
+        weakness,
+        suggestedFix,
+        priority,
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// Sprint 13 Backlog Generator
+// ═══════════════════════════════════════════════════════════════
+function generateSprint13Backlog(repoName = "curl") {
+    const labelFile = path.join(process.cwd(), "benchmarks", `${repoName}-labels.json`);
+    if (!fs.existsSync(labelFile)) {
+        throw new Error(`Labels not found: ${labelFile}`);
+    }
+    const data = JSON.parse(fs.readFileSync(labelFile, "utf-8"));
+    const labels = data.labels || {};
+    const sequences = data.sequences || {};
+    const labeledIndices = Object.keys(labels).map(Number);
+    // Get clean sequences
+    const cleanSeqs = [];
+    for (const idx of labeledIndices) {
+        if (labels[idx] === "clean" && sequences[idx]) {
+            cleanSeqs.push(sequences[idx]);
+        }
+    }
+    // Generate rules
+    const protocols = (0, auto_protocol_synthesizer_1.synthesizeProtocols)(cleanSeqs);
+    // Build rules map
+    const rules = new Map();
+    for (const proto of protocols) {
+        for (const r of proto.rules) {
+            rules.set(r.function, {
+                pre_states: r.pre_states,
+                post_states: r.post_states,
+                invalidate: r.invalidate,
+                namespace: proto.inferredPattern || "discovered",
+            });
+        }
+    }
+    // Count function frequency across sequences
+    const fnFrequency = new Map();
+    for (const seq of cleanSeqs) {
+        const seen = new Set();
+        for (const fn of seq) {
+            if (!seen.has(fn)) {
+                fnFrequency.set(fn, (fnFrequency.get(fn) || 0) + 1);
+                seen.add(fn);
+            }
+        }
+    }
+    // Score all rules
+    const scored = [];
+    for (const [fn, rule] of rules) {
+        scored.push(scoreRule(fn, rule, fnFrequency));
+    }
+    // Sort: weakest (lowest specificity) first
+    scored.sort((a, b) => a.specificityScore - b.specificityScore);
+    // Count weak rules (specificity < 40)
+    const weakRules = scored.filter(r => r.specificityScore < 40).length;
+    const estimatedFPImpact = scored
+        .filter(r => r.specificityScore < 40)
+        .reduce((s, r) => s + r.fpContribution, 0);
+    return {
+        repo: repoName,
+        totalRules: rules.size,
+        weakRules,
+        estimatedFPImpact,
+        backlog: scored,
+        sprintGoal: `Reduce RULE_TOO_BROAD FPs from 61% to 45% by fixing the ${weakRules} weakest rules (est. ${estimatedFPImpact} FP impact)`,
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// Formatter
+// ═══════════════════════════════════════════════════════════════
+function bar(value, max, width = 15) {
+    const filled = Math.round((value / max) * width);
+    return "█".repeat(filled) + "░".repeat(width - filled);
+}
+function formatSprint13Backlog(b) {
+    const lines = [];
+    lines.push("");
+    lines.push("╔══════════════════════════════════════════════════════════════╗");
+    lines.push("║     Sprint 13: Attack RULE_TOO_BROAD                         ║");
+    lines.push("╠══════════════════════════════════════════════════════════════╣");
+    lines.push(`║  Repo: ${b.repo}`.padEnd(63) + "║");
+    lines.push(`║  Total rules: ${b.totalRules}  |  Weak rules: ${b.weakRules}  |  Est. FP impact: ${b.estimatedFPImpact}`.padEnd(63) + "║");
+    lines.push("╠══════════════════════════════════════════════════════════════╣");
+    lines.push(`║  Goal: ${b.sprintGoal.slice(0, 55)}`.padEnd(63) + "║");
+    lines.push("╚══════════════════════════════════════════════════════════════╝");
+    lines.push("");
+    // P0 — Critical (specificity ≤ 20)
+    const p0 = b.backlog.filter(r => r.priority === "P0");
+    if (p0.length > 0) {
+        lines.push("── P0: Critical (specificity ≤ 20) — Fix these first ──");
+        lines.push("");
+        for (const r of p0.slice(0, 15)) {
+            const specBar = bar(r.specificityScore, 100);
+            lines.push(`  ${r.function.padEnd(35)} spec:${String(r.specificityScore).padStart(3)} ${specBar}  est.${r.fpContribution} FP`);
+            lines.push(`    Weakness: ${r.weakness}`);
+            lines.push(`    Fix:      ${r.suggestedFix}`);
+            lines.push("");
+        }
+        if (p0.length > 15) {
+            lines.push(`  ... and ${p0.length - 15} more P0 rules`);
+            lines.push("");
+        }
+    }
+    // P1 — High (specificity 21-40)
+    const p1 = b.backlog.filter(r => r.priority === "P1");
+    if (p1.length > 0) {
+        lines.push("── P1: High (specificity 21-40) — Fix in Sprint 13-14 ──");
+        lines.push("");
+        for (const r of p1.slice(0, 10)) {
+            lines.push(`  ${r.function.padEnd(35)} spec:${String(r.specificityScore).padStart(3)}  ${bar(r.specificityScore, 100)}  est.${r.fpContribution} FP`);
+            lines.push(`    → ${r.suggestedFix}`);
+        }
+        if (p1.length > 10) {
+            lines.push(`  ... and ${p1.length - 10} more P1 rules`);
+        }
+        lines.push("");
+    }
+    // Summary
+    const totalFPImpact = b.backlog.reduce((s, r) => s + r.fpContribution, 0);
+    lines.push("── Sprint 13 Completion Criteria ──");
+    lines.push(`  Fix P0 rules (${p0.length} rules, est. ${p0.reduce((s, r) => s + r.fpContribution, 0)} FP impact)`);
+    lines.push(`  Fix P1 rules (${p1.length} rules, est. ${p1.reduce((s, r) => s + r.fpContribution, 0)} FP impact)`);
+    lines.push(`  Total estimated FP reduction: ${p0.reduce((s, r) => s + r.fpContribution, 0) + p1.reduce((s, r) => s + r.fpContribution, 0)}/${b.totalRules} rules`);
+    lines.push(`  Dashboard K5: RULE_TOO_BROAD 61% → target 45%`);
+    lines.push("");
+    return lines.join("\n");
+}
+// ═══════════════════════════════════════════════════════════════
+// CLI
+// ═══════════════════════════════════════════════════════════════
+if (require.main === module) {
+    const args = process.argv.slice(2);
+    const repoIdx = args.findIndex(a => a === "--repo");
+    const repo = repoIdx >= 0 ? args[repoIdx + 1] : "curl";
+    const backlog = generateSprint13Backlog(repo);
+    console.log(formatSprint13Backlog(backlog));
+}

package/dist/runtime-types.js

@@ -37,6 +37,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.replayLedger = exports.replaySession = exports.getMinimalFixSet = exports.generateRepairSummary = exports.validateProposal = exports.applyProposalAsBranch = exports.suggestInvariantRepair = exports.suggestProtocolRepair = exports.suggestRepairs = exports.describeBranchTree = exports.unwrapBranchTree = exports.wrapAsBranch = exports.findRootBranch = exports.buildBranchMap = exports.replayBranch = exports.getBranchPath = exports.flattenBranch = exports.mergeBranches = exports.forkBranch = exports.createBranch = exports.createRootBranch = exports.registerAllMissingFingerprints = exports.verifyAllFingerprints = exports.verifyFingerprint = exports.getFingerprintRegistry = exports.getFingerprint = exports.registerFingerprint = exports.assertLedgerInvariants = exports.assertTransitionOrder = exports.assertRuleHashMatch = exports.assertDeltaConsistency = exports.assertLedgerConsistency = exports.InvariantViolationError = exports.listAllStates = exports.findTransition = exports.findViolations = exports.findConsumer = exports.findProducer = exports.rejectionToJSON = exports.explainRejection = exports.diffLedgers = exports.hashLedger = exports.hashRules = exports.findFixPathStatic = exports.checkLedgerConsistency = exports.validateTransition = exports.applyTransitionDelta = exports.rebuildState = exports.parseProtocolsFromJSON = exports.StateMachineValidator = void 0;
 exports.replayWithDetail = void 0;
+exports.mapLegacyFCode = mapLegacyFCode;
+exports.ok = ok;
+exports.err = err;
 exports.generateAttemptId = generateAttemptId;
 exports.generateSessionId = generateSessionId;
 exports.generatePlannerSeed = generatePlannerSeed;
@@ -105,6 +108,30 @@ var deterministic_replay_1 = require("./deterministic-replay");
 Object.defineProperty(exports, "replaySession", { enumerable: true, get: function () { return deterministic_replay_1.replaySession; } });
 Object.defineProperty(exports, "replayLedger", { enumerable: true, get: function () { return deterministic_replay_1.replayLedger; } });
 Object.defineProperty(exports, "replayWithDetail", { enumerable: true, get: function () { return deterministic_replay_1.replayWithDetail; } });
+/** Legacy F-code → ViolationType mapping. */
+function mapLegacyFCode(fCode) {
+    const map = {
+        F01: "unexported_function",
+        F02: "wrong_import_path",
+        F03: "type_name_error",
+        F04: "wrong_arg_count",
+        F05: "wrong_arg_type",
+        F06: "undefined_variable",
+        F07: "planning_failure",
+        F08: "return_type_error",
+        F09: "protocol_violation",
+        F10: "other",
+    };
+    return map[fCode] || "other";
+}
+/** Create an Ok result. */
+function ok(value) {
+    return { ok: true, value };
+}
+/** Create an Err result. */
+function err(error) {
+    return { ok: false, error };
+}
 // ── ID生成工具 ──
 function generateAttemptId() {
     return `att_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;

package/dist/scaffold.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Phase 9: Scaffold Engine
+ *
+ * Template-based code generation for full project files.
+ * Complements the function-call-chain model (planner) for
+ * architecture-level code: Express servers, CLI tools, static sites.
+ *
+ * Registered as `progmune_scaffold` MCP tool.
+ */
+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.SCAFFOLD_TYPES = void 0;
+exports.scaffold = scaffold;
+exports.listScaffolds = listScaffolds;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const llm_1 = require("./llm");
+const extract_ir_1 = require("./extract-ir");
+const feedback_1 = require("./feedback");
+const execute_1 = require("./execute");
+// ── Scaffold types ──
+exports.SCAFFOLD_TYPES = [
+    "express-api", // Express REST API with SQLite
+    "cli-tool", // CLI tool with argument parsing
+    "static-site", // HTML/CSS/JS static site
+];
+const TEMPLATES = {
+    "express-api": {
+        description: "Express REST API server with SQLite database",
+        systemPrompt: `You are a TypeScript Express server generator. Generate complete, production-ready code.
+
+RULES:
+- Use express, better-sqlite3
+- Include input validation, proper HTTP status codes, error handling
+- Use TypeScript types everywhere
+- Generate ONLY the server file content, no explanation
+- The code must be complete and runnable
+- Use async/await where appropriate`,
+        prerequisiteHint: "Project should have database functions (init, CRUD) and validation utilities defined in separate files.",
+    },
+    "cli-tool": {
+        description: "CLI tool with argument parsing",
+        systemPrompt: `You are a TypeScript CLI tool generator. Generate complete, production-ready code.
+
+RULES:
+- Parse command-line arguments (process.argv or a simple arg parser)
+- Support --help, --version flags
+- Clear error messages for invalid input
+- Use TypeScript types everywhere
+- Generate ONLY the CLI file content, no explanation
+- The code must be complete and runnable`,
+        prerequisiteHint: "Project should have utility functions for the CLI's domain logic.",
+    },
+    "static-site": {
+        description: "Static HTML site with CSS and vanilla JavaScript",
+        systemPrompt: `You are a frontend HTML/CSS/JS generator. Generate a complete, self-contained single-file HTML page.
+
+RULES:
+- Inline all CSS in <style> and JS in <script> tags
+- Dark theme by default
+- Mobile-responsive (max-width 640px)
+- No external dependencies (no CDN, no framework)
+- No social features, no images, no audio/video
+- Clean, minimal design
+- Generate ONLY the HTML file content, no explanation`,
+        prerequisiteHint: "Page should interact with a backend API if specified in the intent.",
+    },
+};
+// ── Scaffold engine ──
+async function scaffold(scaffoldType, intent, projectPath, filePath) {
+    const template = TEMPLATES[scaffoldType];
+    if (!template) {
+        return {
+            success: false,
+            code: "",
+            scaffoldType,
+            error: `Unknown scaffold type: ${scaffoldType}. Available: ${exports.SCAFFOLD_TYPES.join(", ")}`,
+        };
+    }
+    // 1. Extract IR to understand project context
+    let irContext = "";
+    try {
+        const ir = (0, extract_ir_1.extractIR)(projectPath);
+        if (ir.length > 0) {
+            const funcList = ir
+                .map((f) => `  - ${f.name}(${(f.params || []).map((p) => `${p.name}: ${p.type || "any"}`).join(", ")}): ${f.returnType || "void"}`)
+                .join("\n");
+            irContext = `\n\nAvailable project functions (from IR):\n${funcList}\n\nYou MUST use these functions where applicable. For imports, use relative paths appropriate for the project structure.`;
+        }
+    }
+    catch { /* IR extraction is best-effort */ }
+    // 2. Build prompt
+    const fileHint = filePath
+        ? `Write the generated code to: ${filePath}`
+        : "Return the generated code as the response.";
+    const prompt = `${template.systemPrompt}
+
+Project: ${path.basename(projectPath)}
+File: ${filePath || "(auto-detect)"}
+Intent: ${intent}
+${irContext}
+
+${fileHint}
+
+Generate the complete file content now. Output ONLY the code, no markdown fences, no explanation.`;
+    // 3. Call LLM
+    let code;
+    try {
+        code = await (0, llm_1.generate)(prompt);
+        // Strip markdown fences if LLM adds them anyway
+        code = code.replace(/^```(?:typescript|javascript|html|ts|js)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+    }
+    catch (e) {
+        return {
+            success: false,
+            code: "",
+            scaffoldType,
+            error: `LLM generation failed: ${e.message}`,
+        };
+    }
+    if (!code || code.length < 50) {
+        return {
+            success: false,
+            code: "",
+            scaffoldType,
+            error: "LLM returned empty or too-short response",
+        };
+    }
+    // 4. Add Progmune marker
+    const sessionId = `scaffold_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    let marker = "";
+    if (filePath && (filePath.endsWith(".ts") || filePath.endsWith(".tsx"))) {
+        marker = `// @progmune-scaffolded type=${scaffoldType} session=${sessionId} timestamp=${new Date().toISOString()}\n\n`;
+    }
+    else if (filePath && filePath.endsWith(".html")) {
+        marker = `<!-- @progmune-scaffolded type=${scaffoldType} session=${sessionId} timestamp=${new Date().toISOString()} -->\n`;
+    }
+    code = marker + code;
+    // 5. Write to file
+    if (filePath) {
+        const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(projectPath, filePath);
+        const dir = path.dirname(resolved);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(resolved, code, "utf-8");
+        // Record generation for metrics
+        (0, execute_1.recordGeneration)({
+            sessionId,
+            timestamp: Date.now(),
+            filePath: resolved,
+            repaired: false,
+            repairCount: 0,
+            irFunctionCount: irContext ? irContext.split("\n").filter(l => l.includes(" - ")).length : 0,
+        });
+    }
+    // Record for immune memory
+    try {
+        (0, feedback_1.recordRun)(intent, [{ kind: "scaffold", scaffoldType, filePath: filePath || "" }], true);
+    }
+    catch { /* non-critical */ }
+    return {
+        success: true,
+        code,
+        filePath: filePath || undefined,
+        scaffoldType,
+    };
+}
+/** List available scaffold types with descriptions */
+function listScaffolds() {
+    return exports.SCAFFOLD_TYPES.map((t) => ({
+        type: t,
+        description: TEMPLATES[t].description,
+    }));
+}

package/dist/scale-collector.test.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Scale Trajectory Collector + Reward Model Integration 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 scale_trajectory_collector_1 = require("./scale-trajectory-collector");
+const learning_ranker_1 = require("./learning-ranker");
+const logistic_reward_1 = require("./logistic-reward");
+const planner_telemetry_1 = require("./planner-telemetry");
+const repair_ranker_1 = require("./repair-ranker");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SCALE_DIR = path.resolve(__dirname, "..", "test-scale-collector");
+process.env.PROGMUNE_PROJECT_DIR = SCALE_DIR;
+fs.mkdirSync(SCALE_DIR, { recursive: true });
+fs.mkdirSync(path.join(SCALE_DIR, ".progmune_corpus", "telemetry"), { recursive: true });
+fs.mkdirSync(path.join(SCALE_DIR, ".progmune_corpus", "trajectories"), { recursive: true });
+(0, vitest_1.describe)("Scale Trajectory Collector", () => {
+    (0, vitest_1.it)("collects 200+ validated trajectories from all sources", () => {
+        const { sequences, report } = (0, scale_trajectory_collector_1.collectTrajectoriesAtScale)();
+        (0, vitest_1.expect)(report.sourceRepos).toBeGreaterThanOrEqual(20);
+        (0, vitest_1.expect)(report.sourceSequences).toBeGreaterThan(50);
+        (0, vitest_1.expect)(report.finalCorpusSize).toBeGreaterThan(50);
+        // All sequences should be valid physics patterns
+        for (const seq of sequences.slice(0, 10)) {
+            (0, vitest_1.expect)(seq.length).toBeGreaterThanOrEqual(2);
+        }
+        (0, scale_trajectory_collector_1.printCollectionReport)(report);
+    });
+});
+(0, vitest_1.describe)("Reward Model Integration", () => {
+    (0, vitest_1.it)("LearningRanker accepts optional LogisticRewardModel", () => {
+        const telemetry = new planner_telemetry_1.PlannerTelemetry(path.join(SCALE_DIR, ".progmune_corpus", "telemetry", `rl-${Date.now()}.jsonl`));
+        // Seed some telemetry data
+        for (let i = 0; i < 100; 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: "write", protocol: "FileProtocol", violationType: "resource_leak",
+                candidates: [{ candidateId: fp, source: "protocol", evidenceSources: ["protocol"], actions: a, explanation: "full" }],
+                selectedCandidateId: fp,
+            });
+            telemetry.recordFeedback(id, {
+                decision: i < 80 ? "accepted" : "rejected",
+                executionResult: i < 80 ? { success: true, violations: [] } : { success: false, violations: ["leak"] },
+                timestamp: Date.now(),
+            });
+        }
+        // Train reward model
+        const model = logistic_reward_1.LogisticRewardModel.train(telemetry);
+        // Create LearningRanker with reward model
+        const base = (0, repair_ranker_1.createLinearRanker)();
+        const ranker = new learning_ranker_1.LearningRanker(base, telemetry, undefined, model, 0.5);
+        (0, vitest_1.expect)(ranker).toBeDefined();
+        // Rank candidates
+        const candidates = [
+            { id: "safe", source: "protocol", actions: [{ kind: "call", function: "open_file", args: [] }, { kind: "call", function: "write_file", args: [] }, { kind: "call", function: "close_file", args: [] }], explanation: "safe" },
+            { id: "leaky", source: "corpus", actions: [{ kind: "call", function: "open_file", args: [] }, { kind: "call", function: "write_file", args: [] }], explanation: "leaky" },
+        ];
+        const ctx = { protocol: "FileProtocol", currentState: ["FILE_OPEN"], targetState: [], violationType: "resource_leak", constraints: [], rules: new Map() };
+        const features = candidates.map(c => (0, repair_ranker_1.extractFeatures)(c, ctx));
+        const ranked = ranker.rank(candidates, features, { protocol: "FileProtocol", violationType: "resource_leak" });
+        (0, vitest_1.expect)(ranked.length).toBe(2);
+        // Safe candidate should score higher (was accepted 80% vs leaky rejected)
+        (0, vitest_1.expect)(ranked[0].id).toBe("safe");
+    });
+});