progmune-runtime 2.1.5 → 3.2.0

package/dist/asset-factory.js

@@ -0,0 +1,309 @@
+"use strict";
+/**
+ * Asset Factory — the operational engine of the Evidence Company.
+ *
+ * Progmune doesn't sell detections.
+ * It accumulates production evidence that turns protocol knowledge
+ * into trusted governance assets.
+ *
+ * This module turns the Promotion Pipeline from a concept into a tool.
+ * Like GitHub PRs for verification assets.
+ *
+ * Three queues:
+ *   1. Review Queue    — assets awaiting human review
+ *   2. Evidence Queue  — evidence pending validation
+ *   3. Promotion Queue — assets ready for promotion
+ *
+ * Factory Health metrics:
+ *   - Research intake/week
+ *   - Pilot promotion/week
+ *   - Production promotion/month
+ *   - Average promotion time
+ *   - Queue depth
+ *
+ * Usage:
+ *   npx ts-node --transpile-only src/asset-factory.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetFactory = void 0;
+exports.getAssetFactory = getAssetFactory;
+exports.formatAssetFactory = formatAssetFactory;
+// ═══════════════════════════════════════════════════════════════
+// Asset Factory
+// ═══════════════════════════════════════════════════════════════
+class AssetFactory {
+    constructor() {
+        this.reviewQueue = [];
+        this.evidenceQueue = [];
+        this.promotionQueue = [];
+        this.seed();
+    }
+    /** Seed with current known assets awaiting review. */
+    seed() {
+        // Pilot assets awaiting evidence for Production
+        this.reviewQueue = [
+            {
+                id: "REV-001",
+                assetName: "File Lifecycle",
+                domain: "File",
+                currentTier: "Pilot Ready",
+                targetTier: "Production Ready",
+                evidence: ["curl (85 seqs)", "nginx (50 seqs)", "Score: 10/20"],
+                submittedBy: "auto",
+                submittedAt: "2026-06-15",
+                status: "pending",
+                priority: "high",
+            },
+            {
+                id: "REV-002",
+                assetName: "SSH Key Exchange",
+                domain: "SSH",
+                currentTier: "Pilot Ready",
+                targetTier: "Production Ready",
+                evidence: ["curl (85 seqs)", "libssh (47 seqs)", "RFC 4253", "Score: 11/20"],
+                submittedBy: "auto",
+                submittedAt: "2026-06-20",
+                status: "pending",
+                priority: "high",
+            },
+            {
+                id: "REV-003",
+                assetName: "HTTP Request Lifecycle",
+                domain: "HTTP",
+                currentTier: "Pilot Ready",
+                targetTier: "Production Ready",
+                evidence: ["nginx (50 seqs)", "nghttp2 (52 seqs)", "RFC 9110", "Score: 9/20"],
+                submittedBy: "auto",
+                submittedAt: "2026-06-22",
+                status: "pending",
+                priority: "medium",
+            },
+            {
+                id: "REV-004",
+                assetName: "Memory Alloc/Free",
+                domain: "Memory",
+                currentTier: "Research",
+                targetTier: "Pilot Ready",
+                evidence: ["curl (85 seqs)", "Score: 4/20"],
+                submittedBy: "auto",
+                submittedAt: "2026-07-01",
+                status: "pending",
+                priority: "low",
+            },
+        ];
+        // Evidence pending validation
+        this.evidenceQueue = [
+            {
+                id: "EVI-001",
+                assetName: "TLS Handshake",
+                type: "deployment",
+                source: "staging-cluster-1",
+                value: "30 days, 0 FPs",
+                submittedAt: "2026-06-28",
+                validated: false,
+            },
+            {
+                id: "EVI-002",
+                assetName: "File Lifecycle",
+                type: "repo_scan",
+                source: "redis",
+                value: "50 sequences, 45% FP rate",
+                submittedAt: "2026-07-01",
+                validated: false,
+            },
+            {
+                id: "EVI-003",
+                assetName: "SSH Key Exchange",
+                type: "rfc_alignment",
+                source: "RFC 4253",
+                value: "Key exchange protocol matched",
+                submittedAt: "2026-06-15",
+                validated: true,
+            },
+        ];
+        // Assets ready for promotion
+        this.promotionQueue = [
+            {
+                id: "PRO-001",
+                assetName: "File Lifecycle",
+                from: "Pilot Ready",
+                to: "Production Ready",
+                score: 10,
+                readySince: "2026-06-15",
+                blockedBy: ["Needs RFC reference", "FP rate 45% — needs VI suppression"],
+            },
+            {
+                id: "PRO-002",
+                assetName: "SSH Key Exchange",
+                from: "Pilot Ready",
+                to: "Production Ready",
+                score: 11,
+                readySince: "2026-06-20",
+                blockedBy: ["Needs deployment validation"],
+            },
+        ];
+    }
+    /** Get the review queue. */
+    getReviewQueue() {
+        return [...this.reviewQueue].sort((a, b) => {
+            const priority = { high: 0, medium: 1, low: 2 };
+            return priority[a.priority] - priority[b.priority];
+        });
+    }
+    /** Get the evidence queue. */
+    getEvidenceQueue() {
+        return [...this.evidenceQueue].filter(e => !e.validated);
+    }
+    /** Get the promotion queue. */
+    getPromotionQueue() {
+        return [...this.promotionQueue];
+    }
+    /** Compute Factory Health metrics. */
+    getHealth() {
+        const reviewDepth = this.reviewQueue.filter(r => r.status === "pending").length;
+        const evidenceDepth = this.evidenceQueue.filter(e => !e.validated).length;
+        const promotionDepth = this.promotionQueue.length;
+        // Determine status
+        let status = "HEALTHY";
+        let bottleneck = null;
+        if (reviewDepth >= 3 && promotionDepth >= 2) {
+            status = "BOTTLENECKED";
+            bottleneck = "Review queue backing up — need more reviewers";
+        }
+        else if (evidenceDepth === 0 && reviewDepth === 0) {
+            status = "STARVED";
+            bottleneck = "No new evidence — need more repo scans";
+        }
+        return {
+            queues: { reviewDepth, evidenceDepth, promotionDepth },
+            throughput: {
+                researchIntakePerWeek: 1.5,
+                pilotPromotionPerWeek: 0.5,
+                productionPromotionPerMonth: 1.0,
+            },
+            cycleTime: {
+                avgReviewToPromotion: "2-4 weeks",
+                avgEvidenceToValidation: "3-5 days",
+            },
+            status,
+            bottleneck,
+        };
+    }
+    /** Approve a review item → triggers promotion. */
+    approve(id, reviewer) {
+        const item = this.reviewQueue.find(r => r.id === id);
+        if (!item)
+            return `Review item ${id} not found`;
+        item.status = "approved";
+        this.promotionQueue.push({
+            id: `PRO-${Date.now().toString(36)}`,
+            assetName: item.assetName,
+            from: item.currentTier,
+            to: item.targetTier,
+            score: 0,
+            readySince: new Date().toISOString(),
+            blockedBy: [],
+        });
+        return `${item.assetName} approved by ${reviewer} → moved to promotion queue`;
+    }
+    /** Validate an evidence item. */
+    validateEvidence(id) {
+        const item = this.evidenceQueue.find(e => e.id === id);
+        if (!item)
+            return `Evidence ${id} not found`;
+        item.validated = true;
+        return `Evidence ${id} validated: ${item.value}`;
+    }
+}
+exports.AssetFactory = AssetFactory;
+// ═══════════════════════════════════════════════════════════════
+// Singleton
+// ═══════════════════════════════════════════════════════════════
+let _factory = null;
+function getAssetFactory() {
+    if (!_factory)
+        _factory = new AssetFactory();
+    return _factory;
+}
+// ═══════════════════════════════════════════════════════════════
+// Formatter
+// ═══════════════════════════════════════════════════════════════
+function formatAssetFactory() {
+    const factory = getAssetFactory();
+    const health = factory.getHealth();
+    const lines = [];
+    lines.push("");
+    lines.push("╔══════════════════════════════════════════════════════════════╗");
+    lines.push("║     Asset Factory — Evidence Company Operations               ║");
+    lines.push("╠══════════════════════════════════════════════════════════════╣");
+    const statusIcon = health.status === "HEALTHY" ? "🟢" : health.status === "BOTTLENECKED" ? "🟡" : "🔴";
+    lines.push(`║  Status: ${statusIcon} ${health.status}`.padEnd(63) + "║");
+    if (health.bottleneck) {
+        lines.push(`║  Bottleneck: ${health.bottleneck.slice(0, 48)}`.padEnd(63) + "║");
+    }
+    lines.push("╚══════════════════════════════════════════════════════════════╝");
+    lines.push("");
+    // Factory Health
+    lines.push("── Factory Health ──");
+    lines.push(`  Throughput:`);
+    lines.push(`    Research intake:       ${health.throughput.researchIntakePerWeek}/week`);
+    lines.push(`    Pilot promotion:       ${health.throughput.pilotPromotionPerWeek}/week`);
+    lines.push(`    Production promotion:  ${health.throughput.productionPromotionPerMonth}/month`);
+    lines.push(`  Cycle Time:`);
+    lines.push(`    Review → Promotion:    ${health.cycleTime.avgReviewToPromotion}`);
+    lines.push(`    Evidence → Validation: ${health.cycleTime.avgEvidenceToValidation}`);
+    lines.push("");
+    // Review Queue
+    const reviews = factory.getReviewQueue();
+    lines.push(`── Review Queue (${reviews.filter(r => r.status === "pending").length} pending) ──`);
+    if (reviews.length === 0) {
+        lines.push("  No assets awaiting review.");
+    }
+    else {
+        for (const r of reviews) {
+            const icon = r.status === "approved" ? "✅" : r.status === "rejected" ? "❌" : "📝";
+            const prioIcon = r.priority === "high" ? "🔴" : r.priority === "medium" ? "🟡" : "🟢";
+            lines.push(`  ${icon} ${prioIcon} ${r.assetName.padEnd(25)} ${r.currentTier} → ${r.targetTier}`);
+            lines.push(`     Evidence: ${r.evidence.join(", ")}`);
+        }
+    }
+    lines.push("");
+    // Evidence Queue
+    const evidence = factory.getEvidenceQueue();
+    lines.push(`── Evidence Queue (${evidence.length} pending validation) ──`);
+    if (evidence.length === 0) {
+        lines.push("  No evidence awaiting validation.");
+    }
+    else {
+        for (const e of evidence) {
+            lines.push(`  📋 ${e.assetName.padEnd(25)} ${e.type}: ${e.value} (from: ${e.source})`);
+        }
+    }
+    lines.push("");
+    // Promotion Queue
+    const promotions = factory.getPromotionQueue();
+    lines.push(`── Promotion Queue (${promotions.length} ready) ──`);
+    if (promotions.length === 0) {
+        lines.push("  No assets ready for promotion.");
+    }
+    else {
+        for (const p of promotions) {
+            const blocked = p.blockedBy.length > 0 ? ` [BLOCKED: ${p.blockedBy.join(", ")}]` : " [UNBLOCKED]";
+            lines.push(`  ⬆️ ${p.assetName.padEnd(25)} ${p.from} → ${p.to} (Score: ${p.score})${blocked}`);
+        }
+    }
+    lines.push("");
+    // Value proposition
+    lines.push("── Evidence Company ──");
+    lines.push(`  Progmune doesn't sell detections.`);
+    lines.push(`  It accumulates production evidence that turns`);
+    lines.push(`  protocol knowledge into trusted governance assets.`);
+    lines.push("");
+    lines.push(`  Algorithms can be replicated.`);
+    lines.push(`  Evidence cannot.`);
+    lines.push("");
+    return lines.join("\n");
+}
+if (require.main === module) {
+    console.log(formatAssetFactory());
+}

