@neuroverseos/nv-sim 0.1.4 → 0.1.5

package/dist/engine/cli.js

@@ -56,7 +56,9 @@ const liveVisualizer_1 = require("./liveVisualizer");
 const narrativeInjection_1 = require("./narrativeInjection");
 const scenarioLibrary_1 = require("./scenarioLibrary");
 const scenarioCapsule_1 = require("./scenarioCapsule");
+const behavioralAnalysis_1 = require("./behavioralAnalysis");
 const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
 // ============================================
 // CLI ARGUMENT PARSING
 // ============================================
@@ -235,7 +237,7 @@ async function main() {
                 }
                 console.log(`\n  Same events. Different rules. Different outcomes.`);
             }
-            console.log(`\n  Simulate the future. Govern the outcomes.`);
+            console.log(`\n  Design rules. Run reality. See what changes.`);
             console.log(`  neuroverse-simulations | @neuroverseos\n`);
             break;
         }
@@ -414,9 +416,8 @@ async function main() {
                 console.log("  Interactive world controls ready.\n");
                 console.log("  Change world rules, inject narrative events, run simulations.");
                 console.log("  Press Ctrl+C to stop.\n");
-                const { exec } = require("child_process");
                 const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-                exec(`${openCmd} ${url}`, () => { });
+                (0, child_process_1.exec)(`${openCmd} ${url}`, () => { });
             });
             await new Promise(() => { }); // block forever
             break;
@@ -437,7 +438,15 @@ async function main() {
                 console.log(`\n  Server ready: ${url}`);
                 console.log(`  Governance:   ${url}/api/evaluate`);
                 console.log(`  Dashboard:    ${url}`);
-                console.log(`  SSE stream:   ${url}/events\n`);
+                console.log(`  SSE stream:   ${url}/events`);
+                console.log("");
+                console.log("  Session & Reporting:");
+                console.log(`  Stats:        GET  ${url}/api/session`);
+                console.log(`  Report:       GET  ${url}/api/session/report`);
+                console.log(`  Report JSON:  GET  ${url}/api/session/report.json`);
+                console.log(`  Reset:        POST ${url}/api/session/reset`);
+                console.log(`  Save:         POST ${url}/api/session/save\n`);
+                console.log("  Workflow: evaluate → report → apply new rules → reset → compare");
                 console.log("  Waiting for simulator connections...");
                 console.log("  Press Ctrl+C to stop.\n");
             });
@@ -454,11 +463,11 @@ async function main() {
             console.log("  " + "=".repeat(60));
             // Step 1: Start governance server
             console.log(`  [1/3] Starting governance server on port ${runPort}...`);
+            const { createAdapter: ca, ADAPTER_REGISTRY: ar } = await Promise.resolve().then(() => __importStar(require("./liveAdapter")));
             (0, liveVisualizer_1.startInteractiveServer)(runPort, (url) => {
                 console.log(`  [1/3] Governance ready: ${url}/api/evaluate`);
                 // Step 2: Start simulator via live adapter
                 console.log(`  [2/3] Starting ${simId} simulator...`);
-                const { createAdapter: ca, ADAPTER_REGISTRY: ar } = require("./liveAdapter");
                 // Check if we have a registry entry, otherwise try raw command
                 const adapterEntry = ar[simId];
                 if (!adapterEntry) {
@@ -504,14 +513,151 @@ async function main() {
                 });
                 // Open viewer unless --no-viewer
                 if (!noViewer) {
-                    const { exec } = require("child_process");
                     const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-                    exec(`${openCmd} ${url}`, () => { });
+                    (0, child_process_1.exec)(`${openCmd} ${url}`, () => { });
                 }
             });
             await new Promise(() => { }); // block forever
             break;
         }
