progmune-runtime 2.0.2 → 2.1.0

package/dist/benchmark-full.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780350938098_h5bts timestamp=2026-06-01T21:55:39.709Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 404 functions, 17 protocol rules
+const load_benchmarks_1 = require("./load-benchmarks");
+const benchmark_count_1 = require("./benchmark-count");
+const benchmark_report_1 = require("./benchmark-report");
+const benchmark_save_1 = require("./benchmark-save");
+function main() {
+    const benchmarks = (0, load_benchmarks_1.loadBenchmarks)();
+    const count = (0, benchmark_count_1.benchmarkCount)();
+    const report = (0, benchmark_report_1.benchmarkReport)();
+    const savedPath = (0, benchmark_save_1.benchmarkSave)(report);
+    return savedPath;
+}
+main();

package/dist/benchmark-pass-rate.js

@@ -0,0 +1,54 @@
+"use strict";
+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.benchmarkPassRate = benchmarkPassRate;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function benchmarkPassRate() {
+    const resultsDir = path.resolve(process.cwd(), "bench");
+    if (!fs.existsSync(resultsDir))
+        return { total: 0, passed: 0, rate: 0 };
+    const files = fs.readdirSync(resultsDir).filter(f => f.startsWith("results-") && f.endsWith(".json"));
+    if (files.length === 0)
+        return { total: 0, passed: 0, rate: 0 };
+    const latest = files.sort().reverse()[0];
+    const results = JSON.parse(fs.readFileSync(path.join(resultsDir, latest), "utf-8"));
+    const passed = results.filter(r => r.compile_success).length;
+    return {
+        total: results.length,
+        passed,
+        rate: results.length > 0 ? passed / results.length : 0,
+    };
+}

package/dist/benchmark-report.js

