progmune-runtime 2.0.2 → 2.1.0

package/dist/deterministic-replay.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * Phase 4: Deterministic Replay (P1)
+ *
+ * Verifies that replaying a session's ledger against current rules
+ * produces the same result as the stored execution certificate.
+ *
+ * Answers: "Would this execution produce the same result today?"
+ * Not just "read the log" — actively re-validates every transition.
+ */
+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.replaySession = replaySession;
+exports.replayLedger = replayLedger;
+exports.replayWithDetail = replayWithDetail;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ledger_registry_1 = require("./ledger-registry");
+const protocol_registry_1 = require("./protocol-registry");
+const ssg_validator_1 = require("./ssg-validator");
+const branch_ledger_1 = require("./branch-ledger");
+// ── Core Replay ──
+/** Replay a session from disk, comparing against its stored fingerprint. */
+function replaySession(sessionId, currentRules, namespaceInitialStates = (0, protocol_registry_1.getNsInit)()) {
+    // Load session
+    const sessionsDir = path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd(), ".progmune_corpus/sessions");
+    const sessionFile = path.join(sessionsDir, `${sessionId}.json`);
+    if (!fs.existsSync(sessionFile)) {
+        return {
+            success: false,
+            sessionId,
+            finalState: {},
+            replayedHash: "",
+            storedHash: "",
+            ruleHashMatch: false,
+            ledgerHashMatch: false,
+            totalTransitions: 0,
+            validTransitions: 0,
+            invalidTransitions: 0,
+            divergencePoint: 0,
+            divergenceDetail: `Session file not found: ${sessionFile}`,
+        };
+    }
+    const session = JSON.parse(fs.readFileSync(sessionFile, "utf-8"));
+    // Collect all transitions
+    let transitions = [];
+    let sessionRuleHash = session.ruleHash || "";
+    // Handle branch tree if present (Phase 4)
+    if (session.branchTree && session.branchTree.length > 0) {
+        const branches = session.branchTree;
+        const map = (0, branch_ledger_1.buildBranchMap)(branches);
+        const root = (0, branch_ledger_1.findRootBranch)(branches);
+        if (root) {
+            transitions = (0, branch_ledger_1.flattenBranch)(root, map);
+        }
+        // Use first attempt's ruleHash as session hash
+        if (!sessionRuleHash && branches[0]?.transitions[0]?.ruleHash) {
+            sessionRuleHash = branches[0].transitions[0].ruleHash;
+        }
+    }
+    else {
+        // Legacy: collect from attempts
+        for (const attempt of (session.attempts || [])) {
+            if (attempt.transitions) {
+                transitions = transitions.concat(attempt.transitions);
+            }
+            if (!sessionRuleHash && (attempt.ruleHash || session.ruleHash)) {
+                sessionRuleHash = attempt.ruleHash || session.ruleHash;
+            }
+        }
+    }
+    // Load fingerprint
+    const fingerprint = (0, ledger_registry_1.getFingerprint)(sessionId);
+    const storedHash = fingerprint?.ledgerHash || "";
+    // Compute current rule hash
+    let currentRuleHash = "";
+    if (currentRules && currentRules.size > 0) {
+        currentRuleHash = (0, ssg_validator_1.hashRules)(currentRules);
+    }
+    return replayLedger(sessionId, transitions, sessionRuleHash, storedHash, currentRuleHash, currentRules, namespaceInitialStates);
+}
+/** Core replay logic: replay transitions against (optional) current rules. */
+function replayLedger(sessionId, transitions, storedRuleHash, storedLedgerHash, currentRuleHash, currentRules, namespaceInitialStates = (0, protocol_registry_1.getNsInit)()) {
+    const replayedHash = transitions.length > 0 ? (0, ssg_validator_1.hashLedger)(transitions) : "";
+    const ruleHashMatch = !currentRuleHash || !storedRuleHash
+        ? true // can't compare if either is missing
+        : currentRuleHash === storedRuleHash;
+    const ledgerHashMatch = !storedLedgerHash
+        ? true // no fingerprint to compare against
+        : replayedHash === storedLedgerHash;
+    // Replay each transition if we have current rules
+    let validTransitions = 0;
+    let invalidTransitions = 0;
+    let divergencePoint;
+    let divergenceDetail;
+    if (currentRules && currentRules.size > 0) {
+        const ctx = {
+            ledger: [],
+            currentState: (0, ssg_validator_1.rebuildState)([], namespaceInitialStates),
+        };
+        for (let i = 0; i < transitions.length; i++) {
+            const t = transitions[i];
+            if (!t.valid) {
+                invalidTransitions++;
+                continue;
+            }
+            try {
+                // Re-validate against current rules
+                const { valid, transition } = (0, ssg_validator_1.validateTransition)(ctx, t.function, i, currentRules, namespaceInitialStates, currentRuleHash || "");
+                if (!valid && divergencePoint === undefined) {
+                    divergencePoint = i;
+                    divergenceDetail = `Transition[${i}] "${t.function}" is no longer valid under current rules.`;
+                }
+                // Check statesBefore matches rebuilt state
+                const rebuiltBefore = ctx.currentState;
+                const beforeMatch = deepEqualSnapshots(rebuiltBefore, t.statesBefore);
+                if (!beforeMatch && divergencePoint === undefined) {
+                    divergencePoint = i;
+                    divergenceDetail = `Transition[${i}] "${t.function}" statesBefore mismatch: rebuilt=${JSON.stringify(rebuiltBefore[t.namespace] || [])} recorded=${JSON.stringify(t.statesBefore[t.namespace] || [])}`;
+                }
+                if (valid) {
+                    validTransitions++;
+                    ctx.ledger.push(transition);
+                    ctx.currentState = transition.statesAfter;
+                }
+                else {
+                    invalidTransitions++;
+                    ctx.ledger.push({ ...t, valid: false });
+                }
+            }
+            catch {
+                invalidTransitions++;
+                if (divergencePoint === undefined) {
+                    divergencePoint = i;
+                    divergenceDetail = `Transition[${i}] "${t.function}" threw an error during replay. Rule may have changed.`;
+                }
+            }
+        }
+    }
+    else {
+        // No current rules: just verify structural consistency
+        const consistency = (0, ssg_validator_1.checkLedgerConsistency)(transitions, namespaceInitialStates);
+        if (!consistency.consistent) {
+            divergencePoint = consistency.violations[0]?.index;
+            divergenceDetail = `Structural inconsistency: ${consistency.violations.length} violation(s). First: [${consistency.violations[0]?.invariant}] at index ${consistency.violations[0]?.index}`;
+        }
+        validTransitions = transitions.filter(t => t.valid).length;
+        invalidTransitions = transitions.filter(t => !t.valid).length;
+    }
+    // Compute final state
+    const finalState = transitions.length > 0
+        ? (0, ssg_validator_1.rebuildState)(transitions.filter(t => t.valid), namespaceInitialStates)
+        : {};
+    const success = ruleHashMatch && ledgerHashMatch && divergencePoint === undefined;
+    return {
+        success,
+        sessionId,
+        finalState,
+        divergencePoint,
+        divergenceDetail,
+        replayedHash,
+        storedHash: storedLedgerHash,
+        ruleHashMatch,
+        ledgerHashMatch,
+        totalTransitions: transitions.length,
+        validTransitions,
+        invalidTransitions,
+    };
+}
+/** Replay with per-transition detail — for debugging and UI. */
+function replayWithDetail(transitions, currentRules, namespaceInitialStates = (0, protocol_registry_1.getNsInit)()) {
+    if (!currentRules || currentRules.size === 0) {
+        return transitions.map(t => ({
+            index: t.actionIndex,
+            function: t.function,
+            namespace: t.namespace,
+            originalValid: t.valid,
+            replayValid: t.valid,
+            statesBeforeMatch: true,
+            statesAfterMatch: true,
+        }));
+    }
+    const ctx = {
+        ledger: [],
+        currentState: (0, ssg_validator_1.rebuildState)([], namespaceInitialStates),
+    };
+    const currentRuleHash = (0, ssg_validator_1.hashRules)(currentRules);
+    const results = [];
+    for (let i = 0; i < transitions.length; i++) {
+        const t = transitions[i];
+        const result = {
+            index: t.actionIndex,
+            function: t.function,
+            namespace: t.namespace,
+            originalValid: t.valid,
+            replayValid: false,
+            statesBeforeMatch: false,
+            statesAfterMatch: false,
+        };
+        if (!t.valid) {
+            result.detail = "Originally invalid";
+            results.push(result);
+            continue;
+        }
+        try {
+            const { valid, transition } = (0, ssg_validator_1.validateTransition)(ctx, t.function, i, currentRules, namespaceInitialStates, currentRuleHash);
+            result.replayValid = valid;
+            result.statesBeforeMatch = deepEqualSnapshots(ctx.currentState, t.statesBefore);
+            result.statesAfterMatch = valid
+                ? deepEqualSnapshots(transition.statesAfter, t.statesAfter)
+                : false;
+            if (!result.statesBeforeMatch) {
+                result.detail = `statesBefore mismatch`;
+            }
+            else if (!result.statesAfterMatch) {
+                result.detail = `statesAfter mismatch`;
+            }
+            else if (!valid) {
+                result.detail = `No longer valid under current rules`;
+            }
+            ctx.ledger.push(valid ? transition : { ...t, valid: false });
+            ctx.currentState = valid ? transition.statesAfter : ctx.currentState;
+        }
+        catch (e) {
+            result.replayValid = false;
+            result.detail = `Error: ${e.message?.slice(0, 80)}`;
+        }
+        results.push(result);
+    }
+    return results;
+}
+// ── Helpers ──
+function deepEqualSnapshots(a, b) {
+    const keysA = Object.keys(a).sort();
+    const keysB = Object.keys(b).sort();
+    if (keysA.length !== keysB.length)
+        return false;
+    for (const k of keysA) {
+        if (!b[k])
+            return false;
+        if (a[k].join(",") !== b[k].join(","))
+            return false;
+    }
+    return true;
+}