+        case "world-from-doc": {
+            // Generate a world file from a plain-English document
+            const docPath = args[1];
+            if (!docPath) {
+                console.error("\n  Usage: npx nv-sim world-from-doc <file>\n");
+                console.error("  Reads a document (.md, .txt, .pdf) and generates a world definition.\n");
+                console.error("  Examples:");
+                console.error("    npx nv-sim world-from-doc policy.md");
+                console.error("    npx nv-sim world-from-doc regulations.txt --output my-world.json");
+                console.error("    cat rules.txt | npx nv-sim world-from-doc -\n");
+                process.exit(1);
+            }
+            const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+            const path = await Promise.resolve().then(() => __importStar(require("path")));
+            let docText;
+            if (docPath === "-") {
+                // Read from stdin
+                const chunks = [];
+                for await (const chunk of process.stdin) {
+                    chunks.push(Buffer.from(chunk));
+                }
+                docText = Buffer.concat(chunks).toString("utf-8");
+            }
+            else {
+                const resolved = path.resolve(docPath);
+                if (!fs.existsSync(resolved)) {
+                    console.error(`\n  Error: File not found: ${resolved}\n`);
+                    process.exit(1);
+                }
+                docText = fs.readFileSync(resolved, "utf-8");
+            }
+            console.log(`\n  NV-SIM — World File Generator\n`);
+            console.log(`  Reading: ${docPath === "-" ? "stdin" : docPath}`);
+            console.log("  " + "=".repeat(60));
+            // Parse the document into a world definition
+            const lines = docText.split("\n").map(l => l.trim()).filter(l => l.length > 0);
+            const worldId = args.includes("--id") ? args[args.indexOf("--id") + 1] : path.basename(docPath, path.extname(docPath)).replace(/\s+/g, "_").toLowerCase();
+            // Extract thesis (first paragraph or heading)
+            let thesis = "";
+            const invariants = [];
+            const gates = [];
+            const stateVars = [];
+            let invCount = 0;
+            let gateCount = 0;
+            for (const line of lines) {
+                const lower = line.toLowerCase();
+                // Skip markdown headers but use them for context
+                if (line.startsWith("#")) {
+                    if (!thesis)
+                        thesis = line.replace(/^#+\s*/, "");
+                    continue;
+                }
+                // First non-header line as thesis if not set
+                if (!thesis && line.length > 10) {
+                    thesis = line;
+                    continue;
+                }
+                // Detect rules: lines starting with block/prevent/limit/require/allow etc
+                if (/^(block|prevent|prohibit|ban|stop|forbid|no\b|don.t|limit|cap|restrict)/i.test(lower)) {
+                    invCount++;
+                    invariants.push({
+                        id: `INV-${String(invCount).padStart(3, "0")}`,
+                        description: line.replace(/^[-*•]\s*/, ""),
+                        enforceable: true,
+                    });
+                }
+                else if (/^(require|must|shall|ensure|mandate)/i.test(lower)) {
+                    invCount++;
+                    invariants.push({
+                        id: `INV-${String(invCount).padStart(3, "0")}`,
+                        description: line.replace(/^[-*•]\s*/, ""),
+                        enforceable: true,
+                    });
+                }
+                else if (/^(allow|permit|enable)/i.test(lower)) {
+                    invCount++;
+                    invariants.push({
+                        id: `INV-${String(invCount).padStart(3, "0")}`,
+                        description: line.replace(/^[-*•]\s*/, ""),
+                        enforceable: false,
+                    });
+                }
+                else if (/^(warn|alert|flag|monitor|watch)/i.test(lower)) {
+                    gateCount++;
+                    gates.push({
+                        id: `GATE-${String(gateCount).padStart(3, "0")}`,
+                        label: line.replace(/^[-*•]\s*/, ""),
+                        condition: lower,
+                        severity: /critical|extreme|emergency/i.test(lower) ? "critical" : "warning",
+                    });
+                }
+                else if (/^[-*•]\s*/.test(line)) {
+                    // Bullet points are probably rules
+                    invCount++;
+                    invariants.push({
+                        id: `INV-${String(invCount).padStart(3, "0")}`,
+                        description: line.replace(/^[-*•]\s*/, ""),
+                        enforceable: true,
+                    });
+                }
+            }
+            if (!thesis)
+                thesis = "Governance rules from " + (docPath === "-" ? "document" : docPath);
+            const worldDef = {
+                thesis,
+                state_variables: stateVars,
+                invariants,
+                gates,
+            };
+            // Wrap in SavedWorld format so enforce can consume it directly
+            const { createSavedWorld: createWorld } = await Promise.resolve().then(() => __importStar(require("./worldStorage")));
+            const savedWorld = createWorld(worldId, worldDef, "document", {
+                description: `Generated from ${docPath === "-" ? "stdin" : docPath}`,
+            });
+            // Output
+            const outputPath = args.includes("--output") ? args[args.indexOf("--output") + 1] : null;
+            const json = JSON.stringify(savedWorld, null, 2);
+            if (outputPath) {
+                fs.writeFileSync(outputPath, json, "utf-8");
+                console.log(`\n  Generated: ${outputPath}`);
+            }
+            else {
+                console.log("\n" + json);
+            }
+            console.log(`\n  Summary:`);
+            console.log(`    Thesis:     ${thesis}`);
+            console.log(`    Invariants: ${invariants.length}`);
+            console.log(`    Gates:      ${gates.length}`);
+            console.log(`\n  This world file is saved for reuse.`);
+            console.log(`  You don't need this step — enforce accepts .txt directly:`);
+            console.log(`    npx nv-sim enforce trading ${docPath === "-" ? "policy.txt" : docPath}`);
+            if (outputPath) {
+                console.log(`\n  But since you saved it, you can also:`);
+                console.log(`    npx nv-sim enforce trading ${outputPath}`);
+            }
+            console.log("");
+            break;
+        }
         case "preset": {
             const presetId = args[1];
             if (!presetId) {
@@ -540,6 +686,864 @@ async function main() {
             console.log("  Usage: npx nv-sim preset <preset_id>\n");
             break;
         }
+        // ============================================
+        // WORLD SAVE / LOAD / LIST
+        // ============================================
+        case "world:save": {
+            const sourcePreset = args[1];
+            const outputPath = args[2] || `${sourcePreset || "world"}.nv-world.json`;
+            const nameArg = args.find(a => a.startsWith("--name="))?.slice(7);
+            if (!sourcePreset) {
+                console.error("  Usage: npx nv-sim world:save <preset|file.json> [output.nv-world.json] [--name=My World]");
+                console.error("  Available presets: trading, strait_of_hormuz, gas_price_spike, ai_regulation_crisis");
+                process.exit(1);
+            }
+            try {
+                const { resolveWorld } = await Promise.resolve().then(() => __importStar(require("./worldComparison")));
+                const { createSavedWorld, saveWorldToFile } = await Promise.resolve().then(() => __importStar(require("./worldStorage")));
+                const resolved = resolveWorld(sourcePreset);
+                const name = nameArg || resolved.title;
+                const saved = createSavedWorld(name, resolved.world, sourcePreset, {
+                    description: `Saved from CLI: ${resolved.title}`,
+                });
+                await saveWorldToFile(saved, outputPath);
+                console.log(`\n  World saved: ${outputPath}`);
+                console.log(`  Name: ${saved.name}`);
+                console.log(`  Thesis: ${saved.world.thesis}`);
+                console.log(`  Rules: ${saved.world.invariants.length} invariants, ${(saved.world.gates ?? []).length} gates`);
+                console.log(`  ID: ${saved.id}\n`);
+            }
+            catch (err) {
+                console.error(`  Failed to save world: ${err instanceof Error ? err.message : err}`);
+                process.exit(1);
+            }
+            break;
+        }
+        case "world:load": {
+            const filePath = args[1];
+            if (!filePath) {
+                console.error("  Usage: npx nv-sim world:load <file.nv-world.json>");
+                process.exit(1);
+            }
+            try {
+                const { loadWorldFromFile } = await Promise.resolve().then(() => __importStar(require("./worldStorage")));
+                const world = await loadWorldFromFile(filePath);
+                console.log(`\n  World loaded: ${filePath}`);
+                console.log(`  Name: ${world.name}`);
+                console.log(`  Thesis: ${world.world.thesis}`);
+                console.log(`  Base: ${world.basePreset}`);
+                console.log(`  Rules: ${world.world.invariants.length} invariants, ${(world.world.gates ?? []).length} gates`);
+                console.log(`  Created: ${world.createdAt}`);
+                console.log(`  ID: ${world.id}\n`);
+                console.log("  INVARIANTS:");
+                for (const inv of world.world.invariants) {
+                    console.log(`    [${inv.enforceable ? "ENFORCED" : "ADVISORY"}] ${inv.description}`);
+                }
+                if (world.world.gates?.length) {
+                    console.log("\n  GATES:");
+                    for (const gate of world.world.gates) {
+                        console.log(`    [${gate.severity.toUpperCase()}] ${gate.label}: ${gate.condition}`);
+                    }
+                }
+                console.log();
+            }
+            catch (err) {
+                console.error(`  Failed to load world: ${err instanceof Error ? err.message : err}`);
+                process.exit(1);
+            }
+            break;
+        }
+        case "world:list": {
+            const { getAvailableWorlds, explainWorldGovernance } = await Promise.resolve().then(() => __importStar(require("./worldComparison")));
+            const worlds = getAvailableWorlds();
+            console.log(`\n  NV-SIM — Available Worlds\n`);
+            console.log("  " + "=".repeat(60));
+            for (const w of worlds) {
+                console.log(`\n  ${w.id}`);
+                console.log(`    ${w.title}`);
+                console.log(`    ${w.thesis.slice(0, 80)}${w.thesis.length > 80 ? "..." : ""}`);
+                console.log(`    ${w.invariantCount} rules, ${w.gateCount} gates`);
+            }
+            console.log(`\n  Total: ${worlds.length} worlds available\n`);
+            console.log("  Use: npx nv-sim worlds <worldA> <worldB>   to compare");
+            console.log("  Use: npx nv-sim world:save <preset>        to save as JSON\n");
+            break;
+        }
+        case "world:compare": {
+            // Compare two saved world files
+            const fileA = args[1];
+            const fileB = args[2];
+            if (!fileA || !fileB) {
+                console.error("  Usage: npx nv-sim world:compare <worldA.json> <worldB.json>");
+                process.exit(1);
+            }
+            try {
+                const { loadWorldFromFile, saveWorldToStorage } = await Promise.resolve().then(() => __importStar(require("./worldStorage")));
+                const worldA = await loadWorldFromFile(fileA);
+                const worldB = await loadWorldFromFile(fileB);
+                // Temporarily register in storage so resolveWorld can find them
+                saveWorldToStorage(worldA);
+                saveWorldToStorage(worldB);
+                console.log(`\n  NV-SIM — World File Comparison\n`);
+                console.log(`  World A: ${worldA.name} (${fileA})`);
+                console.log(`  World B: ${worldB.name} (${fileB})`);
+                console.log("  " + "=".repeat(60));
+                const compResult = await (0, worldComparison_1.runWorldComparison)(worldA.id, worldB.id, {
+                    onProgress: (label, phase) => console.log(`  ${label}: ${phase}...`),
+                });
+                const { generateComparisonImpact } = await Promise.resolve().then(() => __importStar(require("./worldComparison")));
+                const impact = generateComparisonImpact(compResult);
+                printWorldComparisonResults(compResult, impact);
+            }
+            catch (err) {
+                console.error(`  Comparison failed: ${err instanceof Error ? err.message : err}`);
+                process.exit(1);
+            }
+            break;
+        }
+        // ============================================
+        // PRIME RADIANT — Full Policy Enforcement System
+        // ============================================
+        case "radiant":
+        case "prime": {
+            const presetId = (args[1] && !args[1].startsWith("--")) ? args[1] : undefined;
+            const mode = args.includes("--compare") ? "compare" : args.includes("--world") ? "world" : "simulate";
+            console.log(`\n  PRIME RADIANT — Policy Enforcement System\n`);
+            console.log(`  "govern() controls actions. governDynamics() controls outcomes."\n`);
+            console.log("  " + "=".repeat(60));
+            const { createPrimeRadiant, PRIME_RADIANT_PRESETS } = await Promise.resolve().then(() => __importStar(require("./primeRadiant")));
+            // Resolve preset or use default
+            const presetKey = presetId && (presetId in PRIME_RADIANT_PRESETS)
+                ? presetId
+                : "university_crisis";
+            const preset = PRIME_RADIANT_PRESETS[presetKey];
+            const narrativeEvents = (0, narrativeInjection_1.parseInjectArgs)(args);
+            console.log(`  Preset: ${presetKey}`);
+            const radiant = createPrimeRadiant({
+                scenario: preset.scenario,
+                policyText: preset.policyText,
+                stakeholders: preset.stakeholders,
+                narrativeEvents: narrativeEvents.length > 0 ? narrativeEvents : undefined,
+            });
+            if (mode === "world") {
+                // MODE 1: Build world
+                console.log(`  Mode: WORLD BUILDER\n`);
+                const world = radiant.buildWorld();
+                console.log(`  Policy Health: ${world.health.healthScore}/100`);
+                console.log(`  Total Rules:   ${world.coverageReport.totalRules}`);
+                console.log(`    Enforced:    ${world.coverageReport.enforcedRules}`);
+                console.log(`    Advisory:    ${world.coverageReport.advisoryRules}`);
+                console.log(`    Dynamics:    ${world.coverageReport.dynamicsRulesDetected}`);
+                console.log(`  Thesis: ${world.world.thesis}`);
+                if (world.coverageReport.uncoveredCritical.length > 0) {
+                    console.log(`\n  UNCOVERED CRITICAL VARIABLES:`);
+                    for (const v of world.coverageReport.uncoveredCritical) {
+                        console.log(`    - ${v}`);
+                    }
+                }
+                console.log(`\n  INVARIANTS:`);
+                for (const inv of world.world.invariants) {
+                    console.log(`    [${inv.enforceable ? "ENFORCED" : "ADVISORY"}] ${inv.description}`);
+                }
+                if (world.world.gates && world.world.gates.length > 0) {
+                    console.log(`\n  GATES:`);
+                    for (const gate of world.world.gates) {
+                        console.log(`    [${gate.severity.toUpperCase()}] ${gate.label}`);
+                    }
+                }
+            }
+            else if (mode === "compare") {
+                // MODE 3: Decision Intelligence
+                console.log(`  Mode: DECISION INTELLIGENCE\n`);
+                const options = preset.policyOptions;
+                console.log(`  Comparing ${options.length} policy options...\n`);
+                for (const opt of options) {
+                    console.log(`    ${opt.id.padEnd(20)} ${opt.label}`);
+                }
+                console.log();
+                const result = await radiant.compareOptions(options);
+                // Print decision brief
+                console.log(result.decisionBrief);
+                // Print dynamics details
+                console.log(`\n  DYNAMICS GOVERNANCE`);
+                console.log("  " + "-".repeat(50));
+                for (const optResult of result.optionResults) {
+                    const d = optResult.simulation.dynamicsGovernance;
+                    console.log(`  ${optResult.optionLabel}:`);
+                    console.log(`    Interventions: ${d.totalInterventions} (propagation: ${d.propagationLimits}, amplification: ${d.amplificationDampens}, cascade: ${d.cascadeBreakers}, trust: ${d.trustBoosts}, cooling: ${d.coolingPeriods})`);
+                    console.log(`    Peak outrage: ${(d.peakOutrage * 100).toFixed(0)}% | Peak polarization: ${(d.peakPolarization * 100).toFixed(0)}% | Avg trust: ${(d.averageTrust * 100).toFixed(0)}%`);
+                }
+                // Print recommendation
+                console.log(`\n  RECOMMENDATION: ${result.recommendation.optionLabel}`);
+                console.log(`  Confidence: ${(result.recommendation.confidence * 100).toFixed(0)}%`);
+                console.log(`  ${result.recommendation.rationale}`);
+            }
+            else {
+                // MODE 2: Governed Simulation
+                console.log(`  Mode: GOVERNED SIMULATION\n`);
+                console.log(`  Running dual-layer governance...`);
+                console.log(`    Layer A: govern()         — per-action, per-agent`);
+                console.log(`    Layer B: governDynamics()  — per-round, system-level\n`);
+                const result = await radiant.runGovernedSimulation();
+                const g = result.governed;
+                const b = result.baseline;
+                const d = result.delta;
+                // System state timeline
+                console.log(`  STATE EVOLUTION`);
+                console.log("  " + "-".repeat(60));
+                console.log(`  ${"Round".padEnd(8)} ${"Trust".padEnd(10)} ${"Outrage".padEnd(10)} ${"Polar.".padEnd(10)} ${"Cascade".padEnd(10)} ${"Trajectory"}`);
+                for (const snap of g.stateTimeline) {
+                    const round = g.rounds.find(r => r.round === snap.round);
+                    console.log(`  ${String(snap.round).padEnd(8)} ${(snap.trust * 100).toFixed(0).padStart(4)}%     ${(snap.outrage * 100).toFixed(0).padStart(4)}%     ${(snap.polarization * 100).toFixed(0).padStart(4)}%     ${(snap.cascadeRisk * 100).toFixed(0).padStart(4)}%     ${round?.dynamicsTrajectory ?? "-"}`);
+                }
+                // Action governance
+                console.log(`\n  ACTION GOVERNANCE (Layer A)`);
+                console.log("  " + "-".repeat(50));
+                const ag = g.actionGovernance;
+                console.log(`  Evaluations: ${ag.totalEvaluations}`);
+                console.log(`  Allowed: ${ag.allowed} | Blocked: ${ag.blocked} | Modified: ${ag.modified} | Paused: ${ag.paused}`);
+                console.log(`  Avg reduction: ${(ag.avgReduction * 100).toFixed(0)}% | Rules fired: ${ag.rulesFired}`);
+                // Dynamics governance
+                console.log(`\n  DYNAMICS GOVERNANCE (Layer B)`);
+                console.log("  " + "-".repeat(50));
+                const dg = g.dynamicsGovernance;
+                console.log(`  Total interventions: ${dg.totalInterventions}`);
+                console.log(`    Propagation limits:  ${dg.propagationLimits}`);
+                console.log(`    Amplification damps: ${dg.amplificationDampens}`);
+                console.log(`    Cascade breakers:    ${dg.cascadeBreakers}`);
+                console.log(`    Trust boosts:        ${dg.trustBoosts}`);
+                console.log(`    Cooling periods:     ${dg.coolingPeriods}`);
+                console.log(`  Peak outrage:        ${(dg.peakOutrage * 100).toFixed(0)}%`);
+                console.log(`  Peak polarization:   ${(dg.peakPolarization * 100).toFixed(0)}%`);
+                console.log(`  Peak cascade risk:   ${(dg.peakCascadeRisk * 100).toFixed(0)}%`);
+                console.log(`  Average trust:       ${(dg.averageTrust * 100).toFixed(0)}%`);
+                // Delta
+                console.log(`\n  GOVERNANCE IMPACT (vs ungoverned baseline)`);
+                console.log("  " + "=".repeat(50));
+                console.log(`  Trust:         ${d.trustDelta > 0 ? "+" : ""}${(d.trustDelta * 100).toFixed(0)} points  (${(b.finalState.trust * 100).toFixed(0)}% → ${(g.finalState.trust * 100).toFixed(0)}%)`);
+                console.log(`  Polarization:  ${d.polarizationDelta < 0 ? "" : "+"}${(d.polarizationDelta * 100).toFixed(0)} points  (${(b.finalState.polarization * 100).toFixed(0)}% → ${(g.finalState.polarization * 100).toFixed(0)}%)`);
+                console.log(`  Outrage:       ${d.outrageDelta < 0 ? "" : "+"}${(d.outrageDelta * 100).toFixed(0)} points  (${(b.finalState.outrage * 100).toFixed(0)}% → ${(g.finalState.outrage * 100).toFixed(0)}%)`);
+                console.log(`  Cascade risk:  ${d.cascadeRiskDelta < 0 ? "" : "+"}${(d.cascadeRiskDelta * 100).toFixed(0)} points  (${(b.finalState.cascadeRisk * 100).toFixed(0)}% → ${(g.finalState.cascadeRisk * 100).toFixed(0)}%)`);
+                console.log(`  System health: ${d.healthDelta > 0 ? "+" : ""}${d.healthDelta}  (${b.systemHealthScore}/100 → ${g.systemHealthScore}/100)`);
+                console.log(`  Trajectory:    ${d.trajectoryShift}`);
+                console.log(`  Effectiveness: ${(d.governanceEffectiveness * 100).toFixed(0)}%`);
+                // Inflection points
+                if (g.inflectionPoints.length > 0) {
+                    console.log(`\n  INFLECTION POINTS`);
+                    console.log("  " + "-".repeat(50));
+                    for (const ip of g.inflectionPoints) {
+                        console.log(`  ${ip}`);
+                    }
+                }
+                // Narrative
+                console.log(`\n  NARRATIVE`);
+                console.log("  " + "-".repeat(50));
+                const words = result.narrative.split(" ");
+                let line = "  ";
+                for (const word of words) {
+                    if (line.length + word.length > 72) {
+                        console.log(line);
+                        line = "  " + word;
+                    }
+                    else {
+                        line += (line.trim() ? " " : "") + word;
+                    }
+                }
+                if (line.trim())
+                    console.log(line);
+            }
+            console.log(`\n  ${"=".repeat(60)}`);
+            console.log(`  govern() controls actions.`);
+            console.log(`  governDynamics() controls outcomes.`);
+            console.log(`  ${"=".repeat(60)}`);
+            console.log(`\n  Design rules. Run reality. See what changes.`);
+            console.log(`  neuroverse-simulations | @neuroverseos\n`);
+            break;
+        }
+        // ============================================
+        // MIROFISH — Governed Agent Simulation
+        // ============================================
+        case "mirofish": {
+            console.log(`\n  MIROFISH SIMULATION — Governed by NeuroVerse\n`);
+            console.log(`  MiroFish + NeuroVerse Governance Layer`);
+            console.log(`  MiroFish generates emergent agent behavior.`);
+            console.log(`  NeuroVerse enforces rules, constraints, and system stability in real time.\n`);
+            console.log("  " + "=".repeat(60));
+            const { runMiroFishComparison } = await Promise.resolve().then(() => __importStar(require("../adapters/mirofish")));
+            const mfMode = args.includes("--compare") ? "compare" : "governed";
+            if (mfMode === "compare") {
+                console.log(`  Mode: GOVERNED vs UNGOVERNED COMPARISON\n`);
+                console.log(`  Running simulation...`);
+                const comparison = runMiroFishComparison();
+                const gov = comparison.governed;
+                const ungov = comparison.ungoverned;
+                const gs = gov.metrics.systemState;
+                const us = ungov.metrics.systemState;
+                console.log(`\n  Scenario: ${comparison.scenario}`);
+                console.log("  " + "=".repeat(60));
+                // Metric comparison
+                console.log(`\n  ${"Metric".padEnd(30)} ${"Governed".padEnd(15)} ${"Ungoverned".padEnd(15)} ${"Delta"}`);
+                console.log("  " + "-".repeat(75));
+                const mfMetrics = [
+                    ["Trust", gs.trust, us.trust],
+                    ["Polarization", gs.polarization, us.polarization],
+                    ["Outrage", gs.outrage, us.outrage],
+                    ["Cascade Risk", gs.cascadeRisk, us.cascadeRisk],
+                    ["Amplification", gs.amplification, us.amplification],
+                ];
+                for (const [label, gv, uv] of mfMetrics) {
+                    const delta = gv - uv;
+                    const deltaStr = `${delta > 0 ? "+" : ""}${(delta * 100).toFixed(0)}`;
+                    console.log(`  ${label.padEnd(30)} ${(gv * 100).toFixed(0).padStart(5)}%         ${(uv * 100).toFixed(0).padStart(5)}%         ${deltaStr.padStart(5)}`);
+                }
+                console.log(`\n  ${"".padEnd(30)} ${"Governed".padEnd(15)} ${"Ungoverned"}`);
+                console.log("  " + "-".repeat(60));
+                console.log(`  ${"Verdict".padEnd(30)} ${gov.verdict.padEnd(15)} ${ungov.verdict}`);
+                console.log(`  ${"Actions Blocked".padEnd(30)} ${String(gov.totalBlocked).padEnd(15)} ${0}`);
+                console.log(`  ${"Actions Modified".padEnd(30)} ${String(gov.totalModified).padEnd(15)} ${0}`);
+                console.log(`  ${"Trajectory".padEnd(30)} ${gov.metrics.trajectory.padEnd(15)} ${ungov.metrics.trajectory}`);
+                // State timeline
+                console.log(`\n  STATE EVOLUTION (Trust)`);
+                console.log("  " + "-".repeat(60));
+                console.log(`  ${"Round".padEnd(8)} ${"Governed".padEnd(15)} ${"Ungoverned".padEnd(15)} ${"Gap"}`);
+                for (let i = 0; i < gov.timeline.length; i++) {
+                    const gt = gov.timeline[i].systemState.trust;
+                    const ut = ungov.timeline[i].systemState.trust;
+                    const gap = gt - ut;
+                    console.log(`  ${String(i + 1).padEnd(8)} ${(gt * 100).toFixed(0).padStart(5)}%         ${(ut * 100).toFixed(0).padStart(5)}%         ${(gap > 0 ? "+" : "") + (gap * 100).toFixed(0).padStart(4)}`);
+                }
+                // Science state comparison
+                const govSci = gov.metrics.scienceState;
+                const ungovSci = ungov.metrics.scienceState;
+                console.log(`\n  SYSTEM ASSESSMENT`);
+                console.log("  " + "-".repeat(60));
+                console.log(`  Governed:    ${govSci.overallAssessment}`);
+                console.log(`  Ungoverned:  ${ungovSci.overallAssessment}`);
+                console.log(`\n  This simulation was generated by MiroFish.`);
+                console.log(`  NeuroVerse governance altered the system trajectory in real time.`);
+            }
+            else {
+                // Single governed run
+                console.log(`  Mode: GOVERNED SIMULATION\n`);
+                const { createMiroFishWrapper, generateDemoSimulation } = await Promise.resolve().then(() => __importStar(require("../adapters/mirofish")));
+                const demo = generateDemoSimulation();
+                const wrapper = createMiroFishWrapper({ enabled: true });
+                console.log(`  Scenario: ${demo.scenario}\n`);
+                for (let i = 0; i < demo.rounds.length; i++) {
+                    const round = demo.rounds[i];
+                    let blocked = 0;
+                    let modified = 0;
+                    const approved = [];
+                    for (const action of round) {
+                        const result = wrapper.interceptAction(action);
+                        if (result.wasBlocked)
+                            blocked++;
+                        else if (result.wasModified)
+                            modified++;
+                        if (!result.wasBlocked)
+                            approved.push(result.governed ?? action);
+                    }
+                    const cycleResult = wrapper.completeCycle({ cycle: i + 1, actions: approved });
+                    const m = wrapper.getMetrics();
+                    const flags = blocked > 0 ? ` [${blocked} blocked]` : "";
+                    console.log(`  Round ${String(i + 1).padEnd(3)} | trust: ${(m.systemState.trust * 100).toFixed(0).padStart(3)}% | cascade: ${(m.systemState.cascadeRisk * 100).toFixed(0).padStart(3)}% | ${cycleResult.trajectory}${flags}`);
+                }
+                const final = wrapper.getMetrics();
+                console.log(`\n  FINAL STATE`);
+                console.log("  " + "=".repeat(50));
+                console.log(`  Trust:         ${(final.systemState.trust * 100).toFixed(0)}%`);
+                console.log(`  Cascade Risk:  ${(final.systemState.cascadeRisk * 100).toFixed(0)}%`);
+                console.log(`  Blocked:       ${final.actionStats.blocked}`);
+                console.log(`  Modified:      ${final.actionStats.modified}`);
+                console.log(`  Assessment:    ${final.scienceState.overallAssessment}`);
+            }
+            console.log(`\n  ${"=".repeat(60)}`);
+            console.log(`  Governed MiroFish Simulation  |  NeuroVerse Governance Layer`);
+            console.log(`  ${"=".repeat(60)}`);
+            console.log(`\n  neuroverse-simulations | @neuroverseos\n`);
+            break;
+        }
+        // ============================================
+        // SCIENCE — Governed Scientific Discovery
+        // ============================================
+        case "science": {
+            console.log(`\n  SCIENCECLAW SIMULATION — Governed by NeuroVerse\n`);
+            console.log(`  Powered by ScienceClaw  |  Governed by NeuroVerse`);
+            console.log(`  ScienceClaw generates autonomous scientific discovery.`);
+            console.log(`  NeuroVerse enforces reproducibility, provenance, and research integrity.\n`);
+            console.log("  " + "=".repeat(60));
+            const { createScienceClawAdapter, generateDemoInvestigation } = await Promise.resolve().then(() => __importStar(require("../adapters/scienceclaw")));
+            const { SCIENCE_METRICS, interpretScienceState } = await Promise.resolve().then(() => __importStar(require("./metrics/science.metrics")));
+            const demo = generateDemoInvestigation();
+            const mode = args.includes("--compare") ? "compare" : "simulate";
+            if (mode === "compare") {
+                // Governed vs ungoverned comparison
+                console.log(`  Mode: GOVERNED vs UNGOVERNED COMPARISON\n`);
+                // Run governed
+                console.log(`  Running GOVERNED investigation...`);
+                const governed = createScienceClawAdapter();
+                const govResult = governed.runGovernedInvestigation(demo.artifactCycles, demo.matchesByCycle);
+                // Run ungoverned (empty policy)
+                console.log(`  Running UNGOVERNED investigation...`);
+                const ungoverned = createScienceClawAdapter({ policyText: "" });
+                const ungovResult = ungoverned.runGovernedInvestigation(demo.artifactCycles, demo.matchesByCycle);
+                // Print comparison
+                console.log(`\n  COMPARISON: Governed vs Ungoverned Discovery`);
+                console.log("  " + "=".repeat(60));
+                console.log(`  ${"Metric".padEnd(30)} ${"Governed".padEnd(15)} ${"Ungoverned".padEnd(15)} ${"Delta"}`);
+                console.log("  " + "-".repeat(75));
+                const metrics = [
+                    ["Trust (Reproducibility)", govResult.finalState.trust, ungovResult.finalState.trust],
+                    ["Polarization (Fragmentation)", govResult.finalState.polarization, ungovResult.finalState.polarization],
+                    ["Outrage (Publication Pressure)", govResult.finalState.outrage, ungovResult.finalState.outrage],
+                    ["Cascade Risk (False Positives)", govResult.finalState.cascadeRisk, ungovResult.finalState.cascadeRisk],
+                    ["Amplification (Citation Echo)", govResult.finalState.amplification, ungovResult.finalState.amplification],
+                ];
+                for (const [label, gov, ungov] of metrics) {
+                    const delta = gov - ungov;
+                    const deltaStr = `${delta > 0 ? "+" : ""}${(delta * 100).toFixed(0)}`;
+                    console.log(`  ${label.padEnd(30)} ${(gov * 100).toFixed(0).padStart(5)}%         ${(ungov * 100).toFixed(0).padStart(5)}%         ${deltaStr.padStart(5)}`);
+                }
+                console.log(`\n  ${"".padEnd(30)} ${"Governed".padEnd(15)} ${"Ungoverned"}`);
+                console.log("  " + "-".repeat(60));
+                console.log(`  ${"Verdict".padEnd(30)} ${govResult.verdict.padEnd(15)} ${ungovResult.verdict}`);
+                console.log(`  ${"Cycles".padEnd(30)} ${String(govResult.totalCycles).padEnd(15)} ${ungovResult.totalCycles}`);
+                console.log(`  ${"Artifacts Blocked".padEnd(30)} ${String(govResult.actionGovernance.blocked).padEnd(15)} ${ungovResult.actionGovernance.blocked}`);
+                console.log(`  ${"Interventions".padEnd(30)} ${String(govResult.dynamicsGovernance.totalInterventions).padEnd(15)} ${ungovResult.dynamicsGovernance.totalInterventions}`);
+                // Science state interpretation — side by side
+                const sciState = govResult.finalScienceState;
+                const ungovSciState = ungovResult.finalScienceState;
+                console.log(`\n  SCIENCE STATE`);
+                console.log("  " + "-".repeat(70));
+                console.log(`  ${"".padEnd(30)} ${"Governed".padEnd(20)} ${"Ungoverned"}`);
+                console.log("  " + "-".repeat(70));
+                console.log(`  ${"Hypothesis Fragmentation".padEnd(30)} ${sciState.hypothesisFragmentation.padEnd(20)} ${ungovSciState.hypothesisFragmentation}`);
+                console.log(`  ${"Publication Pressure".padEnd(30)} ${sciState.publicationPressure.padEnd(20)} ${ungovSciState.publicationPressure}`);
+                console.log(`  ${"Reproducibility".padEnd(30)} ${sciState.reproducibilityConfidence.padEnd(20)} ${ungovSciState.reproducibilityConfidence}`);
+                console.log(`  ${"Citation Health".padEnd(30)} ${sciState.citationHealth.padEnd(20)} ${ungovSciState.citationHealth}`);
+                console.log(`  ${"False Positive Risk".padEnd(30)} ${sciState.falsePositiveRisk.padEnd(20)} ${ungovSciState.falsePositiveRisk}`);
+                console.log(`  ${"Discovery Velocity".padEnd(30)} ${sciState.discoveryVelocity.padEnd(20)} ${ungovSciState.discoveryVelocity}`);
+                console.log(`\n  Governed:    ${sciState.overallAssessment}`);
+                console.log(`  Ungoverned:  ${ungovSciState.overallAssessment}`);
+                console.log(`\n  This simulation was generated by ScienceClaw.`);
+                console.log(`  NeuroVerse governance altered the research trajectory in real time.`);
+            }
+            else {
+                // Single governed investigation
+                console.log(`  Mode: GOVERNED INVESTIGATION\n`);
+                console.log(`  Running governed investigation (${demo.artifactCycles.length} artifact cycles)...\n`);
+                const adapter = createScienceClawAdapter({
+                    onCycleComplete: (result) => {
+                        const state = result.scienceState;
+                        const flags = result.riskFlags.length > 0 ? ` [${result.riskFlags.length} flags]` : "";
+                        console.log(`  Cycle ${String(result.cycle).padEnd(3)} | approved: ${result.artifactsApproved} blocked: ${result.artifactsBlocked} | ${result.dynamics.trajectory}${flags}`);
+                    },
+                    onConvergence: (cycle, assessment) => {
+                        console.log(`\n  >>> CONVERGENCE at cycle ${cycle}: ${assessment}`);
+                    },
+                    onHalt: (reason, cycle) => {
+                        console.log(`\n  >>> HALTED at cycle ${cycle}: ${reason}`);
+                    },
+                });
+                const result = adapter.runGovernedInvestigation(demo.artifactCycles, demo.matchesByCycle);
+                // State timeline
+                console.log(`\n  STATE EVOLUTION`);
+                console.log("  " + "-".repeat(70));
+                console.log(`  ${"Cycle".padEnd(8)} ${"Trust".padEnd(10)} ${"Fragment".padEnd(10)} ${"Pressure".padEnd(10)} ${"Cascade".padEnd(10)} ${"Trajectory"}`);
+                for (const snap of result.stateTimeline) {
+                    const round = result.cycles.find(c => c.cycle === snap.round);
+                    console.log(`  ${String(snap.round).padEnd(8)} ${(snap.trust * 100).toFixed(0).padStart(4)}%     ${(snap.polarization * 100).toFixed(0).padStart(4)}%     ${(snap.outrage * 100).toFixed(0).padStart(4)}%     ${(snap.cascadeRisk * 100).toFixed(0).padStart(4)}%     ${round?.dynamics.trajectory ?? "-"}`);
+                }
+                // Summary
+                console.log(`\n  INVESTIGATION SUMMARY`);
+                console.log("  " + "=".repeat(50));
+                console.log(`  Verdict:          ${result.verdict.toUpperCase()}`);
+                console.log(`  Cycles:           ${result.totalCycles}`);
+                console.log(`  Artifacts:        ${result.actionGovernance.totalEvaluations} evaluated`);
+                console.log(`    Approved:       ${result.actionGovernance.approved}`);
+                console.log(`    Blocked:        ${result.actionGovernance.blocked}`);
+                console.log(`    Modified:       ${result.actionGovernance.modified}`);
+                console.log(`  Interventions:    ${result.dynamicsGovernance.totalInterventions}`);
+                console.log(`    Propagation:    ${result.dynamicsGovernance.propagationLimits}`);
+                console.log(`    Amplification:  ${result.dynamicsGovernance.amplificationDampens}`);
+                console.log(`    Cascade Break:  ${result.dynamicsGovernance.cascadeBreakers}`);
+                console.log(`    Trust Boost:    ${result.dynamicsGovernance.trustBoosts}`);
+                console.log(`    Cooling:        ${result.dynamicsGovernance.coolingPeriods}`);
+                // Final science state
+                console.log(`\n  FINAL SCIENCE STATE`);
+                console.log("  " + "-".repeat(50));
+                const sciState = result.finalScienceState;
+                console.log(`  ${sciState.overallAssessment}`);
+                console.log(`  Reproducibility: ${sciState.reproducibilityConfidence}`);
+                console.log(`  Citation Health:  ${sciState.citationHealth}`);
+                console.log(`  False Positives:  ${sciState.falsePositiveRisk}`);
+            }
+            console.log(`\n  ${"=".repeat(60)}`);
+            console.log(`  Powered by ScienceClaw. Governed by NeuroVerse.`);
+            console.log(`  ${"=".repeat(60)}`);
+            console.log(`\n  neuroverse-simulations | @neuroverseos\n`);
+            break;
+        }
+        case "enforce": {
+            // ==============================================
+            // POLICY ENFORCEMENT — Iterative Governance Lab
+            //
+            // "Design rules. Run reality. See what changes."
+            //
+            // Same scenario, different rules, measurable divergence.
+            // ==============================================
+            const { createEnforcementSession, formatEnforcementReport, exportEnforcementReportJSON, formatGuidedNextSteps, formatPolicyDiagnostics, formatRuleImpactAttribution, detectSystemArchetype, createSavedExperiment, formatMultiPatchComparison, loadExperimentLibrary, formatExperimentLineage, formatSimilarExperiments, formatBestKnownStrategy, governedDetectArchetype, governedSynthesizeStrategy, governedFindSimilar } = await Promise.resolve().then(() => __importStar(require("./policyEnforcement")));
+            const { createSavedWorld, forkWorld, loadWorldFromFile } = await Promise.resolve().then(() => __importStar(require("./worldStorage")));
+            const { parseRulesFromText, validatePolicy, policyToWorld, applyQuickFix } = await Promise.resolve().then(() => __importStar(require("./policyEngine")));
+            const presetArg = (args[1] && !args[1].startsWith("--")) ? args[1] : "trading";
+            const outputJson = args.includes("--json");
+            const outputFile = args.find(a => a.startsWith("--output="))?.split("=")[1];
+            // Support multiple --patch flags: --patch POL-001 --patch POL-002
+            const patchDiagIds = [];
+            for (let i = 0; i < args.length; i++) {
+                if (args[i] === "--patch" && args[i + 1] && !args[i + 1].startsWith("--")) {
+                    patchDiagIds.push(args[i + 1]);
+                }
+                else if (args[i].startsWith("--patch=")) {
+                    patchDiagIds.push(args[i].split("=")[1]);
+                }
+            }
+            const patchDiagId = patchDiagIds[0];
+            const compareMode = args.includes("--compare");
+            const saveExperiment = args.includes("--save");
+            const saveLabel = args.find(a => a.startsWith("--save="))?.split("=")[1];
+            // Accept .json world files AND .txt/.md policy documents
+            const inputFiles = args.filter(a => (a.endsWith(".json") || a.endsWith(".txt") || a.endsWith(".md")) && a !== outputFile);
+            const worldFiles = inputFiles.filter(a => a.endsWith(".json"));
+            const policyDocFiles = inputFiles.filter(a => a.endsWith(".txt") || a.endsWith(".md"));
+            console.log(`\n  POLICY ENFORCEMENT SYSTEM`);
+            console.log(`  ${"=".repeat(60)}`);
+            console.log(`  Design rules. Run reality. See what changes.\n`);
+            console.log(`  NeuroVerse is a control layer. You define the rules.`);
+            console.log(`  The simulation shows what happens when those rules are enforced.\n`);
+            // Resolve the base scenario
+            let baseRequest;
+            let basePaths;
+            let baseWorldDef;
+            let scenarioTitle;
+            if (presetArg === "trading" || presetArg === "flash_crash") {
+                baseRequest = governedSimulation_1.TRADING_DEMO.scenario;
+                basePaths = [...governedSimulation_1.TRADING_DEMO.paths];
+                baseWorldDef = governedSimulation_1.TRADING_DEMO.world;
+                scenarioTitle = "Flash Crash — Algorithmic Cascade";
+            }
+            else {
+                const template = scenarioCapsule_1.SCENARIO_TEMPLATES[presetArg];
+                if (!template || !template.world?.inline_definition) {
+                    console.error(`  Unknown preset: ${presetArg}`);
+                    console.error(`  Available: trading, ${Object.keys(scenarioCapsule_1.SCENARIO_TEMPLATES).join(", ")}`);
+                    process.exit(1);
+                }
+                baseRequest = {
+                    scenario: template.scenario,
+                    stakeholders: template.stakeholders,
+                    assumptions: template.assumptions,
+                    constraints: template.constraints,
+                    depth: "full",
+                    swarm: { enabled: true, rounds: 5, reaction_model: "mixed" },
+                };
+                basePaths = [
+                    {
+                        id: "path_primary",
+                        label: "Primary Response",
+                        description: "The most likely course of action given the scenario",
+                        projected_outcome: "Moderate disruption with cascading effects",
+                        probability: 0.6,
+                        risk: "high",
+                        tradeoffs: ["Speed vs. thoroughness", "Short-term vs. long-term"],
+                        benefits_stakeholders: template.stakeholders.filter((s) => s.disposition === "supportive").map((s) => s.id),
+                        harms_stakeholders: template.stakeholders.filter((s) => s.disposition === "hostile").map((s) => s.id),
+                    },
+                    {
+                        id: "path_defensive",
+                        label: "Defensive Posture",
+                        description: "Conservative approach prioritizing stability over opportunity",
+                        projected_outcome: "Reduced damage but slower recovery",
+                        probability: 0.7,
+                        risk: "moderate",
+                        tradeoffs: ["Safety vs. opportunity cost", "Coordination cost vs. independence"],
+                        benefits_stakeholders: template.stakeholders.filter((s) => s.disposition !== "hostile").map((s) => s.id),
+                        harms_stakeholders: [],
+                    },
+                ];
+                baseWorldDef = template.world.inline_definition;
+                scenarioTitle = template.title;
+            }
+            console.log(`  Scenario: ${scenarioTitle}`);
+            // Create session
+            const session = createEnforcementSession(scenarioTitle, baseRequest, basePaths);
+            // Convert policy documents (.txt/.md) to world files
+            const convertedWorlds = [];
+            if (policyDocFiles.length > 0) {
+                console.log(`  Converting ${policyDocFiles.length} policy document(s) to world files...\n`);
+                for (const docFile of policyDocFiles) {
+                    try {
+                        let docText = fs.readFileSync(docFile, "utf-8");
+                        // --patch: auto-apply a quick fix before converting
+                        if (patchDiagId) {
+                            const preParsed = parseRulesFromText(docText);
+                            const preHealth = validatePolicy(preParsed);
+                            const targetDiag = preHealth.diagnostics.find(d => d.id === patchDiagId);
+                            if (targetDiag?.quickFix) {
+                                console.log(`  Applying fix ${patchDiagId}: ${targetDiag.quickFix.label}`);
+                                docText = applyQuickFix(docText, targetDiag.quickFix);
+                                console.log(`  Patched. Running with fixed rules.\n`);
+                            }
+                            else if (targetDiag) {
+                                console.log(`  ${patchDiagId} found but has no quick fix available.\n`);
+                            }
+                            else {
+                                console.log(`  ${patchDiagId} not found in diagnostics for ${docFile}.\n`);
+                            }
+                        }
+                        const parsed = parseRulesFromText(docText);
+                        const health = validatePolicy(parsed);
+                        const worldDef = policyToWorld(parsed);
+                        const docName = docFile.replace(/^.*[\\/]/, "").replace(/\.\w+$/, "");
+                        const world = createSavedWorld(docName, worldDef, presetArg, { description: `Generated from ${docFile}` });
+                        console.log(`  ${docFile} → "${docName}"`);
+                        console.log(`    World: ${worldDef.invariants.length} invariants, ${worldDef.gates.length} gates`);
+                        // GitHub-style policy review — show diagnostics with quick fixes
+                        console.log(formatPolicyDiagnostics(health, parsed, docFile));
+                        // If errors would block simulation, warn but continue
+                        if (!health.canSimulate) {
+                            console.error(`  ✗ ${docFile} has blocking errors — skipping.`);
+                            console.error(`  Fix the issues above and run again.\n`);
+                            continue;
+                        }
+                        convertedWorlds.push(world);
+                    }
+                    catch (e) {
+                        console.error(`  Failed to convert ${docFile}: ${e.message}`);
+                    }
+                }
+            }
+            // Build ordered list of worlds to test: JSON files first, then converted docs
+            const worldsToRun = [];
+            for (const jsonFile of worldFiles) {
+                try {
+                    const w = await loadWorldFromFile(jsonFile);
+                    worldsToRun.push({ label: jsonFile, world: w });
+                }
+                catch (e) {
+                    console.error(`  Failed to load ${jsonFile}: ${e.message}`);
+                }
+            }
+            for (const cw of convertedWorlds) {
+                worldsToRun.push({ label: cw.name, world: cw });
+            }
+            // If user provided files (JSON or docs), run them. Otherwise, run progressive rule sets.
+            if (worldsToRun.length > 0) {
+                console.log(`  Running ${worldsToRun.length} world(s)...\n`);
+                for (let i = 0; i < worldsToRun.length; i++) {
+                    try {
+                        const world = worldsToRun[i].world;
+                        console.log(`  Run ${i + 1}: "${world.name}" (${world.world.invariants.length} rules, ${(world.world.gates ?? []).length} gates)`);
+                        const run = await session.run(world);
+                        console.log(`    → Stability: ${(run.result.governed.metrics.stabilityScore * 100).toFixed(0)}%  Collapse: ${(run.result.governed.metrics.collapseProbability * 100).toFixed(0)}%  Effectiveness: ${(run.result.comparison.governanceEffectiveness * 100).toFixed(0)}%`);
+                    }
+                    catch (e) {
+                        console.error(`  Failed to run "${worldsToRun[i].label}": ${e.message}`);
+                    }
+                }
+            }
+            else {
+                // Progressive enforcement: no rules → light rules → full rules
+                console.log(`  Running progressive enforcement (3 iterations)...\n`);
+                // Run 1: No rules (baseline world)
+                const noRulesWorld = createSavedWorld("No Rules", { thesis: baseWorldDef.thesis, state_variables: baseWorldDef.state_variables ?? [], invariants: [], gates: [] }, presetArg, { description: "Baseline — no governance rules applied" });
+                console.log(`  Run 1: "No Rules" (0 invariants, 0 gates)`);
+                const run1 = await session.run(noRulesWorld);
+                console.log(`    → Stability: ${(run1.result.governed.metrics.stabilityScore * 100).toFixed(0)}%  Collapse: ${(run1.result.governed.metrics.collapseProbability * 100).toFixed(0)}%  Effectiveness: ${(run1.result.comparison.governanceEffectiveness * 100).toFixed(0)}%`);
+                // Run 2: Light rules (pick first 2 invariants)
+                const lightInvariants = baseWorldDef.invariants.slice(0, 2);
+                const lightWorld = createSavedWorld("Light Governance", { thesis: baseWorldDef.thesis, state_variables: baseWorldDef.state_variables ?? [], invariants: lightInvariants, gates: [] }, presetArg, { description: "Partial rules — testing minimal governance" });
+                console.log(`  Run 2: "Light Governance" (${lightInvariants.length} invariants, 0 gates)`);
+                const run2 = await session.run(lightWorld);
+                console.log(`    → Stability: ${(run2.result.governed.metrics.stabilityScore * 100).toFixed(0)}%  Collapse: ${(run2.result.governed.metrics.collapseProbability * 100).toFixed(0)}%  Effectiveness: ${(run2.result.comparison.governanceEffectiveness * 100).toFixed(0)}%`);
+                // Run 3: Full rules
+                const fullWorld = createSavedWorld("Full Governance", baseWorldDef, presetArg, { description: "All rules active — full governance enforcement" });
+                console.log(`  Run 3: "Full Governance" (${baseWorldDef.invariants.length} invariants, ${(baseWorldDef.gates ?? []).length} gates)`);
+                const run3 = await session.run(fullWorld);
+                console.log(`    → Stability: ${(run3.result.governed.metrics.stabilityScore * 100).toFixed(0)}%  Collapse: ${(run3.result.governed.metrics.collapseProbability * 100).toFixed(0)}%  Effectiveness: ${(run3.result.comparison.governanceEffectiveness * 100).toFixed(0)}%`);
+            }
+            // Generate report
+            const report = session.generateReport();
+            if (outputJson || outputFile) {
+                const json = exportEnforcementReportJSON(report);
+                if (outputFile) {
+                    fs.writeFileSync(outputFile, json, "utf-8");
+                    console.log(`\n  Report saved to: ${outputFile}`);
+                }
+                else {
+                    console.log(json);
+                }
+            }
+            else {
+                console.log(formatEnforcementReport(report));
+                // Behavioral analysis — what agents did differently under governance
+                for (const run of session.runs) {
+                    console.log(`\n  ── Behavioral Analysis: Run ${run.iteration} (${run.world.name}) ──`);
+                    console.log((0, behavioralAnalysis_1.formatBehavioralAnalysis)(run.result.behavioralAnalysis));
+                }
+                // Rule impact attribution — show which rules shaped the outcome
+                const attribution = formatRuleImpactAttribution(report);
+                if (attribution) {
+                    console.log(attribution);
+                }
+                // System archetype insight — governed AI detects system patterns
+                const archetypeGov = await governedDetectArchetype(report);
+                const archetypeInsight = archetypeGov.result;
+                if (archetypeInsight) {
+                    console.log(archetypeInsight);
+                    // Show governance trace for archetype detection
+                    console.log(`  ┌─ Governed AI ────────────────────────────────┐`);
+                    console.log(`  │ Actor: ${archetypeGov.actor.padEnd(40)}│`);
+                    console.log(`  │ Action: ${"detect_archetype".padEnd(39)}│`);
+                    console.log(`  │ Constraints: ${String(archetypeGov.trace.constraints.length).padEnd(34)}│`);
+                    console.log(`  │ Passed: ${String(archetypeGov.trace.passed).padEnd(39)}│`);
+                    console.log(`  └──────────────────────────────────────────────┘`);
+                }
+                // Load experiment library for knowledge features
+                const experimentLibrary = loadExperimentLibrary();
+                const bestRun = report.runs[report.divergence.bestIteration - 1];
+                const currentMetrics = bestRun
+                    ? { stability: bestRun.metrics.stabilityScore, effectiveness: bestRun.comparison.governanceEffectiveness }
+                    : { stability: 0, effectiveness: 0 };
+                // Find similar experiments + best known strategy — ALL governed
+                if (experimentLibrary.length > 0 && bestRun) {
+                    const runArchetype = archetypeInsight
+                        ? (archetypeInsight.match(/behaves like: (.+)/)?.[1] ?? null)
+                        : null;
+                    // Governed similarity search
+                    const similarGov = await governedFindSimilar(runArchetype, currentMetrics, experimentLibrary);
+                    if (similarGov.result) {
+                        console.log(similarGov.result);
+                        console.log(`  ┌─ Governed AI ────────────────────────────────┐`);
+                        console.log(`  │ Actor: ${similarGov.actor.padEnd(40)}│`);
+                        console.log(`  │ Action: ${"compare_experiments".padEnd(39)}│`);
+                        console.log(`  │ Constraints: ${String(similarGov.trace.constraints.length).padEnd(34)}│`);
+                        console.log(`  │ Passed: ${String(similarGov.trace.passed).padEnd(39)}│`);
+                        console.log(`  └──────────────────────────────────────────────┘`);
+                    }
+                    // Governed strategy synthesis
+                    const strategyGov = await governedSynthesizeStrategy(runArchetype, currentMetrics, experimentLibrary);
+                    if (strategyGov.result) {
+                        console.log(strategyGov.result);
+                        console.log(`  ┌─ Governed AI ────────────────────────────────┐`);
+                        console.log(`  │ Actor: ${strategyGov.actor.padEnd(40)}│`);
+                        console.log(`  │ Action: ${"synthesize_strategy".padEnd(39)}│`);
+                        console.log(`  │ Constraints: ${String(strategyGov.trace.constraints.length).padEnd(34)}│`);
+                        console.log(`  │ Passed: ${String(strategyGov.trace.passed).padEnd(39)}│`);
+                        console.log(`  └──────────────────────────────────────────────┘`);
+                    }
+                }
+                // --compare: show side-by-side before/after when used with --patch
+                if (compareMode && patchDiagId && report.runs.length >= 1) {
+                    const run = report.runs[report.runs.length - 1];
+                    const baseStab = report.runs.length > 1 ? report.runs[0].metrics.stabilityScore : 0.5;
+                    const baseEff = report.runs.length > 1 ? report.runs[0].comparison.governanceEffectiveness : 0;
+                    const baseCollapse = report.runs.length > 1 ? report.runs[0].metrics.collapseProbability : 0.15;
+                    // Multi-patch comparison
+                    if (patchDiagIds.length > 1) {
+                        // Build comparison data from available runs
+                        const patchResults = patchDiagIds.map((pid, idx) => {
+                            const patchRun = idx < report.runs.length ? report.runs[idx] : run;
+                            return {
+                                patchId: pid,
+                                stability: patchRun.metrics.stabilityScore,
+                                effectiveness: patchRun.comparison.governanceEffectiveness,
+                                collapse: patchRun.metrics.collapseProbability,
+                            };
+                        });
+                        console.log(formatMultiPatchComparison(patchResults, {
+                            stability: baseStab,
+                            effectiveness: baseEff,
+                            collapse: baseCollapse,
+                        }));
+                    }
+                    else {
+                        // Single patch comparison
+                        console.log("  BEFORE vs AFTER (--compare)");
+                        console.log("  " + "-".repeat(70));
+                        console.log(`  Patch applied: ${patchDiagId}`);
+                        console.log("");
+                        console.log("  Metric               Before (baseline)    After (patched)");
+                        console.log("  " + "─".repeat(60));
+                        console.log(`  Stability             ${(baseStab * 100).toFixed(0).padStart(3)}%                  ${(run.metrics.stabilityScore * 100).toFixed(0).padStart(3)}%`);
+                        console.log(`  Effectiveness         ${(baseEff * 100).toFixed(0).padStart(3)}%                  ${(run.comparison.governanceEffectiveness * 100).toFixed(0).padStart(3)}%`);
+                        console.log(`  Collapse risk         ${(baseCollapse * 100).toFixed(0).padStart(3)}%                  ${(run.metrics.collapseProbability * 100).toFixed(0).padStart(3)}%`);
+                        const stabDelta = run.metrics.stabilityScore - baseStab;
+                        const effDelta = run.comparison.governanceEffectiveness - baseEff;
+                        console.log("");
+                        console.log(`  Net change: ${stabDelta >= 0 ? "+" : ""}${(stabDelta * 100).toFixed(0)} stability, ${effDelta >= 0 ? "+" : ""}${(effDelta * 100).toFixed(0)} effectiveness`);
+                        if (stabDelta > 0 && effDelta > 0) {
+                            console.log("  The fix improved both dimensions. Apply it permanently.");
+                        }
+                        else if (stabDelta > 0 && effDelta <= 0) {
+                            console.log("  Stability improved but effectiveness didn't. The fix may be too conservative.");
+                        }
+                        else if (stabDelta <= 0 && effDelta > 0) {
+                            console.log("  Effectiveness improved but stability dropped. The fix may need guardrails.");
+                        }
+                        console.log("");
+                    }
+                }
+                // --save: persist this experiment with lineage tracking
+                if (saveExperiment || saveLabel) {
+                    const rulesFile = policyDocFiles.length > 0 ? policyDocFiles[0] : null;
+                    // Find parent experiment — most recent experiment for same scenario
+                    const parentExp = experimentLibrary.length > 0
+                        ? experimentLibrary.filter(e => e.scenario === report.scenario).pop() ?? null
+                        : null;
+                    const experiment = createSavedExperiment(report, rulesFile, patchDiagIds, parentExp);
+                    const savePath = saveLabel
+                        ? `experiments/${saveLabel}.json`
+                        : `experiments/${experiment.id}.json`;
+                    try {
+                        fs.mkdirSync("experiments", { recursive: true });
+                        fs.writeFileSync(savePath, JSON.stringify(experiment, null, 2));
+                        console.log("");
+                        console.log("  EXPERIMENT SAVED");
+                        console.log("  " + "-".repeat(70));
+                        console.log(`  Saved to: ${savePath}`);
+                        console.log(`  ID: ${experiment.id}`);
+                        console.log(`  Scenario: ${experiment.scenario}`);
+                        console.log(`  Generation: ${experiment.lineage.generation}`);
+                        console.log(`  Stability: ${(experiment.metrics.stability * 100).toFixed(0)}%  Effectiveness: ${(experiment.metrics.effectiveness * 100).toFixed(0)}%`);
+                        if (experiment.archetype) {
+                            console.log(`  Archetype: ${experiment.archetype}`);
+                        }
+                        if (experiment.lineage.parentId) {
+                            const imp = experiment.lineage.improvementFromParent;
+                            console.log(`  Derived from: ${experiment.lineage.parentId}`);
+                            console.log(`  Improvement: ${imp.stability >= 0 ? "+" : ""}${(imp.stability * 100).toFixed(0)} stability, ${imp.effectiveness >= 0 ? "+" : ""}${(imp.effectiveness * 100).toFixed(0)} effectiveness`);
+                            if (experiment.lineage.patchesFromParent.length > 0) {
+                                console.log(`  Patches applied: ${experiment.lineage.patchesFromParent.join(", ")}`);
+                            }
+                        }
+                        // Show lineage chain
+                        const updatedLibrary = [...experimentLibrary, experiment];
+                        console.log(formatExperimentLineage(experiment, updatedLibrary));
+                        console.log("  Compare experiments later:");
+                        console.log(`    npx nv-sim enforce trading --compare-experiments ${savePath}`);
+                        console.log("");
+                    }
+                    catch {
+                        console.log(`\n  Could not save experiment to ${savePath}`);
+                    }
+                }
+                // Show guided next steps (skip for JSON output)
+                const usedCustomFiles = inputFiles.length > 0;
+                console.log(await formatGuidedNextSteps(report, usedCustomFiles));
+            }
+            break;
+        }
         case "help":
         case "--help":
         case "-h":
@@ -558,15 +1562,38 @@ async function main() {
                            --compare to test across multiple worlds
     scenarios              List all available scenarios
     worlds <a> <b>         Same agents, different rule environments
+    enforce [preset]       Policy enforcement lab — iterative rule testing
+                           Run same scenario with different rules, see divergence
+                           --json to output JSON report
+                           --output=file.json to save report
+                           Pass world files: nv-sim enforce trading a.json b.json
     chaos [preset]         Stress test — find the breaking point
     visualize              Interactive scenario control platform
     serve | govern         Start local governance runtime
                            --port N (default: 3456)
     run <simulator>        Run external simulator with governance
                            e.g., nv-sim run mirofish
+    radiant [preset]       Prime Radiant — full policy enforcement system
+                           Dual-layer: govern() + governDynamics()
+                           --world     MODE 1: build & validate world
+                           --compare   MODE 3: decision intelligence (N options)
+                           (default)   MODE 2: governed simulation with comparison
+    mirofish               MiroFish agent simulation with governance
+                           --compare   Governed vs ungoverned comparison
+    science                Science mode — governed autonomous discovery
+                           --compare   Governed vs ungoverned comparison
+    world-from-doc <file>  Generate world rules from a document
+                           --output file.json --id my-world
     analyze <file>         Analyze a simulation from file or stdin
     presets                List available preset scenarios
-    help                   Show this help message
+
+  WORLD MANAGEMENT:
+
+    world:save <preset> [output.json]   Save a world as JSON file
+                                        --name="My World Name"
+    world:load <file.json>              Inspect a saved world file
+    world:list                          List all available worlds
+    world:compare <a.json> <b.json>     Compare two saved world files
 
   PRESETS:
 
@@ -590,8 +1617,38 @@ async function main() {
     npx nv-sim scenario bank_run --compare        # Cross-world comparison
     npx nv-sim scenarios                          # List all scenarios
     npx nv-sim analyze simulation.json
+    npx nv-sim world-from-doc policy.md       # Generate world from document
+    npx nv-sim world-from-doc rules.txt --output world.json
+    npx nv-sim world:save trading my-world.json   # Save world to file
+    npx nv-sim world:load my-world.json           # Inspect a saved world
+    npx nv-sim world:compare a.json b.json        # Compare two world files
+
+  POLICY ENFORCEMENT:
+
+    npx nv-sim enforce                             # Progressive: no rules → light → full
+    npx nv-sim enforce strait_of_hormuz            # Same, with geopolitical preset
+    npx nv-sim enforce trading a.json b.json       # Compare custom world files
+    npx nv-sim enforce --output=report.json        # Save report as JSON
+
+  PRIME RADIANT:
+
+    npx nv-sim radiant                             # Full governed simulation
+    npx nv-sim radiant university_crisis           # University crisis preset
+    npx nv-sim radiant financial_crisis --compare  # Decision intelligence mode
+    npx nv-sim radiant geopolitical_crisis --world # World builder mode
+    npx nv-sim radiant scientific_discovery        # Science discovery preset
+
+  MIROFISH MODE:
 
-  Simulate the future. Govern the outcomes.
+    npx nv-sim mirofish                            # Governed agent simulation
+    npx nv-sim mirofish --compare                  # Governed vs ungoverned comparison
+
+  SCIENCE MODE:
+
+    npx nv-sim science                             # Governed investigation demo
+    npx nv-sim science --compare                   # Governed vs ungoverned comparison
+
+  Design rules. Run reality. See what changes.
 `);
             break;
         }
@@ -699,18 +1756,20 @@ function printComparisonResults(result, worldId) {
             }
         }
     }
+    // Behavioral analysis — what agents did differently
+    console.log((0, behavioralAnalysis_1.formatBehavioralAnalysis)(result.behavioralAnalysis));
     // Key message
     console.log(`\n  ${"=".repeat(60)}`);
     console.log(`  NeuroVerse doesn't just stop bad actions.`);
     console.log(`  It changes the structure of the system itself.`);
     console.log(`  ${"=".repeat(60)}`);
-    console.log(`\n  Simulate the future. Govern the outcomes.`);
+    console.log(`\n  Design rules. Run reality. See what changes.`);
     console.log(`  neuroverse-simulations | @neuroverseos\n`);
 }
 // ============================================
 // WORLD COMPARISON OUTPUT
 // ============================================
-function printWorldComparisonResults(r) {
+function printWorldComparisonResults(r, impact) {
     const a = r.worldA;
     const b = r.worldB;
     const d = r.delta;
@@ -743,6 +1802,21 @@ function printWorldComparisonResults(r) {
     console.log("  " + "-".repeat(50));
     console.log(`  World A: ${a.governanceStats.engineLoaded ? "@neuroverseos/governance" : "heuristic"} — ${a.governanceStats.totalEvaluations} evals (${a.governanceStats.verdicts.allow} allow, ${a.governanceStats.verdicts.block} block, ${a.governanceStats.verdicts.pause} pause)`);
     console.log(`  World B: ${b.governanceStats.engineLoaded ? "@neuroverseos/governance" : "heuristic"} — ${b.governanceStats.totalEvaluations} evals (${b.governanceStats.verdicts.allow} allow, ${b.governanceStats.verdicts.block} block, ${b.governanceStats.verdicts.pause} pause)`);
+    // Impact analysis (when available)
+    if (impact) {
+        console.log(`\n  IMPACT ANALYSIS`);
+        console.log("  " + "=".repeat(50));
+        console.log(`  Stability delta:     ${impact.stabilityDelta}`);
+        console.log(`  Cascade risk delta:  ${impact.cascadeRiskDelta}`);
+        console.log(`  Volatility delta:    ${impact.volatilityDelta}`);
+        console.log(`  Interventions A:     ${impact.totalInterventionsA} (${impact.blockedActionsA} blocked)`);
+        console.log(`  Interventions B:     ${impact.totalInterventionsB} (${impact.blockedActionsB} blocked)`);
+        console.log(`\n  KEY FINDINGS:`);
+        for (const finding of impact.keyFindings) {
+            console.log(`    • ${finding}`);
+        }
+        console.log(`\n  Powered by ${impact.poweredBy}`);
+    }
     // Narrative
     console.log(`\n  ANALYSIS`);
     console.log("  " + "=".repeat(50));
@@ -763,7 +1837,7 @@ function printWorldComparisonResults(r) {
     console.log(`  Same agents. Different rules.`);
     console.log(`  The world shapes the outcome.`);
     console.log(`  ${"=".repeat(60)}`);
-    console.log(`\n  Simulate the future. Govern the outcomes.`);
+    console.log(`\n  Design rules. Run reality. See what changes.`);
     console.log(`  neuroverse-simulations | @neuroverseos\n`);
 }
 // ============================================
@@ -829,7 +1903,7 @@ function printChaosResults(r) {
     }
     console.log(`  Tested with nv-sim chaos (${r.runsCompleted} runs, ${(r.durationMs / 1000).toFixed(1)}s)`);
     console.log(`  ${"=".repeat(60)}`);
-    console.log(`\n  Simulate the future. Govern the outcomes.`);
+    console.log(`\n  Design rules. Run reality. See what changes.`);
     console.log(`  neuroverse-simulations | @neuroverseos\n`);
 }
 main().catch((err) => {