package/dist/asset-growth.js

@@ -0,0 +1,244 @@
+"use strict";
+/**
+ * Asset Library Growth — the compounding value of Progmune.
+ *
+ * Each new repo scanned → each Asset gets stronger → more Production Assets.
+ *
+ * This tool answers the enterprise question:
+ *   "If I scan repo X, how many new Production Assets do I get?"
+ *
+ * And the investment question:
+ *   "How fast is the Asset Library growing?"
+ *
+ * Usage:
+ *   npx ts-node --transpile-only src/asset-growth.ts
+ */
+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.projectAssetGrowth = projectAssetGrowth;
+exports.scoreRepoAssets = scoreRepoAssets;
+exports.formatAssetGrowth = formatAssetGrowth;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const asset_quality_1 = require("./asset-quality");
+/**
+ * Scan all benchmark repos and project Asset Library growth.
+ */
+function projectAssetGrowth() {
+    const benchmarksDir = path.resolve(process.cwd(), "benchmarks");
+    const current = (0, asset_quality_1.generateAssetLibrary)();
+    const repos = ["curl", "libssh", "nginx", "redis"];
+    const contributions = [];
+    for (const repo of repos) {
+        const labelFile = path.join(benchmarksDir, `${repo}-labels.json`);
+        const hasLabels = fs.existsSync(labelFile);
+        let labeledSequences = 0;
+        if (hasLabels) {
+            try {
+                const data = JSON.parse(fs.readFileSync(labelFile, "utf-8"));
+                labeledSequences = Object.keys(data.labels || {}).length;
+            }
+            catch { /* */ }
+        }
+        // Estimate contribution based on repo characteristics
+        const repoContributions = {
+            curl: { assets: ["TLS Handshake", "HTTP Request Lifecycle", "SSH Key Exchange", "File Lifecycle"], gain: 2 },
+            libssh: { assets: ["SSH Key Exchange", "Password Verify → JWT → Session"], gain: 1 },
+            nginx: { assets: ["HTTP Request Lifecycle", "File Lifecycle"], gain: 1 },
+            redis: { assets: ["Connection Setup/Teardown"], gain: 0 },
+        };
+        const contrib = repoContributions[repo] || { assets: [], gain: 0 };
+        contributions.push({
+            repo,
+            hasLabels,
+            labeledSequences,
+            newAssetsDiscovered: contrib.assets.length,
+            assetsPromoted: contrib.assets,
+            estimatedProductionGain: contrib.gain,
+        });
+    }
+    const totalGain = contributions.reduce((s, c) => s + c.estimatedProductionGain, 0);
+    return {
+        current: {
+            productionReady: current.summary.productionReady,
+            pilotReady: current.summary.pilotReady,
+            totalAssets: current.assets.length,
+        },
+        contributions,
+        projected: {
+            productionReady: current.summary.productionReady + totalGain,
+            pilotReady: current.summary.pilotReady + contributions.reduce((s, c) => s + c.newAssetsDiscovered, 0),
+            totalAssets: current.assets.length + contributions.reduce((s, c) => s + c.newAssetsDiscovered, 0),
+        },
+        growthRate: `${contributions.filter(c => c.estimatedProductionGain > 0).length}/${contributions.length} repos yield Production Assets`,
+        timeTo100: totalGain > 0
+            ? `${Math.ceil((100 - current.summary.productionReady) / totalGain)} more repo-scans at current rate`
+            : "Need more labeled repos for projection",
+    };
+}
+/**
+ * Score all rules discovered in a repo and rank by deployment readiness.
+ */
+function scoreRepoAssets(repoName) {
+    const labelFile = path.join(process.cwd(), "benchmarks", `${repoName}-labels.json`);
+    if (!fs.existsSync(labelFile))
+        return [];
+    const data = JSON.parse(fs.readFileSync(labelFile, "utf-8"));
+    const sequences = data.sequences || {};
+    // Count function frequency
+    const fnFreq = new Map();
+    const fnRepos = new Map();
+    for (const calls of Object.values(sequences)) {
+        const seen = new Set();
+        for (const fn of calls) {
+            fnFreq.set(fn, (fnFreq.get(fn) || 0) + 1);
+            if (!seen.has(fn)) {
+                if (!fnRepos.has(fn))
+                    fnRepos.set(fn, new Set());
+                fnRepos.get(fn).add(repoName);
+                seen.add(fn);
+            }
+        }
+    }
+    // Score each function as if it were an Asset
+    const scored = [];
+    for (const [fn, freq] of fnFreq) {
+        if (freq < 2)
+            continue; // Too rare
+        const repoCount = fnRepos.get(fn)?.size || 1;
+        // Estimate FP rate: generic functions → high FP, protocol functions → low FP
+        const isGeneric = /^(memset|memcpy|strlen|strcmp|defined|UNUSED|free|malloc|printf)/i.test(fn);
+        const isProtocol = /^(ssl_|tls_|ssh_|http_|curl_|ngx_|open_|close_|init_|create_|verify_|auth_)/i.test(fn);
+        const fpRateEstimate = isGeneric ? 0.85 : isProtocol ? 0.25 : 0.55;
+        // Mock asset for scoring
+        const mockAsset = {
+            id: `rule:${repoName}:${fn}`,
+            kind: "verification_rule",
+            name: fn,
+            domain: isProtocol ? fn.split("_")[0].toUpperCase() : "General",
+            stage: repoCount >= 2 ? "observed" : "candidate",
+            confidence: isProtocol ? 0.7 : 0.3,
+            importance: isProtocol ? 70 : 30,
+            evidence: {
+                repos: [repoName],
+                rfcRefs: [],
+                sequenceCount: freq,
+                crossRepoCount: repoCount,
+                firstSeen: new Date().toISOString(),
+                lastSeen: new Date().toISOString(),
+            },
+            history: [],
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            description: `${fn} (${freq}× in ${repoName})`,
+        };
+        const score = (0, asset_quality_1.computeDeploymentScore)(mockAsset, fpRateEstimate);
+        const tier = (0, asset_quality_1.classifyAssetTier)(score);
+        scored.push({
+            function: fn,
+            domain: mockAsset.domain,
+            deploymentScore: score.total,
+            tier,
+            fpRateEstimate,
+            repoCount,
+            isNew: true,
+        });
+    }
+    return scored.sort((a, b) => b.deploymentScore - a.deploymentScore);
+}
+// ═══════════════════════════════════════════════════════════════
+// Formatter
+// ═══════════════════════════════════════════════════════════════
+function bar(value, max, width = 15) {
+    const filled = Math.round((value / max) * width);
+    return "█".repeat(filled) + "░".repeat(width - filled);
+}
+function formatAssetGrowth(p) {
+    const lines = [];
+    lines.push("");
+    lines.push("╔══════════════════════════════════════════════════════════════╗");
+    lines.push("║     Asset Library Growth Projection                           ║");
+    lines.push("╠══════════════════════════════════════════════════════════════╣");
+    lines.push(`║  Current: ${p.current.productionReady} Production  |  ${p.current.pilotReady} Pilot  |  ${p.current.totalAssets} Total Assets`.padEnd(63) + "║");
+    lines.push("╚══════════════════════════════════════════════════════════════╝");
+    lines.push("");
+    // Per-repo contributions
+    lines.push("── Per-Repo Contribution ──");
+    lines.push("  'Which repo gives us the most new Production Assets?'");
+    lines.push("");
+    lines.push("  ┌──────────┬──────────┬──────────────┬──────────┬──────────────────────────────────────┐");
+    lines.push("  │ Repo     │ Seqs     │ New Assets   │ Prod.Gain│ Assets Promoted                      │");
+    lines.push("  ├──────────┼──────────┼──────────────┼──────────┼──────────────────────────────────────┤");
+    for (const c of p.contributions) {
+        const gainIcon = c.estimatedProductionGain > 0 ? "✅" : "—";
+        const gainStr = c.estimatedProductionGain > 0 ? `+${c.estimatedProductionGain}` : "0";
+        const promoted = c.assetsPromoted.slice(0, 3).join(", ");
+        lines.push(`  │ ${c.repo.padEnd(8)} │ ${String(c.labeledSequences).padStart(7)}  │ ${String(c.newAssetsDiscovered).padStart(11)}  │ ${gainStr.padStart(7)}  │ ${promoted.padEnd(36)} │`);
+    }
+    lines.push("  └──────────┴──────────┴──────────────┴──────────┴──────────────────────────────────────┘");
+    lines.push("");
+    // Projection
+    lines.push("── Projection ──");
+    lines.push(`  Current:  ${p.current.productionReady} Production Assets`);
+    lines.push(`  After 4 repos: ${p.projected.productionReady} Production Assets (+${p.projected.productionReady - p.current.productionReady})`);
+    lines.push(`  Growth rate: ${p.growthRate}`);
+    lines.push(`  Time to 100: ${p.timeTo100}`);
+    lines.push("");
+    // Compound value
+    lines.push("── Compound Value ──");
+    lines.push("  Each new repo:");
+    lines.push("    1. Discovers new Asset candidates");
+    lines.push("    2. Strengthens existing Assets (more repos = higher score)");
+    lines.push("    3. Promotes Pilot → Production when score crosses 16/20");
+    lines.push("");
+    lines.push("  Asset Library growth is compounding:");
+    lines.push(`    ${p.current.productionReady} → ${p.current.productionReady + 1} → ${p.current.productionReady + 2} → ... → 100`);
+    lines.push("");
+    return lines.join("\n");
+}
+// ═══════════════════════════════════════════════════════════════
+// CLI
+// ═══════════════════════════════════════════════════════════════
+if (require.main === module) {
+    const projection = projectAssetGrowth();
+    console.log(formatAssetGrowth(projection));
+    // Also show per-repo scoring for curl
+    console.log("── Curl: Top Assets by Deployment Score ──");
+    const curlAssets = scoreRepoAssets("curl");
+    for (const a of curlAssets.slice(0, 10)) {
+        const icon = a.tier === "Production Ready" ? "✅" : a.tier === "Pilot Ready" ? "⚠️" : a.tier === "Research" ? "🔬" : "🗄️";
+        console.log(`  ${icon} ${a.function.padEnd(40)} Score: ${String(a.deploymentScore).padStart(2)}/20  FP: ${(a.fpRateEstimate * 100).toFixed(0)}%  ${a.tier}`);
+    }
+}