@neuroverseos/nv-sim 0.1.2 → 0.1.6

package/dist/engine/cli.js

@@ -51,9 +51,14 @@ const analyzer_1 = require("./analyzer");
 const api_1 = require("./api");
 const governedSimulation_1 = require("./governedSimulation");
 const chaosEngine_1 = require("./chaosEngine");
+const worldComparison_1 = require("./worldComparison");
+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 http = __importStar(require("http"));
+const child_process_1 = require("child_process");
 // ============================================
 // CLI ARGUMENT PARSING
 // ============================================
@@ -68,7 +73,8 @@ async function main() {
     }
     switch (command) {
         case "compare": {
-            const presetId = args[1] || "trading";
+            const presetId = (args[1] && !args[1].startsWith("--")) ? args[1] : "trading";
+            const narrativeEvents = (0, narrativeInjection_1.parseInjectArgs)(args);
             console.log(`\n  NV-SIM — Governed Simulation Comparison\n`);
             console.log(`  "We ran the same simulation twice.`);
             console.log(`   The only difference was the world rules."\n`);
@@ -78,7 +84,7 @@ async function main() {
             if (presetId === "trading" || presetId === "flash_crash") {
                 console.log(`  Scenario: Flash Crash — Algorithmic Cascade\n`);
                 worldId = "trading-flash-crash";
-                result = await (0, governedSimulation_1.runGovernedComparison)(governedSimulation_1.TRADING_DEMO.scenario, governedSimulation_1.TRADING_DEMO.world, governedSimulation_1.TRADING_DEMO.paths);
+                result = await (0, governedSimulation_1.runGovernedComparison)(governedSimulation_1.TRADING_DEMO.scenario, governedSimulation_1.TRADING_DEMO.world, governedSimulation_1.TRADING_DEMO.paths, narrativeEvents.length > 0 ? narrativeEvents : undefined);
             }
             else {
                 // Try to use an existing preset
@@ -126,11 +132,135 @@ async function main() {
                         harms_stakeholders: [],
                     },
                 ];
-                result = await (0, governedSimulation_1.runGovernedComparison)(request, template.world.inline_definition, paths);
+                result = await (0, governedSimulation_1.runGovernedComparison)(request, template.world.inline_definition, paths, narrativeEvents.length > 0 ? narrativeEvents : undefined);
+            }
+            if (narrativeEvents.length > 0) {
+                console.log(`\n  NARRATIVE INJECTIONS`);
+                console.log("  " + "-".repeat(50));
+                for (const ne of narrativeEvents) {
+                    console.log(`  [Round ${ne.round}] "${ne.headline}" (${ne.severity}, ${ne.propagation})`);
+                }
             }
             printComparisonResults(result, worldId);
             break;
         }
+        case "worlds": {
+            const worldAId = args[1];
+            const worldBId = args[2];
+            if (!worldAId || !worldBId) {
+                console.error("  Usage: npx nv-sim worlds <world-a> <world-b>");
+                console.error("  Example: npx nv-sim worlds trading strait_of_hormuz");
+                console.error(`  Available: trading, ${Object.keys(scenarioCapsule_1.SCENARIO_TEMPLATES).join(", ")}`);
+                process.exit(1);
+            }
+            console.log(`\n  NV-SIM — World Comparison\n`);
+            console.log(`  "Same agents. Different rules.`);
+            console.log(`   The world shapes the outcome."\n`);
+            console.log("  " + "=".repeat(60));
+            const wcResult = await (0, worldComparison_1.runWorldComparison)(worldAId, worldBId, {
+                onProgress: (label, phase) => {
+                    console.log(`  ${label}: ${phase}...`);
+                },
+            });
+            printWorldComparisonResults(wcResult);
+            break;
+        }
+        case "scenario": {
+            const scenarioId = args[1];
+            const doCompare = args.includes("--compare");
+            if (!scenarioId || scenarioId.startsWith("--")) {
+                console.error("  Usage: nv-sim scenario <scenario-id> [--compare]");
+                console.error(`  Available: ${Object.keys(scenarioLibrary_1.SCENARIO_LIBRARY).join(", ")}`);
+                console.error("  Run `nv-sim scenarios` to see all scenarios.");
+                process.exit(1);
+            }
+            const scenario = scenarioLibrary_1.SCENARIO_LIBRARY[scenarioId];
+            if (!scenario) {
+                console.error(`  Unknown scenario: ${scenarioId}`);
+                console.error(`  Available: ${Object.keys(scenarioLibrary_1.SCENARIO_LIBRARY).join(", ")}`);
+                process.exit(1);
+            }
+            console.log(`\n  NV-SIM — Scenario: ${scenario.title}\n`);
+            console.log(`  ${scenario.description}\n`);
+            console.log("  " + "=".repeat(60));
+            console.log(`  World: ${scenario.world}`);
+            console.log(`  Events:`);
+            const scenarioEvents = (0, scenarioLibrary_1.resolveScenarioEvents)(scenario);
+            for (const ev of scenarioEvents) {
+                console.log(`    [Round ${ev.round}] ${ev.headline} (${ev.severity}, ${ev.propagation})`);
+            }
+            console.log();
+            // Resolve world
+            const { resolveWorld } = await Promise.resolve().then(() => __importStar(require("./worldComparison")));
+            const resolved = resolveWorld(scenario.world);
+            const rounds = scenario.rounds ?? resolved.swarm.rounds ?? 5;
+            const request = {
+                scenario: resolved.scenario,
+                stakeholders: resolved.stakeholders,
+                assumptions: resolved.assumptions,
+                constraints: resolved.constraints,
+                depth: resolved.depth,
+                swarm: { ...resolved.swarm, rounds },
+            };
+            // Run primary scenario
+            console.log(`  Running scenario on world "${scenario.world}"...`);
+            const primaryResult = await (0, governedSimulation_1.runGovernedComparison)(request, resolved.world, resolved.paths, scenarioEvents);
+            printComparisonResults(primaryResult, scenario.world);
+            // --compare: run across additional worlds
+            if (doCompare && scenario.compareWorlds && scenario.compareWorlds.length > 0) {
+                console.log(`\n  ${"=".repeat(60)}`);
+                console.log(`  CROSS-WORLD COMPARISON`);
+                console.log(`  Running same scenario across ${scenario.compareWorlds.length} additional world(s)...\n`);
+                for (const altWorldId of scenario.compareWorlds) {
+                    const altResolved = resolveWorld(altWorldId);
+                    const altRounds = scenario.rounds ?? altResolved.swarm.rounds ?? 5;
+                    const altRequest = {
+                        scenario: altResolved.scenario,
+                        stakeholders: altResolved.stakeholders,
+                        assumptions: altResolved.assumptions,
+                        constraints: altResolved.constraints,
+                        depth: altResolved.depth,
+                        swarm: { ...altResolved.swarm, rounds: altRounds },
+                    };
+                    console.log(`  Running on world "${altWorldId}"...`);
+                    const altResult = await (0, governedSimulation_1.runGovernedComparison)(altRequest, altResolved.world, altResolved.paths, scenarioEvents);
+                    // Print condensed comparison
+                    const pm = primaryResult.governed.metrics;
+                    const am = altResult.governed.metrics;
+                    console.log(`\n  ${scenario.world} vs ${altWorldId}`);
+                    console.log("  " + "-".repeat(50));
+                    console.log(`  ${scenario.world.padEnd(25)} Stability: ${(pm.stabilityScore * 100).toFixed(0)}%  Collapse: ${(pm.collapseProbability * 100).toFixed(0)}%  Volatility: ${(pm.maxVolatility * 100).toFixed(0)}%`);
+                    console.log(`  ${altWorldId.padEnd(25)} Stability: ${(am.stabilityScore * 100).toFixed(0)}%  Collapse: ${(am.collapseProbability * 100).toFixed(0)}%  Volatility: ${(am.maxVolatility * 100).toFixed(0)}%`);
+                    const stabDiff = pm.stabilityScore - am.stabilityScore;
+                    const winner = Math.abs(stabDiff) < 0.02 ? "tie" : stabDiff > 0 ? scenario.world : altWorldId;
+                    console.log(`  More resilient: ${winner === "tie" ? "roughly equal" : winner}`);
+                }
+                console.log(`\n  Same events. Different rules. Different outcomes.`);
+            }
+            console.log(`\n  Design rules. Run reality. See what changes.`);
+            console.log(`  neuroverse-simulations | @neuroverseos\n`);
+            break;
+        }
+        case "scenarios": {
+            console.log(`\n  NV-SIM — Scenario Library\n`);
+            console.log(`  "Named stress scenarios — run a crisis, not a config."\n`);
+            console.log("  " + "=".repeat(60));
+            const grouped = (0, scenarioLibrary_1.getScenariosByCategory)();
+            for (const [category, scenarios] of Object.entries(grouped)) {
+                console.log(`\n  ${category.toUpperCase()}`);
+                console.log("  " + "-".repeat(40));
+                for (const s of scenarios) {
+                    console.log(`  ${s.id.padEnd(28)} ${s.title}`);
+                    console.log(`  ${"".padEnd(28)} ${s.description}`);
+                    console.log(`  ${"".padEnd(28)} World: ${s.world} | Events: ${s.events.length}${s.compareWorlds ? ` | Compare: ${s.compareWorlds.join(", ")}` : ""}\n`);
+                }
+            }
+            console.log("  " + "=".repeat(60));
+            console.log(`  Usage: nv-sim scenario <id>`);
+            console.log(`         nv-sim scenario <id> --compare    (cross-world comparison)`);
+            console.log(`\n  Example: nv-sim scenario taiwan_crisis --compare\n`);
+            break;
+        }
         case "analyze": {
             const filePath = args[1];
             let input;
@@ -279,47 +409,253 @@ async function main() {
         }
         case "visualize":
         case "view": {
-            const presetId = args[1] || "trading";
-            console.log(`\n  NV-SIM — Running simulation for visualization...\n`);
-            let comparisonResult;
-            if (presetId === "trading" || presetId === "flash_crash") {
-                comparisonResult = await (0, governedSimulation_1.runGovernedComparison)(governedSimulation_1.TRADING_DEMO.scenario, governedSimulation_1.TRADING_DEMO.world, governedSimulation_1.TRADING_DEMO.paths);
+            console.log(`\n  NV-SIM — Scenario Control Platform\n`);
+            const port = 3456;
+            (0, liveVisualizer_1.startInteractiveServer)(port, (url) => {
+                console.log(`  Dashboard: ${url}`);
+                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 openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+                (0, child_process_1.exec)(`${openCmd} ${url}`, () => { });
+            });
+            await new Promise(() => { }); // block forever
+            break;
+        }
+        case "serve":
+        case "govern": {
+            // Local governance runtime — external simulators POST to /api/evaluate
+            const governPort = args.includes("--port") ? parseInt(args[args.indexOf("--port") + 1], 10) : 3456;
+            console.log(`\n  NV-SIM — Local Governance Runtime\n`);
+            console.log(`  Runs on YOUR machine. No cloud. No cost.\n`);
+            console.log("  " + "=".repeat(60));
+            console.log(`  Endpoint: http://localhost:${governPort}/api/evaluate`);
+            console.log(`  Method:   POST`);
+            console.log(`  Contract: { actor, action, payload?, state?, world? }`);
+            console.log(`  Response: { decision: ALLOW|BLOCK|MODIFY, reason, evidence }`);
+            console.log("  " + "=".repeat(60));
+            (0, liveVisualizer_1.startInteractiveServer)(governPort, (url) => {
+                console.log(`\n  Server ready: ${url}`);
+                console.log(`  Governance:   ${url}/api/evaluate`);
+                console.log(`  Dashboard:    ${url}`);
+                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");
+            });
+            await new Promise(() => { }); // block forever
+            break;
+        }
+        case "run": {
+            // Run an external simulator with governance
+            const simId = args[1] ?? "mirofish";
+            const runPort = args.includes("--port") ? parseInt(args[args.indexOf("--port") + 1], 10) : 3456;
+            const noViewer = args.includes("--no-viewer");
+            console.log(`\n  NV-SIM — Governed Simulation Runner\n`);
+            console.log(`  Simulator: ${simId}`);
+            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...`);
+                // Check if we have a registry entry, otherwise try raw command
+                const adapterEntry = ar[simId];
+                if (!adapterEntry) {
+                    console.error(`  Unknown simulator: ${simId}`);
+                    console.error(`  Available: ${Object.keys(ar).join(", ")}`);
+                    console.error(`  Or provide command: nv-sim run generic --command "python sim.py"`);
+                    process.exit(1);
+                }
+                const adapterOpts = {};
+                if (args.includes("--command")) {
+                    adapterOpts.command = args[args.indexOf("--command") + 1];
+                }
+                if (args.includes("--args")) {
+                    adapterOpts.args = args[args.indexOf("--args") + 1];
+                }
+                const adapter = ca(simId, adapterOpts);
+                if (!adapter) {
+                    console.error(`  Failed to create adapter for: ${simId}`);
+                    process.exit(1);
+                }
+                let roundCount = 0;
+                adapter.on("round", (round) => {
+                    roundCount++;
+                    const actions = round.agentActions?.length ?? 0;
+                    const events = round.systemEvents?.length ?? 0;
+                    console.log(`  [round ${round.round}] ${actions} actions, ${events} events`);
+                });
+                adapter.on("complete", () => {
+                    console.log(`\n  Simulation complete. ${roundCount} rounds processed.`);
+                    console.log(`  Dashboard: http://localhost:${runPort}`);
+                    if (noViewer)
+                        process.exit(0);
+                });
+                adapter.on("error", (err) => {
+                    console.error(`  Simulator error: ${err.message}`);
+                });
+                adapter.start().then(() => {
+                    console.log(`  [2/3] Simulator started.`);
+                    console.log(`  [3/3] Streaming governed output...\n`);
+                }).catch((err) => {
+                    console.error(`  Failed to start simulator: ${err.message}`);
+                    process.exit(1);
+                });
+                // Open viewer unless --no-viewer
+                if (!noViewer) {
+                    const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+                    (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 template = scenarioCapsule_1.SCENARIO_TEMPLATES[presetId];
-                if (!template || !template.world?.inline_definition) {
-                    console.error(`  Unknown or incomplete preset: ${presetId}`);
+                const resolved = path.resolve(docPath);
+                if (!fs.existsSync(resolved)) {
+                    console.error(`\n  Error: File not found: ${resolved}\n`);
                     process.exit(1);
                 }
-                const request = {
-                    scenario: template.scenario,
-                    stakeholders: template.stakeholders,
-                    assumptions: template.assumptions,
-                    constraints: template.constraints,
-                    depth: template.depth,
-                    swarm: template.swarm,
-                };
-                const paths = [
-                    {
-                        id: "path_primary", label: "Primary Response",
-                        description: "Most likely course of action",
-                        projected_outcome: "Moderate disruption", probability: 0.6,
-                        risk: "high", tradeoffs: ["Speed vs. thoroughness"],
-                        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", projected_outcome: "Reduced damage",
-                        probability: 0.7, risk: "moderate", tradeoffs: ["Safety vs. opportunity"],
-                        benefits_stakeholders: template.stakeholders.filter(s => s.disposition !== "hostile").map(s => s.id),
-                        harms_stakeholders: [],
-                    },
-                ];
-                comparisonResult = await (0, governedSimulation_1.runGovernedComparison)(request, template.world.inline_definition, paths);
+                docText = fs.readFileSync(resolved, "utf-8");
             }
-            console.log("  Starting local visualizer...\n");
-            await startVisualizer(comparisonResult, presetId);
+            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": {
@@ -350,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":
@@ -362,13 +1556,44 @@ async function main() {
 
   COMMANDS:
 
-    compare [preset]     Run governed simulation comparison (the killer demo)
-    chaos [preset]       Stress test — find the breaking point (the viral command)
-    visualize [preset]   Launch local simulation viewer in browser
-    analyze <file>       Analyze a simulation from file or stdin
-    preset <id>          Run reasoning on a preset scenario
-    presets              List available preset scenarios
-    help                 Show this help message
+    compare [preset]       Baseline vs governed comparison (the killer demo)
+                           --inject event@round[,event@round,...]
+    scenario <id>          Run a named stress scenario
+                           --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
+
+  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:
 
@@ -379,15 +1604,51 @@ async function main() {
 
   EXAMPLES:
 
-    npx nv-sim compare                          # Run the trading demo
-    npx nv-sim chaos                            # Stress test (100 runs)
-    npx nv-sim chaos trading --runs 500         # 500 randomized runs
-    npx nv-sim visualize                        # Open local viewer
-    npx nv-sim compare strait_of_hormuz         # Run geopolitical demo
+    npx nv-sim compare                          # Baseline vs governed
+    npx nv-sim worlds trading strait_of_hormuz  # Compare two rule environments
+    npx nv-sim chaos --runs 500                 # Stress test (500 runs)
+    npx nv-sim visualize                        # Live viewer in browser
+    npx nv-sim serve                            # Start local governance runtime
+    npx nv-sim run mirofish                     # Run MiroFish with governance
+    npx nv-sim compare strait_of_hormuz         # Geopolitical demo
+    npx nv-sim compare --inject tanker_explosion@3  # With narrative shock
+    npx nv-sim compare --inject rate_cut@3,sanctions@5
+    npx nv-sim scenario taiwan_crisis             # Named scenario
+    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 preset strait_of_hormuz
+    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
 
-  Simulate the future. Govern the outcomes.
+  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:
+
+    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;
         }
@@ -480,12 +1741,103 @@ function printComparisonResults(result, worldId) {
     console.log(`  World viability:  ${gs.finalViability}${gs.worldCollapsed ? " (COLLAPSED)" : ""}`);
     console.log(`  Agents:           ${result.baseline.swarm.rounds[0]?.reactions.length ?? 0}`);
     console.log(`  Rounds:           ${result.baseline.swarm.rounds.length}`);
+    // Narrative impacts
+    if (result.narrativeImpacts && result.narrativeImpacts.length > 0) {
+        console.log(`\n  NARRATIVE IMPACTS`);
+        console.log("  " + "-".repeat(50));
+        for (const ni of result.narrativeImpacts) {
+            console.log(`  EVENT: "${ni.event.headline}" (${ni.event.severity})`);
+            for (const shift of ni.agentShifts) {
+                const arrow = shift.impactShift > 0 ? "\u2191" : shift.impactShift < 0 ? "\u2193" : "=";
+                console.log(`    ${arrow} ${shift.stakeholder_id}: impact ${shift.impactShift > 0 ? "+" : ""}${shift.impactShift.toFixed(3)}, confidence ${shift.confidenceShift > 0 ? "+" : ""}${shift.confidenceShift.toFixed(3)}`);
+            }
+            for (const effect of ni.systemEffects) {
+                console.log(`    > ${effect}`);
+            }
+        }
+    }
+    // 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, impact) {
+    const a = r.worldA;
+    const b = r.worldB;
+    const d = r.delta;
+    console.log(`\n  WORLD A — ${a.id}`);
+    console.log("  " + "=".repeat(50));
+    console.log(`  Thesis: ${a.thesis}`);
+    console.log(`  Invariants: ${a.invariantCount}  |  Gates: ${a.gateCount}`);
+    console.log(`  Trajectory:           ${a.trajectory.toUpperCase()}`);
+    console.log(`  Stability:            ${(a.metrics.stabilityScore * 100).toFixed(0)}%`);
+    console.log(`  Collapse probability: ${(a.metrics.collapseProbability * 100).toFixed(0)}%`);
+    console.log(`  Peak volatility:      ${(a.metrics.maxVolatility * 100).toFixed(0)}%`);
+    console.log(`  Coalition risks:      ${a.metrics.coalitionRisks}`);
+    console.log(`\n  WORLD B — ${b.id}`);
+    console.log("  " + "=".repeat(50));
+    console.log(`  Thesis: ${b.thesis}`);
+    console.log(`  Invariants: ${b.invariantCount}  |  Gates: ${b.gateCount}`);
+    console.log(`  Trajectory:           ${b.trajectory.toUpperCase()}`);
+    console.log(`  Stability:            ${(b.metrics.stabilityScore * 100).toFixed(0)}%`);
+    console.log(`  Collapse probability: ${(b.metrics.collapseProbability * 100).toFixed(0)}%`);
+    console.log(`  Peak volatility:      ${(b.metrics.maxVolatility * 100).toFixed(0)}%`);
+    console.log(`  Coalition risks:      ${b.metrics.coalitionRisks}`);
+    console.log(`\n  DELTA`);
+    console.log("  " + "=".repeat(50));
+    const stabArrow = d.stabilityDiff > 0 ? "A more stable" : d.stabilityDiff < 0 ? "B more stable" : "equal";
+    console.log(`  Stability:      ${d.stabilityDiff > 0 ? "+" : ""}${d.stabilityDiff.toFixed(1)} pp  (${stabArrow})`);
+    console.log(`  Volatility:     ${d.volatilityDiff > 0 ? "+" : ""}${d.volatilityDiff.toFixed(1)} pp`);
+    console.log(`  Coalition risk: ${d.coalitionRiskDiff > 0 ? "+" : ""}${d.coalitionRiskDiff}`);
+    console.log(`  Collapse:       ${d.collapseDiff > 0 ? "+" : ""}${d.collapseDiff.toFixed(1)} pp`);
+    console.log(`\n  GOVERNANCE ENGINE`);
+    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));
+    const words = d.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(`  Same agents. Different rules.`);
+    console.log(`  The world shapes the outcome.`);
+    console.log(`  ${"=".repeat(60)}`);
+    console.log(`\n  Design rules. Run reality. See what changes.`);
     console.log(`  neuroverse-simulations | @neuroverseos\n`);
 }
 // ============================================
@@ -551,252 +1903,9 @@ 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`);
 }
-// ============================================
-// LOCAL VISUALIZER
-// ============================================
-async function startVisualizer(data, scenarioId) {
-    const html = buildVisualizerHtml(data, scenarioId);
-    const server = http.createServer((_req, res) => {
-        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-        res.end(html);
-    });
-    const port = 3456;
-    server.listen(port, () => {
-        const url = `http://localhost:${port}`;
-        console.log(`  Visualizer running at ${url}\n`);
-        console.log("  Press Ctrl+C to stop.\n");
-        // Try to open browser
-        const { exec } = require("child_process");
-        const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-        exec(`${openCmd} ${url}`, () => { });
-    });
-}
-function buildVisualizerHtml(data, scenarioId) {
-    const rounds = data.baseline.swarm.rounds;
-    const governedRounds = data.governed.swarm.rounds;
-    // Build per-round data for charts
-    const roundData = rounds.map((r, i) => {
-        const gr = governedRounds[i];
-        const blAvg = r.reactions.reduce((s, rx) => s + rx.impact, 0) / r.reactions.length;
-        const gvAvg = gr ? gr.reactions.reduce((s, rx) => s + rx.impact, 0) / gr.reactions.length : 0;
-        const blVol = Math.max(...r.reactions.map(rx => Math.abs(rx.impact)));
-        const gvVol = gr ? Math.max(...gr.reactions.map(rx => Math.abs(rx.impact))) : 0;
-        return { round: i, blAvg, gvAvg, blVol, gvVol };
-    });
-    // Agent data
-    const agents = rounds[0]?.reactions.map(r => r.stakeholder_id) ?? [];
-    const agentTimelines = agents.map(agentId => ({
-        id: agentId,
-        baseline: rounds.map(r => {
-            const rx = r.reactions.find(a => a.stakeholder_id === agentId);
-            return rx ? rx.impact : 0;
-        }),
-        governed: governedRounds.map(r => {
-            const rx = r.reactions.find(a => a.stakeholder_id === agentId);
-            return rx ? rx.impact : 0;
-        }),
-    }));
-    // Governance interventions per round
-    const dynamics = governedRounds.map(r => r.emergent_dynamics ?? []);
-    const jsonData = JSON.stringify({ roundData, agentTimelines, dynamics, scenarioId, data });
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>NV-SIM Visualizer — ${scenarioId}</title>
-<style>
-  * { margin: 0; padding: 0; box-sizing: border-box; }
-  body { font-family: 'SF Mono', 'Fira Code', 'Cascadia Code', monospace; background: #0a0a0a; color: #e0e0e0; padding: 24px; }
-  h1 { font-size: 18px; color: #fff; margin-bottom: 4px; }
-  .subtitle { color: #888; font-size: 13px; margin-bottom: 24px; }
-  .grid { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; margin-bottom: 20px; }
-  .card { background: #141414; border: 1px solid #222; border-radius: 8px; padding: 16px; }
-  .card h2 { font-size: 13px; color: #888; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 12px; }
-  .metric { display: flex; justify-content: space-between; padding: 4px 0; font-size: 13px; }
-  .metric .label { color: #999; }
-  .metric .value { color: #fff; font-weight: 600; }
-  .metric .value.good { color: #4ade80; }
-  .metric .value.bad { color: #f87171; }
-  .metric .value.neutral { color: #fbbf24; }
-  canvas { width: 100% !important; height: 200px !important; }
-  .full-width { grid-column: 1 / -1; }
-  .agent-row { display: flex; align-items: center; gap: 8px; padding: 6px 0; border-bottom: 1px solid #1a1a1a; font-size: 12px; }
-  .agent-name { width: 160px; color: #999; flex-shrink: 0; }
-  .bar-container { flex: 1; display: flex; gap: 2px; align-items: center; }
-  .bar { height: 20px; border-radius: 3px; min-width: 1px; transition: width 0.3s; }
-  .bar.baseline { background: #ef4444; opacity: 0.6; }
-  .bar.governed { background: #4ade80; opacity: 0.8; }
-  .dynamics-list { font-size: 12px; color: #999; }
-  .dynamics-list .round-label { color: #fbbf24; font-weight: 600; }
-  .dynamics-list p { padding: 3px 0; }
-  .tag { display: inline-block; padding: 2px 8px; border-radius: 4px; font-size: 11px; margin: 2px; }
-  .tag.allow { background: #052e16; color: #4ade80; }
-  .tag.block { background: #2d0606; color: #f87171; }
-  .tag.pause { background: #2d2006; color: #fbbf24; }
-  .footer { text-align: center; color: #444; font-size: 12px; padding: 24px 0; }
-  .sparkline { display: flex; align-items: flex-end; gap: 1px; height: 40px; }
-  .spark-bar { flex: 1; border-radius: 2px 2px 0 0; min-width: 3px; }
-</style>
-</head>
-<body>
-<h1>NV-SIM Visualizer</h1>
-<div class="subtitle">${scenarioId} — Baseline vs Governed Comparison</div>
-
-<div class="grid">
-  <div class="card">
-    <h2>Simulation A — Baseline (No Governance)</h2>
-    <div id="baseline-metrics"></div>
-  </div>
-  <div class="card">
-    <h2>Simulation B — Governed (World Rules)</h2>
-    <div id="governed-metrics"></div>
-  </div>
-
-  <div class="card">
-    <h2>Impact Timeline — Average Impact Per Round</h2>
-    <canvas id="impactChart"></canvas>
-  </div>
-  <div class="card">
-    <h2>Volatility Timeline — Peak Volatility Per Round</h2>
-    <canvas id="volatilityChart"></canvas>
-  </div>
-
-  <div class="card full-width">
-    <h2>Agent Behavior — Baseline vs Governed (Final Round)</h2>
-    <div id="agent-bars"></div>
-  </div>
-
-  <div class="card">
-    <h2>Governance Interventions</h2>
-    <div id="dynamics" class="dynamics-list"></div>
-  </div>
-  <div class="card">
-    <h2>Governance Engine Stats</h2>
-    <div id="engine-stats"></div>
-  </div>
-</div>
-
-<div class="footer">
-  nv-sim visualize — local simulation inspector<br>
-  neuroverse-simulations | @neuroverseos
-</div>
-
-<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.4/dist/chart.umd.min.js"><\/script>
-<script>
-const SIM = ${jsonData};
-
-// Metrics
-function renderMetrics(containerId, metrics, trajectory) {
-  const el = document.getElementById(containerId);
-  const rows = [
-    ['Trajectory', trajectory.toUpperCase(), trajectory === 'converging' || trajectory === 'stabilizing' ? 'good' : trajectory === 'escalating' ? 'bad' : 'neutral'],
-    ['Collapse Probability', (metrics.collapseProbability * 100).toFixed(0) + '%', metrics.collapseProbability < 0.2 ? 'good' : metrics.collapseProbability > 0.5 ? 'bad' : 'neutral'],
-    ['Stability', (metrics.stabilityScore * 100).toFixed(0) + '%', metrics.stabilityScore > 0.7 ? 'good' : metrics.stabilityScore < 0.4 ? 'bad' : 'neutral'],
-    ['Peak Volatility', (metrics.maxVolatility * 100).toFixed(0) + '%', metrics.maxVolatility < 0.4 ? 'good' : metrics.maxVolatility > 0.7 ? 'bad' : 'neutral'],
-    ['Coalition Risks', metrics.coalitionRisks, metrics.coalitionRisks === 0 ? 'good' : 'bad'],
-    ['Polarization Events', metrics.polarizationEvents, metrics.polarizationEvents === 0 ? 'good' : 'neutral'],
-  ];
-  el.innerHTML = rows.map(([label, value, cls]) =>
-    '<div class="metric"><span class="label">' + label + '</span><span class="value ' + cls + '">' + value + '</span></div>'
-  ).join('');
-}
-
-renderMetrics('baseline-metrics', SIM.data.baseline.metrics, SIM.data.baseline.swarm.trajectory);
-renderMetrics('governed-metrics', SIM.data.governed.metrics, SIM.data.governed.swarm.trajectory);
-
-// Charts
-const labels = SIM.roundData.map(d => 'R' + d.round);
-
-if (typeof Chart !== 'undefined') {
-  new Chart(document.getElementById('impactChart'), {
-    type: 'line',
-    data: {
-      labels,
-      datasets: [
-        { label: 'Baseline', data: SIM.roundData.map(d => d.blAvg), borderColor: '#ef4444', backgroundColor: 'rgba(239,68,68,0.1)', fill: true, tension: 0.3 },
-        { label: 'Governed', data: SIM.roundData.map(d => d.gvAvg), borderColor: '#4ade80', backgroundColor: 'rgba(74,222,128,0.1)', fill: true, tension: 0.3 },
-      ]
-    },
-    options: {
-      responsive: true,
-      plugins: { legend: { labels: { color: '#888', font: { family: 'monospace' } } } },
-      scales: {
-        x: { ticks: { color: '#666' }, grid: { color: '#1a1a1a' } },
-        y: { ticks: { color: '#666' }, grid: { color: '#1a1a1a' }, min: -1, max: 1 }
-      }
-    }
-  });
-
-  new Chart(document.getElementById('volatilityChart'), {
-    type: 'bar',
-    data: {
-      labels,
-      datasets: [
-        { label: 'Baseline', data: SIM.roundData.map(d => d.blVol), backgroundColor: 'rgba(239,68,68,0.6)' },
-        { label: 'Governed', data: SIM.roundData.map(d => d.gvVol), backgroundColor: 'rgba(74,222,128,0.6)' },
-      ]
-    },
-    options: {
-      responsive: true,
-      plugins: { legend: { labels: { color: '#888', font: { family: 'monospace' } } } },
-      scales: {
-        x: { ticks: { color: '#666' }, grid: { color: '#1a1a1a' } },
-        y: { ticks: { color: '#666' }, grid: { color: '#1a1a1a' }, min: 0, max: 1 }
-      }
-    }
-  });
-}
-
-// Agent bars (final round comparison)
-const agentBars = document.getElementById('agent-bars');
-const lastRoundIdx = SIM.agentTimelines[0]?.baseline.length - 1 || 0;
-agentBars.innerHTML = SIM.agentTimelines.map(agent => {
-  const blImpact = agent.baseline[lastRoundIdx] || 0;
-  const gvImpact = agent.governed[lastRoundIdx] || 0;
-  const blWidth = Math.abs(blImpact) * 100;
-  const gvWidth = Math.abs(gvImpact) * 100;
-  const blColor = blImpact >= 0 ? '#4ade80' : '#ef4444';
-  const gvColor = gvImpact >= 0 ? '#4ade80' : '#3b82f6';
-  return '<div class="agent-row">' +
-    '<span class="agent-name">' + agent.id + '</span>' +
-    '<div class="bar-container">' +
-    '<div class="bar" style="width:' + blWidth + '%;background:' + blColor + ';opacity:0.4" title="Baseline: ' + blImpact.toFixed(2) + '"></div>' +
-    '</div>' +
-    '<div class="bar-container">' +
-    '<div class="bar" style="width:' + gvWidth + '%;background:' + gvColor + '" title="Governed: ' + gvImpact.toFixed(2) + '"></div>' +
-    '</div>' +
-    '</div>';
-}).join('');
-
-// Dynamics
-const dynamicsEl = document.getElementById('dynamics');
-dynamicsEl.innerHTML = SIM.dynamics.map((roundDyn, i) =>
-  roundDyn.length > 0
-    ? '<p><span class="round-label">Round ' + i + ':</span> ' + roundDyn.join('; ') + '</p>'
-    : ''
-).filter(Boolean).join('') || '<p>No interventions triggered.</p>';
-
-// Engine stats
-const gs = SIM.data.governanceStats;
-const engineEl = document.getElementById('engine-stats');
-engineEl.innerHTML = [
-  ['Engine', gs.engineLoaded ? '@neuroverseos/governance' : 'heuristic fallback', gs.engineLoaded ? 'good' : 'neutral'],
-  ['Guard Evaluations', gs.totalEvaluations, ''],
-  ['Verdicts', '<span class="tag allow">' + gs.verdicts.allow + ' allow</span><span class="tag block">' + gs.verdicts.block + ' block</span><span class="tag pause">' + gs.verdicts.pause + ' pause</span>', ''],
-  ['Rules Fired', gs.rulesFired, ''],
-  ['World Viability', gs.finalViability + (gs.worldCollapsed ? ' (COLLAPSED)' : ''), gs.worldCollapsed ? 'bad' : 'good'],
-  ['Invariants Checked', gs.invariantsChecked, ''],
-].map(([label, value, cls]) =>
-  '<div class="metric"><span class="label">' + label + '</span><span class="value ' + cls + '">' + value + '</span></div>'
-).join('');
-<\/script>
-</body>
-</html>`;
-}
 main().catch((err) => {
     console.error("Error:", err.message);
     process.exit(1);