@@ -0,0 +1,67 @@
+"use strict";
+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.benchmarkReport = benchmarkReport;
+/** Format benchmark results as a readable report
+ * @protocol pre_states=["BENCHMARKS_LOADED"] post_states=["REPORT_FORMATTED"]
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function benchmarkReport() {
+    const resultsDir = path.resolve(process.cwd(), "bench");
+    if (!fs.existsSync(resultsDir))
+        return "No benchmark results.";
+    const files = fs.readdirSync(resultsDir)
+        .filter(f => f.startsWith("results-") && f.endsWith(".json"))
+        .sort().reverse();
+    if (files.length === 0)
+        return "No benchmark results.";
+    const latest = files[0];
+    const results = JSON.parse(fs.readFileSync(path.join(resultsDir, latest), "utf-8"));
+    const passed = results.filter(r => r.compile_success).length;
+    const repaired = results.filter(r => r.repair_applied).length;
+    const lines = [
+        `Benchmark: ${results.length} tasks`,
+        `Compiled: ${passed}/${results.length} (${((passed / results.length) * 100).toFixed(1)}%)`,
+        `Repaired: ${repaired}`,
+        "",
+    ];
+    for (const r of results) {
+        const icon = r.compile_success ? "✅" : "❌";
+        const repair = r.repair_applied ? " 🔧" : "";
+        lines.push(`${icon} ${r.id}: ${r.intent.slice(0, 60)}${repair}`);
+    }
+    return lines.join("\n");
+}

package/dist/benchmark-save.js

@@ -0,0 +1,62 @@
+"use strict";
+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.benchmarkSave = benchmarkSave;
+exports.benchmarkLoadLatest = benchmarkLoadLatest;
+/** Save benchmark results to a timestamped file
+ * @protocol pre_states=["BENCHMARKS_LOADED"] post_states=["RESULTS_SAVED"]
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function benchmarkSave(data) {
+    const dir = path.resolve(process.cwd(), "bench");
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const ts = Date.now();
+    const filePath = path.join(dir, `results-${ts}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+    return filePath;
+}
+function benchmarkLoadLatest() {
+    const dir = path.resolve(process.cwd(), "bench");
+    if (!fs.existsSync(dir))
+        return null;
+    const files = fs.readdirSync(dir)
+        .filter(f => f.startsWith("results-") && f.endsWith(".json"))
+        .sort().reverse();
+    if (files.length === 0)
+        return null;
+    return JSON.parse(fs.readFileSync(path.join(dir, files[0]), "utf-8"));
+}

package/dist/benchmark-status.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780350835297_stf8a timestamp=2026-06-01T21:53:57.126Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 401 functions, 17 protocol rules
+const load_benchmarks_1 = require("./load-benchmarks");
+const benchmark_count_1 = require("./benchmark-count");
+const benchmark_report_1 = require("./benchmark-report");
+function main() {
+    const tasks = (0, load_benchmarks_1.loadBenchmarks)();
+    const count = (0, benchmark_count_1.benchmarkCount)();
+    const report = (0, benchmark_report_1.benchmarkReport)();
+    return report;
+}
+main();

package/dist/branch-ledger.js

@@ -0,0 +1,365 @@
+"use strict";
+/**
+ * Phase 4: Branch Ledger (P1)
+ *
+ * Upgrades the semantic ledger from linear to tree-structured.
+ * Supports fork/merge for future Repair Planner, alternative plans,
+ * and counterfactual replay.
+ *
+ * A Branch is a named sequence of state transitions with a parent reference.
+ * The full execution is a tree of branches rooted at a single "root" branch.
+ *
+ * Backward compatible: existing linear ledgers auto-wrap as single-branch root.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBranchId = generateBranchId;
+exports.createRootBranch = createRootBranch;
+exports.createBranch = createBranch;
+exports.forkBranch = forkBranch;
+exports.mergeBranches = mergeBranches;
+exports.flattenBranch = flattenBranch;
+exports.getBranchPath = getBranchPath;
+exports.replayBranch = replayBranch;
+exports.buildBranchMap = buildBranchMap;
+exports.findRootBranch = findRootBranch;
+exports.findChildBranches = findChildBranches;
+exports.describeBranchTree = describeBranchTree;
+exports.evaluateBranches = evaluateBranches;
+exports.wrapAsBranch = wrapAsBranch;
+exports.unwrapBranchTree = unwrapBranchTree;
+const ssg_validator_1 = require("./ssg-validator");
+const runtime_invariants_1 = require("./runtime-invariants");
+const protocol_registry_1 = require("./protocol-registry");
+// ── Pure Functions ──
+/** Generate a unique branch ID. */
+function generateBranchId() {
+    return `br_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+}
+/** Create the root branch of a new execution tree. */
+function createRootBranch(transitions = []) {
+    const id = generateBranchId();
+    return {
+        id,
+        rootId: id,
+        transitions,
+        reason: "root",
+        createdAt: Date.now(),
+    };
+}
+/**
+ * Create a CHILD branch (parent → child relationship).
+ *
+ * Tree structure:
+ *   root
+ *   └── child (parentId = root.id)
+ *
+ * The child starts with an independent transition sequence. It does NOT
+ * inherit any transitions from the parent — it begins empty or with
+ * the given initialTransitions. The parent's state at creation time is
+ * the child's implicit starting state; use forkBranch() if you need to
+ * share a prefix of transitions.
+ *
+ * Use createBranch when:
+ * - Creating an alternative implementation from scratch
+ * - The child has no shared history with the parent beyond the parent's
+ *   final state
+ */
+function createBranch(parent, reason = "alternative", initialTransitions = []) {
+    const id = generateBranchId();
+    return {
+        id,
+        parentId: parent.id,
+        rootId: parent.rootId,
+        transitions: initialTransitions,
+        reason,
+        createdAt: Date.now(),
+    };
+}
+/**
+ * Fork a branch at a specific transition index, creating a SIBLING branch.
+ *
+ * Sibling semantics (NOT child):
+ *   parent
+ *   ├── original (branch, truncated at splitIndex, marked "abandoned")
+ *   └── forked  (NEW sibling — same parentId as original, NOT a child of original)
+ *
+ * Tree structure BEFORE fork:
+ *   ... → parent → branch
+ *
+ * Tree structure AFTER fork:
+ *   ... → parent
+ *         ├── original (abandoned — only transitions[0..splitIndex])
+ *         └── forked  (repair_attempt — transitions[splitIndex+1..end])
+ *
+ * Both share the same parent. The forked branch inherits the COMMON PREFIX
+ * (transitions 0..splitIndex) implicitly through the tree path — flattenBranch()
+ * will walk parent → forked and include parent's + forked's transitions.
+ *
+ * Use forkBranch when:
+ * - A violation is detected at splitIndex and you want to try a fix
+ * - The prefix up to splitIndex is valid and should be preserved
+ * - You want to keep the original as evidence (abandoned, not deleted)
+ *
+ * Use createBranch when:
+ * - Starting a completely fresh alternative from the parent's final state
+ */
+function forkBranch(branch, splitIndex, reason = "repair_attempt") {
+    const sharedTransitions = branch.transitions.slice(0, splitIndex + 1);
+    const remainingTransitions = branch.transitions.slice(splitIndex + 1);
+    const original = {
+        ...branch,
+        transitions: sharedTransitions,
+        outcome: "abandoned",
+    };
+    const forked = {
+        id: generateBranchId(),
+        parentId: branch.parentId, // sibling — same parent
+        rootId: branch.rootId,
+        transitions: remainingTransitions,
+        reason,
+        createdAt: Date.now(),
+    };
+    // Ontology: verify all split transitions are internally consistent
+    for (const t of [...sharedTransitions, ...remainingTransitions]) {
+        if (t.valid)
+            try {
+                (0, runtime_invariants_1.assertDeltaConsistency)(t);
+            }
+            catch { }
+    }
+    return { original, forked };
+}
+/** Merge multiple branches into one.
+ *  Takes the successful path: concatenates transitions from each branch
+ *  in the order they appear in the tree path.
+ *  Returns null if no branches have transitions. */
+function mergeBranches(branches) {
+    const validBranches = branches.filter(b => b.transitions.length > 0);
+    if (validBranches.length === 0)
+        return null;
+    // Sort by creation time to preserve causal order
+    const sorted = [...validBranches].sort((a, b) => a.createdAt - b.createdAt);
+    const first = sorted[0];
+    const merged = {
+        id: generateBranchId(),
+        rootId: first.rootId,
+        transitions: [],
+        reason: "merge",
+        createdAt: Date.now(),
+    };
+    // Deduplicate transitions by index (keep first occurrence)
+    const seenIndices = new Set();
+    for (const branch of sorted) {
+        for (const t of branch.transitions) {
+            if (!seenIndices.has(t.actionIndex)) {
+                seenIndices.add(t.actionIndex);
+                merged.transitions.push(t);
+            }
+        }
+    }
+    // Sort by actionIndex
+    merged.transitions.sort((a, b) => a.actionIndex - b.actionIndex);
+    return merged;
+}
+/** Flatten a branch and all its ancestors into a single linear transition sequence.
+ *  This is the bridge between the tree model and existing linear-only consumers
+ *  (checkLedgerConsistency, hashLedger, etc.). */
+function flattenBranch(branch, allBranches) {
+    const path = getBranchPath(branch, allBranches);
+    const allTransitions = [];
+    const seenIndices = new Set();
+    for (const b of path) {
+        for (const t of b.transitions) {
+            // In case of index collision (forked branches), keep the later branch's version
+            if (seenIndices.has(t.actionIndex)) {
+                // Replace the earlier transition with this one
+                const existingIdx = allTransitions.findIndex(existing => existing.actionIndex === t.actionIndex);
+                if (existingIdx >= 0) {
+                    allTransitions[existingIdx] = t;
+                }
+            }
+            else {
+                seenIndices.add(t.actionIndex);
+                allTransitions.push(t);
+            }
+        }
+    }
+    return allTransitions.sort((a, b) => a.actionIndex - b.actionIndex);
+}
+/** Get the path from root to a given branch (inclusive). */
+function getBranchPath(branch, allBranches) {
+    const path = [];
+    let current = branch;
+    while (current) {
+        path.unshift(current);
+        if (current.parentId) {
+            current = allBranches.get(current.parentId);
+        }
+        else {
+            current = undefined;
+        }
+    }
+    return path;
+}
+/** Replay a branch tree: rebuild state across all ancestor branches
+ *  and verify every transition is valid. */
+function replayBranch(branch, allBranches, namespaceInitialStates = (0, protocol_registry_1.getNsInit)()) {
+    const path = getBranchPath(branch, allBranches);
+    const pathIds = path.map(b => b.id);
+    // Collect all transitions in tree order
+    const allTransitions = flattenBranch(branch, allBranches);
+    // Check validity
+    let valid = true;
+    let violationIndex;
+    let violationBranch;
+    for (const t of allTransitions) {
+        if (!t.valid) {
+            valid = false;
+            violationIndex = t.actionIndex;
+            // Find which branch contains this transition
+            for (const b of path) {
+                if (b.transitions.some(bt => bt.actionIndex === t.actionIndex)) {
+                    violationBranch = b.id;
+                    break;
+                }
+            }
+            break;
+        }
+    }
+    const finalState = allTransitions.length > 0
+        ? (0, ssg_validator_1.rebuildState)(allTransitions, namespaceInitialStates)
+        : {};
+    return {
+        branchId: branch.id,
+        path: pathIds,
+        finalState,
+        totalTransitions: allTransitions.length,
+        valid,
+        violationIndex,
+        violationBranch,
+    };
+}
+/** Build a branch lookup map from an array of branches. */
+function buildBranchMap(branches) {
+    const map = new Map();
+    for (const b of branches) {
+        map.set(b.id, b);
+    }
+    return map;
+}
+/** Find the root branch of a tree. */
+function findRootBranch(branches) {
+    return branches.find(b => !b.parentId);
+}
+/** Find all child branches of a given parent. */
+function findChildBranches(parent, allBranches) {
+    const children = [];
+    for (const b of allBranches.values()) {
+        if (b.parentId === parent.id) {
+            children.push(b);
+        }
+    }
+    return children;
+}
+/** Get the full branch tree as a human-readable structure. */
+function describeBranchTree(root, allBranches, indent = 0) {
+    const prefix = "  ".repeat(indent);
+    let result = `${prefix}${root.id.slice(0, 12)} [${root.reason}] (${root.transitions.length} tx, outcome: ${root.outcome || "open"})\n`;
+    const children = findChildBranches(root, allBranches);
+    for (const child of children) {
+        result += describeBranchTree(child, allBranches, indent + 1);
+    }
+    return result;
+}
+/** Evaluate all branches in a tree, score them, and return the recommended winner.
+ *  Scoring: replay +50, zero violations +30, success outcome +20.
+ *  Highest score wins. Ties go to the smaller branch (fewer transitions). */
+function evaluateBranches(branches, namespaceInitialStates = new Map([["_global", "UNAUTHENTICATED"]])) {
+    if (branches.length === 0)
+        return { scores: [], winner: null };
+    const map = buildBranchMap(branches);
+    const scores = [];
+    for (const branch of branches) {
+        const tx = flattenBranch(branch, map);
+        const validCount = tx.filter(t => t.valid).length;
+        const invalidCount = tx.filter(t => !t.valid).length;
+        let replayPassed = false;
+        try {
+            const replay = replayBranch(branch, map, namespaceInitialStates);
+            replayPassed = replay.valid;
+        }
+        catch {
+            replayPassed = false;
+        }
+        let score = 0;
+        if (replayPassed)
+            score += 50;
+        if (invalidCount === 0)
+            score += 30;
+        if (branch.outcome === "success")
+            score += 20;
+        let recommendation = "";
+        if (score >= 90)
+            recommendation = "Recommended — clean execution";
+        else if (score >= 70)
+            recommendation = "Acceptable — minor issues";
+        else if (score >= 50)
+            recommendation = "Needs review — violations present";
+        else
+            recommendation = "Rejected — replay failed or significant violations";
+        scores.push({
+            branchId: branch.id,
+            reason: branch.reason,
+            outcome: branch.outcome || "open",
+            transitionCount: tx.length,
+            validCount,
+            violationCount: invalidCount,
+            replayPassed,
+            score,
+            recommendation,
+        });
+    }
+    // Sort: highest score first, ties broken by fewer transitions
+    scores.sort((a, b) => b.score - a.score || a.transitionCount - b.transitionCount);
+    // Winner is the first one that passed replay
+    const winner = scores.find(s => s.replayPassed) || scores[0] || null;
+    return { scores, winner };
+}
+/** Wrap a linear transition array as a single root branch (backward compat). */
+function wrapAsBranch(transitions) {
+    const b = createRootBranch(transitions);
+    b.outcome = transitions.length > 0
+        ? (transitions.every(t => t.valid) ? "success" : "violation")
+        : "success";
+    return b;
+}
+/** Unwrap a branch tree to the linear transition list.
+ *  For backward compatibility: flattens the "winning" path (first successful leaf). */
+function unwrapBranchTree(branches) {
+    if (branches.length === 0)
+        return [];
+    const map = buildBranchMap(branches);
+    const root = findRootBranch(branches);
+    if (!root)
+        return [];
+    // Find the first successful leaf
+    const successfulLeaf = findSuccessfulLeaf(root, map);
+    if (successfulLeaf) {
+        return flattenBranch(successfulLeaf, map);
+    }
+    // Fallback: flatten the root
+    return flattenBranch(root, map);
+}
+function findSuccessfulLeaf(branch, allBranches) {
+    if (branch.outcome === "success") {
+        // Check if any children are also successful (prefer children)
+        const children = findChildBranches(branch, allBranches);
+        for (const child of children) {
+            const leaf = findSuccessfulLeaf(child, allBranches);
+            if (leaf)
+                return leaf;
+        }
+        return branch;
+    }
+    return undefined;
+}

package/dist/branch-tree-count.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343627181_k5xw4 timestamp=2026-06-01T19:53:48.655Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 389 functions, 17 protocol rules
+const failure_corpus_1 = require("./failure-corpus");
+const branch_ledger_1 = require("./branch-ledger");
+function main() {
+    const sessions = (0, failure_corpus_1.getAllSessions)();
+    const root = (0, branch_ledger_1.findRootBranch)(sessions);
+    const children = (0, branch_ledger_1.findChildBranches)(root, {});
+    return children;
+}
+main();