package/dist/emitter.js

@@ -39,11 +39,44 @@ const BASIC_TYPES = new Set([
     "string", "number", "boolean", "any", "void", "undefined", "null",
     "str", "int", "float", "bool", "list", "dict", "tuple", "bytes",
 ]);
+/** Normalize a type string to an importable type name.
+ *  Strips [], <...>, unions, and typeof expressions.
+ *  e.g. "StateTransition[]" → "StateTransition"
+ *       "Map<string, string>" → "Map"
+ *       "Action | null" → "Action"
+ *       "ReturnType<typeof fn>" → null (complex, skip) */
+function normalizeTypeName(raw) {
+    let t = raw.trim();
+    // Skip function types and complex expressions
+    if (t.includes("=>") || t.includes("typeof"))
+        return null;
+    // Strip array brackets
+    t = t.replace(/\[\]/g, "");
+    // Strip generic parameters
+    t = t.replace(/<[^>]*>/g, "");
+    // Take first part of union/intersection
+    t = t.split("|")[0].split("&")[0].trim();
+    // Must be a simple identifier
+    if (/^[A-Z][a-zA-Z0-9_]*$/.test(t))
+        return t;
+    return null;
+}
 function getImportPath(file) {
-    return "./" + file.replace(/\.ts$|\.tsx$/, "");
+    // Normalize: strip common src/ prefix since generated code lives in src/
+    let clean = file.replace(/\.ts$|\.tsx$/, "");
+    if (clean.startsWith("src/"))
+        clean = clean.slice(4);
+    return "./" + clean;
 }
-function emitCode(actions) {
-    const ir = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
+/**
+ * 将动作序列编译为目标语言代码。
+ * @protocol namespace=dev_pipeline pre_states=["SEQUENCE_VALIDATED"] post_states=["CODE_EMITTED"] invalidate=["SEQUENCE_VALIDATED"]
+ */
+function emitCode(actions, meta) {
+    const irRaw = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
+    // Support both old format (array) and new format ({typeMap, functions})
+    const typeMap = irRaw.typeMap || {};
+    const ir = irRaw.functions || irRaw;
     const fnIndex = new Map();
     const fnMeta = new Map();
     for (const f of ir) {
@@ -56,16 +89,21 @@ function emitCode(actions) {
         if (action.kind === "call" && action.function) {
             const file = fnIndex.get(action.function);
             const meta = fnMeta.get(action.function);
-            if (file) {
+            // Skip external functions — they are global/standard library (fs, path, etc.)
+            // Skip non-exported functions — can't import what isn't exported
+            if (file && file !== "(external)" && meta?.exported !== false) {
                 if (!imports.has(file))
                     imports.set(file, new Set());
                 imports.get(file).add(action.function);
                 if (meta?.params) {
                     for (const p of meta.params) {
-                        if (!BASIC_TYPES.has(p.type)) {
-                            if (!typeImports.has(file))
-                                typeImports.set(file, new Set());
-                            typeImports.get(file).add(p.type);
+                        const normalized = normalizeTypeName(p.type);
+                        if (normalized && !BASIC_TYPES.has(normalized)) {
+                            // Use typeMap to find the correct module for this type
+                            const typeFile = typeMap[normalized] || file;
+                            if (!typeImports.has(typeFile))
+                                typeImports.set(typeFile, new Set());
+                            typeImports.get(typeFile).add(normalized);
                         }
                     }
                 }
@@ -81,14 +119,63 @@ function emitCode(actions) {
     };
     for (const a of actions)
         collect(a);
+    // ── Generation marker (provable usage) ──
     let code = "";
+    if (meta?.sessionId) {
+        const ts = new Date().toISOString();
+        code += `// @progmune-generated session=${meta.sessionId} timestamp=${ts}`;
+        if (meta.ruleHash)
+            code += ` ruleHash=${meta.ruleHash}`;
+        code += `\n`;
+        const funcs = meta.irFunctionCount ?? ir.length;
+        const rules = meta.protocolRuleCount ?? 0;
+        code += `// Generated with IR constraint: ${funcs} functions`;
+        if (rules > 0)
+            code += `, ${rules} protocol rules`;
+        code += `\n`;
+    }
     for (const [file, funcSet] of imports)
         code += `import { ${[...funcSet].join(", ")} } from "${getImportPath(file)}";\n`;
     for (const [file, typeSet] of typeImports)
         code += `import type { ${[...typeSet].join(", ")} } from "${getImportPath(file)}";\n`;
-    code += "\nexport function main() {\n";
+    // Pre-scan: find input variables (referenced but never assigned via call/assign)
     const declared = new Set();
+    const referenced = new Set();
     let counter = 0;
+    // First pass: collect declared and referenced variables
+    for (const action of actions) {
+        if (action.kind === "call" && action.assignTo) {
+            declared.add(action.assignTo);
+        }
+        else if (action.kind === "assign" && action.target) {
+            declared.add(action.target);
+        }
+        // Collect arg value references
+        if (action.kind === "call" && action.args) {
+            for (const arg of action.args) {
+                const v = typeof arg === "object" ? arg?.value : arg;
+                if (typeof v === "string" && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(v) && v !== "") {
+                    referenced.add(v);
+                }
+            }
+        }
+    }
+    // Inputs = referenced but not declared — add as typed parameters
+    const inputs = [...referenced].filter(v => !declared.has(v) && v !== "");
+    const inputTypes = new Map();
+    for (const action of actions) {
+        if (action.kind === "call" && action.args) {
+            for (const arg of action.args) {
+                const v = typeof arg === "object" ? arg?.value : arg;
+                const t = typeof arg === "object" ? arg?.type : "string";
+                if (typeof v === "string" && inputs.includes(v) && t && t !== "any") {
+                    inputTypes.set(v, t);
+                }
+            }
+        }
+    }
+    const paramList = inputs.map(v => `${v}: ${inputTypes.get(v) || "string"}`).join(", ");
+    code += `\nexport function main(${paramList}) {\n`;
     const convert = (action, indent = "  ") => {
         if (!action || !action.kind)
             return "";
@@ -103,15 +190,20 @@ function emitCode(actions) {
                 const val = a?.value;
                 if (typeof val === "string" && declared.has(val))
                     return val;
+                // If value looks like a variable name (valid JS identifier), pass it through
+                if (typeof val === "string" && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(val) && val !== "") {
+                    declared.add(val);
+                    return val;
+                }
                 const paramType = meta?.params?.[i]?.type || "any";
                 if (BASIC_TYPES.has(paramType)) {
                     if (paramType === "string" || paramType === "str")
-                        return `"defaultStr"`;
+                        return `""`;
                     if (paramType === "number" || paramType === "int" || paramType === "float")
                         return "0";
                     if (paramType === "boolean" || paramType === "bool")
                         return "false";
-                    return `"default"`;
+                    return `""`;
                 }
                 if (paramType === "UserPayload")
                     return `{ id: 1, role: "user" } as UserPayload`;
@@ -161,6 +253,14 @@ function emitCode(actions) {
     };
     for (const a of actions)
         code += convert(a) + "\n";
-    code += "}\nmain();\n";
+    code += "}\n";
+    // Call main with params if it has inputs, otherwise no-arg call
+    if (inputs.length > 0) {
+        // Don't call — the user provides the arguments
+        // Just export the function for external use
+    }
+    else {
+        code += "main();\n";
+    }
     return code;
 }

package/dist/exec-metrics.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343438004_ux6bt timestamp=2026-06-01T19:50:39.415Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 385 functions, 17 protocol rules
+const execute_1 = require("./execute");
+function main() {
+    const metrics = (0, execute_1.getExecutionMetrics)();
+    return metrics;
+}
+main();