@neuroverseos/nv-sim 0.1.2 → 0.1.6

package/dist/engine/liveVisualizer.js

@@ -0,0 +1,3063 @@
+"use strict";
+/**
+ * Live Visualizer — Round-by-round simulation viewer
+ *
+ * Streams simulation data to a local browser dashboard via Server-Sent Events.
+ * Watch rules fire, agents react, and governance reshape the system in real time.
+ *
+ * Usage:
+ *   nv-sim visualize trading --live
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startInteractiveServer = startInteractiveServer;
+const http = __importStar(require("http"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const swarmSimulation_1 = require("./swarmSimulation");
+const worldBridge_1 = require("./worldBridge");
+const auditTrace_1 = require("./auditTrace");
+const narrativeInjection_1 = require("./narrativeInjection");
+const scenarioLibrary_1 = require("./scenarioLibrary");
+const liveAdapter_1 = require("./liveAdapter");
+function getVariantsDir() {
+    return path.resolve(process.cwd(), "variants");
+}
+function ensureVariantsDir() {
+    const dir = getVariantsDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function slugify(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+}
+function loadAllVariants() {
+    ensureVariantsDir();
+    const dir = getVariantsDir();
+    const files = fs.readdirSync(dir).filter(f => f.endsWith(".json")).sort();
+    return files.map(f => {
+        try {
+            return JSON.parse(fs.readFileSync(path.join(dir, f), "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }).filter(Boolean);
+}
+function saveVariant(variant) {
+    ensureVariantsDir();
+    const filename = `${variant.id}.json`;
+    const filepath = path.join(getVariantsDir(), filename);
+    fs.writeFileSync(filepath, JSON.stringify(variant, null, 2), "utf-8");
+    return filepath;
+}
+function deleteVariant(variantId) {
+    const filepath = path.join(getVariantsDir(), `${variantId}.json`);
+    if (fs.existsSync(filepath)) {
+        fs.unlinkSync(filepath);
+        return true;
+    }
+    return false;
+}
+/**
+ * Start an interactive live server with world controls + live simulation.
+ *
+ * The UI sends POST /run-sim with world parameters.
+ * The server runs the simulation and streams results via SSE.
+ */
+/**
+ * Parse a single plain-English rule into a guard definition.
+ * No LLM needed — pattern matching on common financial governance phrases.
+ */
+function parseNaturalLanguageRule(line, index) {
+    const lower = line.toLowerCase().trim();
+    if (!lower)
+        return null;
+    // Determine enforcement action
+    let enforcement = "block";
+    if (/^(allow|permit|enable)\b/.test(lower))
+        enforcement = "allow";
+    else if (/^(pause|review|flag|hold|require.*review|require.*approval)\b/.test(lower))
+        enforcement = "pause";
+    else if (/^(block|ban|prevent|prohibit|stop|forbid|disallow|no\b|don.t allow)\b/.test(lower))
+        enforcement = "block";
+    else if (/^limit\b/.test(lower))
+        enforcement = "block";
+    // Extract intent patterns from the rule text
+    const patterns = [];
+    const actionWords = {
+        "panic sell": ["panic_sell", "panic sell", "panic selling"],
+        "panic buy": ["panic_buy", "panic buy", "panic buying"],
+        "short sell": ["short", "short_sell", "short selling", "shorting"],
+        "leverage": ["increase_leverage", "increase leverage", "max leverage", "excessive leverage"],
+        "large trade": ["large_trade", "large trade", "bulk trade", "big trade"],
+        "aggressive": ["aggressive_buy", "aggressive buy", "aggressive_short", "aggressive short"],
+        "flash": ["flash_trade", "flash trade", "high_frequency"],
+        "margin": ["margin_call", "margin call", "increase_margin"],
+        "liquidat": ["liquidate", "liquidation", "force_liquidate"],
+        "hedge": ["hedge", "hedging", "hedge_position"],
+        "buy": ["buy", "aggressive_buy"],
+        "sell": ["sell", "selling"],
+        "trade": ["trade", "trading"],
+        "withdraw": ["withdraw", "withdrawal", "bank_run"],
+        "circuit breaker": ["circuit_breaker", "halt_trading", "trading_halt"],
+    };
+    for (const [keyword, intents] of Object.entries(actionWords)) {
+        if (lower.includes(keyword)) {
+            patterns.push(...intents);
+        }
+    }
+    // Fallback: extract quoted terms or the main noun phrase
+    if (patterns.length === 0) {
+        const quoted = line.match(/"([^"]+)"/g);
+        if (quoted) {
+            quoted.forEach(q => {
+                const term = q.replace(/"/g, "").trim();
+                patterns.push(term, term.replace(/\s+/g, "_"));
+            });
+        }
+        else {
+            // Extract the action part after block/allow/pause
+            const actionPart = lower.replace(/^(block|ban|prevent|prohibit|stop|forbid|disallow|allow|permit|enable|pause|review|flag|hold|limit|no|don.t allow)\s+/i, "").trim();
+            if (actionPart) {
+                patterns.push(actionPart, actionPart.replace(/\s+/g, "_"));
+            }
+        }
+    }
+    // Deduplicate
+    const uniquePatterns = [...new Set(patterns)];
+    if (uniquePatterns.length === 0)
+        return null;
+    return {
+        id: `custom-rule-${index}`,
+        description: line,
+        enforcement,
+        intent_patterns: uniquePatterns,
+        category: "custom",
+    };
+}
+function startInteractiveServer(port, onReady) {
+    const clients = new Set();
+    let isRunning = false;
+    // ── Persistent Audit Trail ──
+    // Every governance verdict is written to disk as JSONL
+    const auditTrail = new auditTrace_1.AuditTrail();
+    // Custom guards from plain-English rule editor (session-scoped)
+    const customGuards = [];
+    let currentSession = {
+        id: `session_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+        startedAt: new Date().toISOString(),
+        world: "trading",
+        guardCount: 0,
+        evaluations: [],
+    };
+    // Session snapshots for multi-run comparison
+    const sessionHistory = [];
+    function synthesizeSessionReport() {
+        // Gather all sessions to report on (history + current if it has data)
+        const allSessions = [
+            ...sessionHistory,
+            ...(currentSession.evaluations.length > 0 ? [currentSession] : []),
+        ];
+        if (allSessions.length === 0) {
+            return {
+                sessionId: currentSession.id,
+                scenario: "Live governance session (no evaluations yet)",
+                runs: [],
+                divergence: {
+                    stabilityTrend: [],
+                    collapseTrend: [],
+                    effectivenessTrend: [],
+                    bestIteration: 0,
+                    worstIteration: 0,
+                    totalDivergence: 0,
+                    narrative: "No evaluations recorded. Send actions to POST /api/evaluate to begin.",
+                },
+                recommendation: "Start sending agent actions to /api/evaluate to generate governance data.",
+                generatedAt: new Date().toISOString(),
+            };
+        }
+        const runs = allSessions.map((sess, idx) => {
+            const evals = sess.evaluations;
+            const total = evals.length;
+            const blocked = evals.filter(e => e.decision === "BLOCK").length;
+            const modified = evals.filter(e => e.decision === "MODIFY").length;
+            const allowed = evals.filter(e => e.decision === "ALLOW").length;
+            // Synthesize metrics from real evaluation data
+            const blockRate = total > 0 ? blocked / total : 0;
+            const interventionRate = total > 0 ? (blocked + modified) / total : 0;
+            // Stability: higher when governance is actively catching harmful actions
+            // If nothing is blocked, either the system is clean OR governance is too weak
+            const stabilityScore = total > 0
+                ? Math.min(0.95, 0.4 + interventionRate * 0.4 + (allowed / Math.max(1, total)) * 0.2)
+                : 0.5;
+            // Collapse probability: lower when more harmful actions are caught
+            const collapseProbability = total > 0
+                ? Math.max(0.02, 0.6 - interventionRate * 0.5 - blockRate * 0.15)
+                : 0.5;
+            // Governance effectiveness: composite of intervention quality
+            const governanceEffectiveness = total > 0
+                ? Math.min(0.95, interventionRate * 0.6 + blockRate * 0.3 + (total > 10 ? 0.1 : 0))
+                : 0;
+            // Unique rules that fired
+            const triggeredRules = [...new Set(evals.filter(e => e.ruleId).map(e => e.ruleId))];
+            // Unique actors and actions
+            const uniqueActors = [...new Set(evals.map(e => e.actor))];
+            const uniqueActions = [...new Set(evals.map(e => e.action))];
+            return {
+                iteration: idx + 1,
+                worldName: sess.world || "live-session",
+                ruleCount: sess.guardCount,
+                gateCount: 0,
+                metrics: {
+                    avgImpact: interventionRate > 0 ? -(interventionRate * 0.5) : 0.1,
+                    collapseProbability,
+                    stabilityScore,
+                    coalitionRisks: 0,
+                    polarizationEvents: 0,
+                    peakNegativeSentiment: blockRate > 0.3 ? -0.6 : -0.2,
+                    consensusRounds: 0,
+                    maxVolatility: blockRate > 0.2 ? 0.7 : 0.3,
+                },
+                comparison: {
+                    collapseReduction: collapseProbability < 0.5 ? (0.6 - collapseProbability) : 0,
+                    stabilityImprovement: stabilityScore > 0.5 ? (stabilityScore - 0.4) : 0,
+                    volatilityReduction: interventionRate * 0.5,
+                    coalitionRiskReduction: 0,
+                    governanceEffectiveness,
+                    narrative: total > 0
+                        ? `${total} actions evaluated: ${blocked} blocked, ${modified} modified, ${allowed} allowed across ${uniqueActors.length} agent(s) performing ${uniqueActions.length} action type(s).`
+                        : "No evaluations in this session.",
+                },
+                governanceStats: {
+                    engineLoaded: true,
+                    totalEvaluations: total,
+                    verdicts: { allow: allowed, block: blocked, pause: modified },
+                    rulesFired: triggeredRules.length,
+                    worldCollapsed: false,
+                    finalViability: stabilityScore > 0.6 ? "stable" : stabilityScore > 0.4 ? "at-risk" : "critical",
+                    invariantsChecked: sess.guardCount,
+                    triggeredGuards: triggeredRules,
+                },
+            };
+        });
+        // Compute rule changes between sessions
+        for (let i = 1; i < runs.length; i++) {
+            const prev = allSessions[i - 1];
+            const curr = allSessions[i];
+            if (prev.guardCount !== curr.guardCount) {
+                runs[i].ruleChanges = {
+                    added: [],
+                    removed: [],
+                    gatesAdded: [],
+                    gatesRemoved: [],
+                    thesisChanged: prev.world !== curr.world,
+                };
+            }
+        }
+        // Divergence analysis
+        const stabilityTrend = runs.map(r => r.metrics.stabilityScore);
+        const collapseTrend = runs.map(r => r.metrics.collapseProbability);
+        const effectivenessTrend = runs.map(r => r.comparison.governanceEffectiveness);
+        let bestIteration = 1;
+        let worstIteration = 1;
+        let bestScore = -Infinity;
+        let worstScore = Infinity;
+        for (const run of runs) {
+            if (run.comparison.governanceEffectiveness > bestScore) {
+                bestScore = run.comparison.governanceEffectiveness;
+                bestIteration = run.iteration;
+            }
+            if (run.comparison.governanceEffectiveness < worstScore) {
+                worstScore = run.comparison.governanceEffectiveness;
+                worstIteration = run.iteration;
+            }
+        }
+        let totalDivergence = 0;
+        for (let i = 1; i < runs.length; i++) {
+            totalDivergence += Math.abs(runs[i].metrics.stabilityScore - runs[i - 1].metrics.stabilityScore);
+            totalDivergence += Math.abs(runs[i].metrics.collapseProbability - runs[i - 1].metrics.collapseProbability);
+            totalDivergence += Math.abs(runs[i].comparison.governanceEffectiveness - runs[i - 1].comparison.governanceEffectiveness);
+        }
+        // Build narrative
+        const totalEvals = allSessions.reduce((sum, s) => sum + s.evaluations.length, 0);
+        const totalBlocked = allSessions.reduce((sum, s) => sum + s.evaluations.filter(e => e.decision === "BLOCK").length, 0);
+        const narrativeParts = [];
+        narrativeParts.push(`${allSessions.length} session(s), ${totalEvals} total evaluations, ${totalBlocked} blocked.`);
+        if (runs.length > 1) {
+            const stabDelta = stabilityTrend[stabilityTrend.length - 1] - stabilityTrend[0];
+            if (stabDelta > 0.05)
+                narrativeParts.push(`Stability improved ${(stabDelta * 100).toFixed(0)}pp across sessions.`);
+            narrativeParts.push(`Best outcome: session ${bestIteration}.`);
+        }
+        const best = runs[bestIteration - 1];
+        const recommendation = runs.length === 1
+            ? `Single session: ${best.governanceStats.totalEvaluations} evaluations, ${best.governanceStats.verdicts.block} blocked. Apply different rules and reset to compare.`
+            : `Best session: #${bestIteration} ("${best.worldName}") — ${(best.comparison.governanceEffectiveness * 100).toFixed(0)}% effectiveness, ${(best.metrics.stabilityScore * 100).toFixed(0)}% stability.`;
+        return {
+            sessionId: currentSession.id,
+            scenario: `Live governance — ${currentSession.world}`,
+            runs,
+            divergence: {
+                stabilityTrend,
+                collapseTrend,
+                effectivenessTrend,
+                bestIteration,
+                worstIteration,
+                totalDivergence: Number(totalDivergence.toFixed(3)),
+                narrative: narrativeParts.join(" "),
+            },
+            recommendation,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    function broadcast(event) {
+        const data = `data: ${JSON.stringify(event)}\n\n`;
+        for (const client of clients) {
+            client.write(data);
+        }
+    }
+    function readBody(req) {
+        return new Promise((resolve) => {
+            let body = "";
+            req.on("data", (chunk) => { body += chunk.toString(); });
+            req.on("end", () => resolve(body));
+        });
+    }
+    function jsonResponse(res, status, data) {
+        res.writeHead(status, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+        res.end(JSON.stringify(data));
+    }
+    async function runSimulation(config) {
+        const { resolveWorld } = await Promise.resolve().then(() => __importStar(require("./worldComparison")));
+        const { runGovernedComparison } = await Promise.resolve().then(() => __importStar(require("./governedSimulation")));
+        const resolved = resolveWorld(config.worldId);
+        const rounds = config.rounds ?? resolved.swarm.rounds ?? 5;
+        // Apply state variable overrides to world definition
+        const world = { ...resolved.world };
+        if (config.stateOverrides) {
+            const updatedVars = world.state_variables.map(sv => {
+                if (config.stateOverrides && sv.id in config.stateOverrides) {
+                    return { ...sv, default_value: config.stateOverrides[sv.id] };
+                }
+                return sv;
+            });
+            world.state_variables = updatedVars;
+        }
+        // Inject custom rules as first-class invariants (not just guards)
+        // This ensures user rules affect BOTH governance paths:
+        //   1. Guard engine (intent-level blocking) — already wired via customGuards[]
+        //   2. Invariant engine (system-level stability shaping) — wired here
+        if (customGuards.length > 0) {
+            const customInvariants = customGuards.map(cg => ({
+                id: cg.id,
+                description: cg.description,
+                enforceable: cg.enforcement === "block",
+            }));
+            world.invariants = [...world.invariants, ...customInvariants];
+        }
+        // Resolve narrative events
+        let narrativeEvents = [];
+        if (config.scenarioId && scenarioLibrary_1.SCENARIO_LIBRARY[config.scenarioId]) {
+            narrativeEvents = (0, scenarioLibrary_1.resolveScenarioEvents)(scenarioLibrary_1.SCENARIO_LIBRARY[config.scenarioId]);
+        }
+        else if (config.injectEvents && config.injectEvents.length > 0) {
+            narrativeEvents = (0, narrativeInjection_1.parseInjectArgs)(["--inject", config.injectEvents.join(",")]);
+        }
+        const request = {
+            scenario: resolved.scenario,
+            stakeholders: resolved.stakeholders,
+            assumptions: resolved.assumptions,
+            constraints: resolved.constraints,
+            depth: resolved.depth,
+            swarm: { ...resolved.swarm, rounds },
+        };
+        // Send meta event
+        broadcast({
+            type: "meta",
+            source: "nv-sim",
+            scenario: resolved.scenario,
+            worldThesis: world.thesis,
+            agents: resolved.stakeholders.map(s => s.id),
+            invariants: world.invariants.map(inv => ({
+                id: inv.id,
+                description: inv.description,
+                enforcement: inv.enforceable ? "full" : "advisory",
+                source: inv.id.startsWith("custom-rule-") ? "user" : "world",
+            })),
+            gates: (world.gates ?? []).map(g => ({ id: g.id, label: g.label, severity: g.severity })),
+            narrativeEvents: narrativeEvents.map(e => ({ id: e.id, headline: e.headline, round: e.round, severity: e.severity })),
+            totalRounds: rounds,
+        });
+        // Run baseline
+        const baselineResult = await (0, swarmSimulation_1.runSwarmSimulation)(resolved.scenario, resolved.stakeholders, resolved.paths, { ...resolved.swarm, rounds });
+        for (const round of baselineResult.rounds) {
+            broadcast({
+                type: "round",
+                round: round.round,
+                totalRounds: rounds,
+                phase: "baseline",
+                reactions: round.reactions.map(r => ({
+                    stakeholder_id: r.stakeholder_id,
+                    reaction: r.reaction,
+                    impact: r.impact,
+                    confidence: r.confidence,
+                    trigger: r.trigger,
+                })),
+                avgImpact: round.reactions.reduce((s, r) => s + r.impact, 0) / round.reactions.length,
+                maxVolatility: Math.max(...round.reactions.map(r => Math.abs(r.impact))),
+                dynamics: round.emergent_dynamics ?? [],
+                interventionCount: 0,
+            });
+            await new Promise(r => setTimeout(r, 400));
+        }
+        // Run governed with narrative events
+        const governedResult = await runGovernedComparison(request, world, resolved.paths, narrativeEvents);
+        const nvWorld = (0, worldBridge_1.buildWorldFromScenario)(request, world);
+        for (const round of governedResult.governed.swarm.rounds) {
+            const reactions = round.reactions.map(r => {
+                const verdict = (0, worldBridge_1.evaluateScenarioGuard)({ ...request, scenario: `[R${round.round}] ${r.stakeholder_id}: ${r.reaction}` }, nvWorld, { trace: true, level: "standard" });
+                return {
+                    stakeholder_id: r.stakeholder_id,
+                    reaction: r.reaction,
+                    impact: r.impact,
+                    confidence: r.confidence,
+                    trigger: r.trigger,
+                    verdict: { status: verdict.status, reason: verdict.reason, ruleId: verdict.ruleId },
+                };
+            });
+            const interventionCount = (round.emergent_dynamics ?? []).filter(d => d.includes("intervention") || d.includes("governance")).length;
+            broadcast({
+                type: "round",
+                round: round.round,
+                totalRounds: rounds,
+                phase: "governed",
+                reactions,
+                avgImpact: round.reactions.reduce((s, r) => s + r.impact, 0) / round.reactions.length,
+                maxVolatility: Math.max(...round.reactions.map(r => Math.abs(r.impact))),
+                dynamics: round.emergent_dynamics ?? [],
+                interventionCount,
+            });
+            await new Promise(r => setTimeout(r, 500));
+        }
+        broadcast({ type: "complete", result: governedResult });
+    }
+    const server = http.createServer(async (req, res) => {
+        // CORS preflight
+        if (req.method === "OPTIONS") {
+            res.writeHead(204, {
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type",
+            });
+            res.end();
+            return;
+        }
+        if (req.url === "/events") {
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Access-Control-Allow-Origin": "*",
+            });
+            clients.add(res);
+            req.on("close", () => clients.delete(res));
+            return;
+        }
+        if (req.url === "/api/worlds" && req.method === "GET") {
+            const { resolveWorld } = await Promise.resolve().then(() => __importStar(require("./worldComparison")));
+            const worldIds = ["trading", "strait_of_hormuz", "gas_price_spike", "ai_regulation_crisis"];
+            const worlds = worldIds.map(id => {
+                try {
+                    const r = resolveWorld(id);
+                    return {
+                        id,
+                        title: r.title,
+                        thesis: r.world.thesis,
+                        stateVariables: r.world.state_variables,
+                        invariants: r.world.invariants,
+                        gates: r.world.gates ?? [],
+                    };
+                }
+                catch {
+                    return null;
+                }
+            }).filter(Boolean);
+            jsonResponse(res, 200, { worlds });
+            return;
+        }
+        if (req.url === "/api/scenarios" && req.method === "GET") {
+            jsonResponse(res, 200, { scenarios: scenarioLibrary_1.SCENARIO_LIBRARY });
+            return;
+        }
+        if (req.url === "/api/narratives" && req.method === "GET") {
+            jsonResponse(res, 200, { narratives: narrativeInjection_1.NARRATIVE_PRESETS });
+            return;
+        }
+        if (req.url === "/api/variants" && req.method === "GET") {
+            const variants = loadAllVariants();
+            jsonResponse(res, 200, { variants });
+            return;
+        }
+        if (req.url === "/api/save-variant" && req.method === "POST") {
+            try {
+                const body = await readBody(req);
+                const payload = JSON.parse(body);
+                if (!payload.name || !payload.baseWorld) {
+                    jsonResponse(res, 400, { error: "name and baseWorld are required" });
+                    return;
+                }
+                const id = slugify(payload.name);
+                const variant = {
+                    id,
+                    name: payload.name,
+                    description: payload.description ?? "",
+                    baseWorld: payload.baseWorld,
+                    stateOverrides: payload.stateOverrides ?? {},
+                    events: payload.events ?? [],
+                    rounds: payload.rounds ?? 5,
+                    createdAt: new Date().toISOString(),
+                    lastResult: payload.lastResult,
+                };
+                const filepath = saveVariant(variant);
+                jsonResponse(res, 200, { status: "saved", variant, filepath });
+            }
+            catch (err) {
+                jsonResponse(res, 400, { error: "Invalid request body" });
+            }
+            return;
+        }
+        if (req.url?.startsWith("/api/delete-variant/") && req.method === "DELETE") {
+            const variantId = req.url.split("/api/delete-variant/")[1];
+            if (variantId && deleteVariant(variantId)) {
+                jsonResponse(res, 200, { status: "deleted", id: variantId });
+            }
+            else {
+                jsonResponse(res, 404, { error: "Variant not found" });
+            }
+            return;
+        }
+        if (req.url === "/api/run-sim" && req.method === "POST") {
+            if (isRunning) {
+                jsonResponse(res, 409, { error: "Simulation already running" });
+                return;
+            }
+            try {
+                const body = await readBody(req);
+                const config = JSON.parse(body);
+                isRunning = true;
+                jsonResponse(res, 200, { status: "started", config });
+                // Run simulation async, streaming via SSE
+                runSimulation(config).catch(err => {
+                    broadcast({ type: "complete", result: { error: String(err) } });
+                }).finally(() => { isRunning = false; });
+            }
+            catch (err) {
+                jsonResponse(res, 400, { error: "Invalid request body" });
+            }
+            return;
+        }
+        // ── Governance Evaluate Endpoint ──
+        // Universal bridge endpoint: external simulators POST actions here for governance evaluation.
+        // Contract: { actor, action, payload, state? } → { decision: ALLOW|BLOCK|MODIFY, reason, modified_action? }
+        if (req.url === "/api/evaluate" && req.method === "POST") {
+            try {
+                const body = await readBody(req);
+                const payload = JSON.parse(body);
+                if (!payload.actor || !payload.action) {
+                    jsonResponse(res, 400, { error: "actor and action are required" });
+                    return;
+                }
+                // Resolve world for evaluation
+                const worldId = payload.world ?? "trading";
+                let nvWorld;
+                try {
+                    const { resolveWorld } = await Promise.resolve().then(() => __importStar(require("./worldComparison")));
+                    const resolved = resolveWorld(worldId);
+                    const request = {
+                        scenario: resolved.scenario,
+                        stakeholders: resolved.stakeholders,
+                        assumptions: resolved.assumptions,
+                        constraints: resolved.constraints,
+                        depth: resolved.depth,
+                        swarm: resolved.swarm,
+                    };
+                    nvWorld = (0, worldBridge_1.buildWorldFromScenario)(request, resolved.world);
+                }
+                catch {
+                    // Fallback: build minimal world
+                    nvWorld = (0, worldBridge_1.buildWorldFromScenario)({
+                        scenario: `${payload.actor}: ${payload.action}`,
+                        stakeholders: [],
+                    });
+                }
+                // Enable action_space — bridge actions are simulation execution, not thinking-only.
+                // Without this, the safety layer flags normal actions like "buy" as execution intents
+                // in a thinking-only environment.
+                nvWorld.world.players = { ...nvWorld.world.players, action_space: true };
+                // Inject simulation-specific guards into the world.
+                // The guard engine pattern-matches event.intent against guard.intent_patterns.
+                // Without guards, everything defaults to ALLOW. These guards define what
+                // simulation actions should be governed.
+                if (!nvWorld.guards) {
+                    // Detect world type from request — social media worlds get social guards,
+                    // financial worlds get trading guards, unknown gets both.
+                    const isSocial = payload.world === "social-media" || payload.world === "social"
+                        || ["create_post", "like_post", "repost", "follow", "unfollow", "create_comment",
+                            "search_posts", "mute", "unmute", "trend"].includes(payload.action);
+                    const financialGuards = [
+                        {
+                            id: "sim-panic-actions",
+                            label: "Block panic-driven actions",
+                            description: "Prevents panic selling, aggressive shorting, and other destabilizing actions during high volatility",
+                            category: "structural",
+                            enforcement: "block",
+                            immutable: true,
+                            invariant_ref: nvWorld.invariants[0]?.id,
+                            intent_patterns: ["panic_sell", "panic sell", "panic buy", "panic_buy"],
+                            default_enabled: true,
+                        },
+                        {
+                            id: "sim-excessive-leverage",
+                            label: "Block excessive leverage",
+                            description: "Prevents increasing leverage positions that could amplify cascades",
+                            category: "structural",
+                            enforcement: "block",
+                            immutable: true,
+                            intent_patterns: ["increase_leverage", "increase leverage", "max leverage"],
+                            default_enabled: true,
+                        },
+                        {
+                            id: "sim-aggressive-actions",
+                            label: "Pause aggressive market actions",
+                            description: "Requires review for aggressive buying or shorting that could move markets",
+                            category: "operational",
+                            enforcement: "pause",
+                            immutable: false,
+                            intent_patterns: ["aggressive_buy", "aggressive buy", "aggressive_short", "short"],
+                            default_enabled: true,
+                        },
+                    ];
+                    // Social media guards for MiroFish/OASIS agent actions.
+                    // These govern what AI agents can do on simulated social platforms.
+                    const socialGuards = [
+                        {
+                            id: "social-harmful-content",
+                            label: "Block harmful content creation",
+                            description: "Prevents agents from posting content that incites panic, spreads disinformation, or promotes harmful behavior",
+                            category: "structural",
+                            enforcement: "block",
+                            immutable: true,
+                            intent_patterns: ["create_post", "create_comment", "quote_post"],
+                            content_patterns: ["panic", "crash", "collaps", "sell everything", "market is dead", "scam", "rug pull", "ponzi"],
+                            default_enabled: true,
+                        },
+                        {
+                            id: "social-coordinated-manipulation",
+                            label: "Block coordinated manipulation",
+                            description: "Prevents agents from engaging in coordinated inauthentic behavior like mass following, mass liking, or brigading",
+                            category: "structural",
+                            enforcement: "block",
+                            immutable: true,
+                            intent_patterns: ["follow", "like_post", "repost"],
+                            default_enabled: true,
+                        },
+                        {
+                            id: "social-spam-prevention",
+                            label: "Pause high-frequency posting",
+                            description: "Rate-limits agents that post too frequently, preventing spam and platform flooding",
+                            category: "operational",
+                            enforcement: "pause",
+                            immutable: false,
+                            intent_patterns: ["create_post", "create_comment", "repost", "quote_post"],
+                            default_enabled: true,
+                        },
+                        {
+                            id: "social-engagement-farming",
+                            label: "Block engagement farming",
+                            description: "Prevents agents from like-bombing, follow-unfollowing, or other engagement manipulation tactics",
+                            category: "operational",
+                            enforcement: "block",
+                            immutable: false,
+                            intent_patterns: ["like_post", "unlike_post", "follow", "unfollow"],
+                            default_enabled: true,
+                        },
+                    ];
+                    const guards = isSocial ? socialGuards : financialGuards;
+                    // Build intent vocabulary from selected guards
+                    const intentVocabulary = {};
+                    for (const g of guards) {
+                        for (const pat of g.intent_patterns) {
+                            if (!intentVocabulary[pat]) {
+                                intentVocabulary[pat] = { label: pat.replace(/_/g, " ").replace(/\b\w/g, c => c.toUpperCase()), pattern: pat };
+                            }
+                        }
+                    }
+                    nvWorld.guards = { guards, intent_vocabulary: intentVocabulary };
+                }
+                // Inject custom guards from plain-English rule editor
+                if (customGuards.length > 0 && nvWorld.guards) {
+                    const existingGuards = nvWorld.guards.guards;
+                    for (const cg of customGuards) {
+                        existingGuards.push({
+                            id: cg.id,
+                            label: cg.label,
+                            description: cg.description,
+                            category: cg.category,
+                            enforcement: cg.enforcement,
+                            immutable: false,
+                            intent_patterns: cg.intent_patterns,
+                            default_enabled: true,
+                        });
+                        // Add patterns to vocabulary
+                        for (const pat of cg.intent_patterns) {
+                            nvWorld.guards.intent_vocabulary[pat] = { label: pat, pattern: pat };
+                        }
+                    }
+                }
+                // Content-aware governance for social media actions.
+                // The guard engine matches intent against intent_patterns, but for social media
+                // we also need to check message content for harmful patterns.
+                const messageContent = typeof payload.payload?.message === "string"
+                    ? payload.payload.message.toLowerCase()
+                    : typeof payload.payload?.content === "string"
+                        ? payload.payload.content.toLowerCase()
+                        : "";
+                const contentPatterns = ["panic", "crash", "collaps", "sell everything", "market is dead",
+                    "scam", "rug pull", "ponzi", "buy now or lose", "guaranteed returns", "get rich"];
+                const hasHarmfulContent = messageContent.length > 0
+                    && contentPatterns.some(p => messageContent.includes(p));
+                // If content is harmful and action is content-creating, short-circuit to BLOCK
+                const isContentAction = ["create_post", "create_comment", "quote_post", "repost"].includes(payload.action);
+                if (hasHarmfulContent && isContentAction) {
+                    const matchedPattern = contentPatterns.find(p => messageContent.includes(p)) ?? "harmful content";
+                    broadcast({
+                        type: "round",
+                        round: 0,
+                        totalRounds: 0,
+                        phase: "governed",
+                        reactions: [{
+                                stakeholder_id: payload.actor,
+                                reaction: payload.action,
+                                impact: 0,
+                                confidence: 0.9,
+                                trigger: "bridge",
+                                verdict: { status: "BLOCK", reason: `Content violates governance: "${matchedPattern}" detected`, ruleId: "social-harmful-content" },
+                            }],
+                        avgImpact: 0,
+                        maxVolatility: 0,
+                        dynamics: [],
+                        interventionCount: 1,
+                    });
+                    // Record in session
+                    currentSession.evaluations.push({
+                        actor: payload.actor, action: payload.action, decision: "BLOCK",
+                        reason: `Content blocked: "${matchedPattern}" detected`,
+                        ruleId: "social-harmful-content", world: payload.world ?? currentSession.world,
+                        timestamp: Date.now(), payload: payload.payload,
+                    });
+                    jsonResponse(res, 200, {
+                        decision: "BLOCK",
+                        reason: `Content blocked: "${matchedPattern}" detected in ${payload.action} — violates social media governance policy`,
+                        rule_id: "social-harmful-content",
+                        evidence: { matched_pattern: matchedPattern, action: payload.action, actor: payload.actor },
+                        modified_action: null,
+                    });
+                    return;
+                }
+                // Build a proper GuardEvent — the guard engine matches intent against intent_patterns.
+                // Omit `direction` — setting it enables execution-intent safety checks (prompt injection
+                // detection) which falsely flag financial terms like "buy" and "sell". Bridge actions are
+                // simulation commands, not user prompts.
+                const guardEvent = {
+                    intent: payload.action,
+                    tool: "simulation",
+                    scope: `bridge/${payload.actor}`,
+                    actionCategory: "execute",
+                    riskLevel: (["panic_sell", "panic_buy", "increase_leverage", "create_post", "repost", "quote_post"].includes(payload.action) ? "high" : "medium"),
+                    args: {
+                        actor: payload.actor,
+                        action: payload.action,
+                        ...(payload.payload ?? {}),
+                    },
+                };
+                // Evaluate directly via the governance module
+                let verdict;
+                try {
+                    const nv = await Promise.resolve().then(() => __importStar(require("@neuroverseos/governance")));
+                    verdict = nv.evaluateGuard(guardEvent, nvWorld, {
+                        trace: true,
+                        level: "standard",
+                    });
+                }
+                catch {
+                    // Fallback to scenario guard evaluation
+                    verdict = (0, worldBridge_1.evaluateScenarioGuard)({
+                        scenario: `[BRIDGE] ${payload.actor}: ${payload.action}`,
+                        stakeholders: [{ id: payload.actor, description: payload.actor, disposition: "neutral", priorities: [] }],
+                    }, nvWorld, { trace: true, level: "standard" });
+                }
+                // Map verdict to bridge protocol
+                const decision = verdict.status === "BLOCK" ? "BLOCK"
+                    : verdict.status === "PAUSE" ? "MODIFY"
+                        : "ALLOW";
+                // Broadcast governance event to connected SSE clients
+                broadcast({
+                    type: "round",
+                    round: 0,
+                    totalRounds: 0,
+                    phase: "governed",
+                    reactions: [{
+                            stakeholder_id: payload.actor,
+                            reaction: payload.action,
+                            impact: 0,
+                            confidence: 0.5,
+                            trigger: "bridge",
+                            verdict: { status: verdict.status, reason: verdict.reason, ruleId: verdict.ruleId },
+                        }],
+                    avgImpact: 0,
+                    maxVolatility: 0,
+                    dynamics: [],
+                    interventionCount: decision !== "ALLOW" ? 1 : 0,
+                });
+                // Record in session
+                currentSession.evaluations.push({
+                    actor: payload.actor, action: payload.action,
+                    decision: decision,
+                    reason: verdict.reason ?? "", ruleId: verdict.ruleId ?? null,
+                    world: payload.world ?? currentSession.world,
+                    timestamp: Date.now(), payload: payload.payload,
+                });
+                currentSession.guardCount = customGuards.length + (nvWorld.guards?.guards?.length ?? 0);
+                // Persist to audit trail on disk
+                auditTrail.logVerdict({
+                    agent: payload.actor,
+                    action: payload.action,
+                    actionType: payload.payload?.type ?? "unknown",
+                    verdict: decision,
+                    reason: verdict.reason ?? "",
+                    confidence: verdict.confidence ?? 0.5,
+                    rulesFired: verdict.ruleId ? [{
+                            id: verdict.ruleId,
+                            description: verdict.reason ?? "",
+                            effect: decision === "BLOCK" ? "blocked" : decision === "MODIFY" ? "dampened" : "monitored",
+                            impactReduction: decision === "BLOCK" ? 1 : decision === "MODIFY" ? 0.5 : 0,
+                        }] : [],
+                    worldState: payload.world ?? currentSession.world,
+                });
+                jsonResponse(res, 200, {
+                    decision,
+                    reason: verdict.reason ?? null,
+                    rule_id: verdict.ruleId ?? null,
+                    evidence: verdict.evidence ?? null,
+                    modified_action: decision === "MODIFY" ? payload.payload : null,
+                });
+            }
+            catch (err) {
+                // Record fail-open in session (payload may be out of scope if JSON parse failed)
+                currentSession.evaluations.push({
+                    actor: "unknown", action: "unknown",
+                    decision: "ALLOW", reason: "Governance evaluation error — fail open",
+                    ruleId: null, world: currentSession.world, timestamp: Date.now(),
+                });
+                // Fail open — return ALLOW on any error
+                jsonResponse(res, 200, {
+                    decision: "ALLOW",
+                    reason: "Governance evaluation error — fail open",
+                    rule_id: null,
+                    evidence: null,
+                    modified_action: null,
+                });
+            }
+            return;
+        }
+        // ── Plain-English Rule Parser ──
+        // Parses natural language rules into guard definitions (local, no LLM needed)
+        if (req.url === "/api/parse-rules" && req.method === "POST") {
+            try {
+                const body = await readBody(req);
+                const payload = JSON.parse(body);
+                if (!payload.text) {
+                    jsonResponse(res, 400, { error: "text is required" });
+                    return;
+                }
+                const lines = payload.text.split("\n").map(l => l.trim()).filter(l => l.length > 0 && !l.startsWith("#"));
+                const rules = lines.map((line, i) => parseNaturalLanguageRule(line, i));
+                jsonResponse(res, 200, { rules: rules.filter(Boolean), raw: lines });
+            }
+            catch (err) {
+                jsonResponse(res, 400, { error: "Invalid request" });
+            }
+            return;
+        }
+        // Apply parsed rules to the active governance context
+        if (req.url === "/api/apply-rules" && req.method === "POST") {
+            try {
+                const body = await readBody(req);
+                const payload = JSON.parse(body);
+                if (!payload.rules || !Array.isArray(payload.rules)) {
+                    jsonResponse(res, 400, { error: "rules array is required" });
+                    return;
+                }
+                // Store custom rules in memory for the session
+                customGuards.length = 0;
+                for (const rule of payload.rules) {
+                    customGuards.push({
+                        id: rule.id,
+                        label: rule.description,
+                        description: rule.description,
+                        category: "custom",
+                        enforcement: rule.enforcement,
+                        immutable: false,
+                        intent_patterns: rule.intent_patterns,
+                        default_enabled: true,
+                    });
+                }
+                jsonResponse(res, 200, {
+                    status: "applied",
+                    applied: customGuards.length,
+                    enforcement: "full",
+                    detail: "Rules enforced across guard engine (intent blocking) AND invariant engine (system dynamics)",
+                });
+            }
+            catch (err) {
+                jsonResponse(res, 400, { error: "Invalid request" });
+            }
+            return;
+        }
+        // ── Session Reporting Endpoints ──
+        // Connect the serve runtime to the enforce reporting pipeline.
+        // Users can request reports, stats, and recommendations from live governance data.
+        // GET /api/session — current session stats (lightweight)
+        if (req.url === "/api/session" && req.method === "GET") {
+            const evals = currentSession.evaluations;
+            const blocked = evals.filter(e => e.decision === "BLOCK").length;
+            const modified = evals.filter(e => e.decision === "MODIFY").length;
+            const allowed = evals.filter(e => e.decision === "ALLOW").length;
+            const uniqueActors = [...new Set(evals.map(e => e.actor))];
+            const uniqueActions = [...new Set(evals.map(e => e.action))];
+            const triggeredRules = [...new Set(evals.filter(e => e.ruleId).map(e => e.ruleId))];
+            jsonResponse(res, 200, {
+                sessionId: currentSession.id,
+                startedAt: currentSession.startedAt,
+                world: currentSession.world,
+                guardCount: currentSession.guardCount,
+                evaluations: {
+                    total: evals.length,
+                    blocked,
+                    modified,
+                    allowed,
+                },
+                agents: uniqueActors,
+                actionTypes: uniqueActions,
+                triggeredRules,
+                historyCount: sessionHistory.length,
+            });
+            return;
+        }
+        // GET /api/session/report — full enforcement report (text)
+        if (req.url === "/api/session/report" && req.method === "GET") {
+            const report = synthesizeSessionReport();
+            // Format as human-readable text using the same style as enforce CLI
+            const lines = [];
+            lines.push("");
+            lines.push("  LIVE GOVERNANCE — ENFORCEMENT REPORT");
+            lines.push("  " + "=".repeat(70));
+            lines.push(`  Session: ${report.sessionId}`);
+            lines.push(`  Scenario: ${report.scenario}`);
+            lines.push(`  Sessions: ${report.runs.length}`);
+            lines.push(`  Generated: ${report.generatedAt}`);
+            lines.push("");
+            if (report.runs.length > 0) {
+                lines.push("  RUN HISTORY");
+                lines.push("  " + "-".repeat(70));
+                lines.push(`  ${"#".padEnd(4)} ${"World".padEnd(25)} ${"Rules".padEnd(8)} ${"Evals".padEnd(8)} ${"Blocked".padEnd(10)} ${"Effectiveness"}`);
+                lines.push("  " + "-".repeat(70));
+                for (const run of report.runs) {
+                    const name = run.worldName.length > 23 ? run.worldName.slice(0, 22) + "…" : run.worldName;
+                    lines.push(`  ${String(run.iteration).padEnd(4)} ${name.padEnd(25)} ${String(run.ruleCount).padEnd(8)} ${String(run.governanceStats.totalEvaluations).padEnd(8)} ${String(run.governanceStats.verdicts.block).padEnd(10)} ${(run.comparison.governanceEffectiveness * 100).toFixed(0)}%`);
+                }
+                lines.push("");
+                lines.push("  DIVERGENCE ANALYSIS");
+                lines.push("  " + "-".repeat(70));
+                lines.push(`  Stability trend:     ${report.divergence.stabilityTrend.map(s => `${(s * 100).toFixed(0)}%`).join(" → ")}`);
+                lines.push(`  Collapse trend:      ${report.divergence.collapseTrend.map(s => `${(s * 100).toFixed(0)}%`).join(" → ")}`);
+                lines.push(`  Effectiveness trend: ${report.divergence.effectivenessTrend.map(s => `${(s * 100).toFixed(0)}%`).join(" → ")}`);
+                lines.push(`  Total divergence:    ${report.divergence.totalDivergence}`);
+                lines.push("");
+                lines.push(`  ${report.divergence.narrative}`);
+                // Blocked action breakdown
+                const allEvals = [
+                    ...sessionHistory.flatMap(s => s.evaluations),
+                    ...currentSession.evaluations,
+                ];
+                const blockedEvals = allEvals.filter(e => e.decision === "BLOCK");
+                if (blockedEvals.length > 0) {
+                    lines.push("");
+                    lines.push("  BLOCKED ACTIONS");
+                    lines.push("  " + "-".repeat(70));
+                    // Group by rule
+                    const byRule = {};
+                    for (const e of blockedEvals) {
+                        const key = e.ruleId ?? "unknown";
+                        if (!byRule[key])
+                            byRule[key] = { count: 0, actors: new Set(), actions: new Set() };
+                        byRule[key].count++;
+                        byRule[key].actors.add(e.actor);
+                        byRule[key].actions.add(e.action);
+                    }
+                    const sorted = Object.entries(byRule).sort((a, b) => b[1].count - a[1].count);
+                    for (const [ruleId, data] of sorted) {
+                        lines.push(`  ${ruleId}: ${data.count} blocks across ${data.actors.size} agent(s)`);
+                        lines.push(`    Actions: ${[...data.actions].join(", ")}`);
+                    }
+                }
+                // Recommendations (deterministic, no LLM needed)
+                lines.push("");
+                lines.push("  RECOMMENDATIONS");
+                lines.push("  " + "-".repeat(70));
+                const best = report.runs[report.divergence.bestIteration - 1];
+                if (best) {
+                    const totalEvals = best.governanceStats.totalEvaluations;
+                    const blockRate = totalEvals > 0 ? best.governanceStats.verdicts.block / totalEvals : 0;
+                    if (blockRate > 0.5) {
+                        lines.push("  HIGH BLOCK RATE — Rules may be too aggressive.");
+                        lines.push("  Try relaxing constraints or adding MODIFY actions instead of hard blocks.");
+                        lines.push(`  Current block rate: ${(blockRate * 100).toFixed(0)}% (${best.governanceStats.verdicts.block}/${totalEvals})`);
+                    }
+                    else if (blockRate < 0.05 && totalEvals > 20) {
+                        lines.push("  LOW BLOCK RATE — Rules may be too permissive.");
+                        lines.push("  Try adding content-specific guards or lowering thresholds.");
+                        lines.push(`  Current block rate: ${(blockRate * 100).toFixed(0)}% (${best.governanceStats.verdicts.block}/${totalEvals})`);
+                    }
+                    else if (blockRate > 0) {
+                        lines.push(`  Governance is active: ${(blockRate * 100).toFixed(0)}% of actions blocked.`);
+                        lines.push("  To iterate: apply different rules via POST /api/apply-rules, then POST /api/session/reset.");
+                        lines.push("  This creates a new session for side-by-side comparison.");
+                    }
+                    if (report.runs.length === 1) {
+                        lines.push("");
+                        lines.push("  EXPERIMENT: Apply different rules and reset to compare sessions.");
+                        lines.push("  This will show divergence: how different governance changes outcomes.");
+                    }
+                }
+                lines.push("");
+                lines.push("  RECOMMENDATION");
+                lines.push("  " + "-".repeat(70));
+                lines.push(`  ${report.recommendation}`);
+            }
+            lines.push("");
+            lines.push("  " + "=".repeat(70));
+            lines.push("  NeuroVerse Policy Enforcement System — Live Governance");
+            lines.push("  Design rules. Run reality. See what changes.");
+            lines.push("  " + "=".repeat(70));
+            lines.push("");
+            res.writeHead(200, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
+            res.end(lines.join("\n"));
+            return;
+        }
+        // GET /api/session/report.json — full enforcement report (JSON)
+        if (req.url === "/api/session/report.json" && req.method === "GET") {
+            const report = synthesizeSessionReport();
+            jsonResponse(res, 200, report);
+            return;
+        }
+        // GET /api/session/evaluations — raw evaluation log
+        if (req.url === "/api/session/evaluations" && req.method === "GET") {
+            jsonResponse(res, 200, {
+                sessionId: currentSession.id,
+                count: currentSession.evaluations.length,
+                evaluations: currentSession.evaluations.slice(-200), // last 200
+            });
+            return;
+        }
+        // POST /api/session/reset — snapshot current session and start fresh
+        // This is how users create multi-run comparisons:
+        //   1. Apply rules A → run simulation → POST /api/session/reset
+        //   2. Apply rules B → run simulation → GET /api/session/report
+        //   Now the report shows divergence between rules A and rules B.
+        if (req.url === "/api/session/reset" && req.method === "POST") {
+            if (currentSession.evaluations.length > 0) {
+                sessionHistory.push({ ...currentSession, evaluations: [...currentSession.evaluations] });
+            }
+            const body = await readBody(req).catch(() => "{}");
+            const opts = JSON.parse(body || "{}");
+            currentSession = {
+                id: `session_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+                startedAt: new Date().toISOString(),
+                world: opts.world ?? currentSession.world,
+                guardCount: customGuards.length,
+                evaluations: [],
+            };
+            jsonResponse(res, 200, {
+                status: "reset",
+                newSessionId: currentSession.id,
+                previousSessions: sessionHistory.length,
+                message: `Session reset. ${sessionHistory.length} session(s) in history. Apply new rules and evaluate to compare.`,
+            });
+            return;
+        }
+        // POST /api/session/save — save session as experiment with lineage
+        if (req.url === "/api/session/save" && req.method === "POST") {
+            const report = synthesizeSessionReport();
+            if (report.runs.length === 0) {
+                jsonResponse(res, 400, { error: "No evaluations to save. Send actions to /api/evaluate first." });
+                return;
+            }
+            const experiment = {
+                id: `exp-live-${Date.now().toString(36)}`,
+                savedAt: new Date().toISOString(),
+                scenario: report.scenario,
+                source: "live-governance",
+                sessions: report.runs.length,
+                totalEvaluations: report.runs.reduce((sum, r) => sum + r.governanceStats.totalEvaluations, 0),
+                metrics: {
+                    stability: report.runs[report.divergence.bestIteration - 1]?.metrics.stabilityScore ?? 0,
+                    effectiveness: report.runs[report.divergence.bestIteration - 1]?.comparison.governanceEffectiveness ?? 0,
+                    collapseProbability: report.runs[report.divergence.bestIteration - 1]?.metrics.collapseProbability ?? 0,
+                },
+                divergence: report.divergence,
+                recommendation: report.recommendation,
+                report,
+            };
+            // Save to experiments/ directory
+            try {
+                if (!fs.existsSync("experiments"))
+                    fs.mkdirSync("experiments", { recursive: true });
+                const filePath = path.join("experiments", `${experiment.id}.json`);
+                fs.writeFileSync(filePath, JSON.stringify(experiment, null, 2));
+                jsonResponse(res, 200, {
+                    status: "saved",
+                    experimentId: experiment.id,
+                    filePath,
+                    metrics: experiment.metrics,
+                    message: `Saved to ${filePath}. View with: npx nv-sim enforce --load ${filePath}`,
+                });
+            }
+            catch (err) {
+                jsonResponse(res, 500, { error: "Failed to save experiment", detail: String(err) });
+            }
+            return;
+        }
+        // List available live adapters
+        if (req.url === "/api/adapters" && req.method === "GET") {
+            const adapters = Object.values(liveAdapter_1.ADAPTER_REGISTRY).map(a => ({
+                id: a.id,
+                label: a.label,
+                description: a.description,
+            }));
+            jsonResponse(res, 200, { adapters });
+            return;
+        }
+        // Run simulation via live adapter (external process)
+        if (req.url === "/api/run-live" && req.method === "POST") {
+            if (isRunning) {
+                jsonResponse(res, 409, { error: "Simulation already running" });
+                return;
+            }
+            try {
+                const body = await readBody(req);
+                const payload = JSON.parse(body);
+                const adapter = (0, liveAdapter_1.createAdapter)(payload.adapterId, payload.options);
+                if (!adapter) {
+                    jsonResponse(res, 400, { error: `Unknown adapter: ${payload.adapterId}` });
+                    return;
+                }
+                isRunning = true;
+                jsonResponse(res, 200, { status: "started", adapter: payload.adapterId });
+                // Resolve world for governance evaluation
+                const { resolveWorld } = await Promise.resolve().then(() => __importStar(require("./worldComparison")));
+                const resolved = resolveWorld(payload.worldId ?? "trading");
+                const world = { ...resolved.world };
+                if (payload.stateOverrides) {
+                    const updatedVars = world.state_variables.map(sv => {
+                        if (payload.stateOverrides && sv.id in payload.stateOverrides) {
+                            return { ...sv, default_value: payload.stateOverrides[sv.id] };
+                        }
+                        return sv;
+                    });
+                    world.state_variables = updatedVars;
+                }
+                const request = {
+                    scenario: resolved.scenario,
+                    stakeholders: resolved.stakeholders,
+                    assumptions: resolved.assumptions,
+                    constraints: resolved.constraints,
+                    depth: resolved.depth,
+                    swarm: resolved.swarm,
+                };
+                const nvWorld = (0, worldBridge_1.buildWorldFromScenario)(request, world);
+                // Send meta event with adapter source
+                broadcast({
+                    type: "meta",
+                    source: payload.adapterId,
+                    scenario: resolved.scenario,
+                    worldThesis: world.thesis,
+                    agents: [], // will be populated dynamically from adapter
+                    invariants: world.invariants.map(inv => ({ id: inv.id, description: inv.description })),
+                    gates: (world.gates ?? []).map(g => ({ id: g.id, label: g.label, severity: g.severity })),
+                    narrativeEvents: [],
+                    totalRounds: 0,
+                });
+                // Listen for rounds from the adapter
+                adapter.on("round", (liveRound) => {
+                    // Build lookup of original verdicts from adapter's adaptation data.
+                    // When an external bridge (e.g. MiroFish) already applied governance,
+                    // the verdict lives in adaptation.deltas — use it instead of re-evaluating
+                    // (re-evaluating the MODIFIED action would return ALLOW, hiding the BLOCK).
+                    const adaptationByAgent = new Map();
+                    if (liveRound.adaptation?.deltas) {
+                        for (const delta of liveRound.adaptation.deltas) {
+                            adaptationByAgent.set(delta.agent, {
+                                status: delta.decision,
+                                reason: delta.reason,
+                                ruleId: delta.rule,
+                            });
+                        }
+                    }
+                    const reactions = liveRound.agentActions.map(a => {
+                        // Priority: per-action verdict > adaptation delta > local re-evaluation
+                        const actionVerdict = a.verdict ? { status: a.verdict.status, reason: a.verdict.reason, ruleId: a.verdict.rule } : null;
+                        const bridgeVerdict = actionVerdict ?? adaptationByAgent.get(a.agent);
+                        let verdict;
+                        if (bridgeVerdict) {
+                            verdict = bridgeVerdict;
+                        }
+                        else {
+                            const guard = (0, worldBridge_1.evaluateScenarioGuard)({ ...request, scenario: `[R${liveRound.round}] ${a.agent}: ${a.action}` }, nvWorld, { trace: true, level: "standard" });
+                            verdict = { status: guard.status, reason: guard.reason, ruleId: guard.ruleId };
+                        }
+                        return {
+                            stakeholder_id: a.agent,
+                            reaction: a.action,
+                            impact: a.impact,
+                            confidence: a.confidence ?? 0.5,
+                            trigger: liveRound.source,
+                            verdict,
+                        };
+                    });
+                    const interventionCount = reactions.filter(r => r.verdict.status !== "ALLOW").length;
+                    broadcast({
+                        type: "round",
+                        round: liveRound.round,
+                        totalRounds: 0, // unknown for live streams
+                        phase: "governed",
+                        reactions,
+                        avgImpact: reactions.reduce((s, r) => s + r.impact, 0) / (reactions.length || 1),
+                        maxVolatility: Math.max(0, ...reactions.map(r => Math.abs(r.impact))),
+                        dynamics: liveRound.emergentDynamics ?? [],
+                        interventionCount,
+                    });
+                });
+                adapter.on("complete", () => {
+                    isRunning = false;
+                });
+                adapter.on("error", (err) => {
+                    broadcast({ type: "complete", result: { error: String(err) } });
+                    isRunning = false;
+                });
+                adapter.start().catch(err => {
+                    broadcast({ type: "complete", result: { error: String(err) } });
+                    isRunning = false;
+                });
+            }
+            catch (err) {
+                jsonResponse(res, 400, { error: "Invalid request body" });
+            }
+            return;
+        }
+        // ── AUDIT TRAIL ENDPOINTS ──
+        // GET /api/audit — summary of current session's audit trail
+        if (req.url === "/api/audit" && req.method === "GET") {
+            jsonResponse(res, 200, auditTrail.summary());
+            return;
+        }
+        // GET /api/audit/entries — all entries from current session (with optional filters)
+        if (req.url?.startsWith("/api/audit/entries") && req.method === "GET") {
+            const url = new URL(req.url, `http://localhost:${port}`);
+            const entries = auditTrail.query({
+                type: url.searchParams.get("type") ?? undefined,
+                agent: url.searchParams.get("agent") ?? undefined,
+                verdict: url.searchParams.get("verdict") ?? undefined,
+                runId: url.searchParams.get("runId") ?? undefined,
+                after: url.searchParams.get("after") ?? undefined,
+                before: url.searchParams.get("before") ?? undefined,
+            });
+            jsonResponse(res, 200, {
+                sessionId: auditTrail.getSessionId(),
+                count: entries.length,
+                entries,
+            });
+            return;
+        }
+        // GET /api/audit/entries/text — human-readable audit trail
+        if (req.url?.startsWith("/api/audit/entries/text") && req.method === "GET") {
+            const entries = auditTrail.readAll();
+            res.writeHead(200, { "Content-Type": "text/plain", "Access-Control-Allow-Origin": "*" });
+            res.end((0, auditTrace_1.formatAuditTrail)(entries, { verbose: true }));
+            return;
+        }
+        // GET /api/audit/sessions — list all audit sessions on disk
+        if (req.url === "/api/audit/sessions" && req.method === "GET") {
+            const sessions = (0, auditTrace_1.listAuditSessions)();
+            jsonResponse(res, 200, {
+                sessions: sessions.map((id) => {
+                    const trail = (0, auditTrace_1.loadAuditSession)(id);
+                    return trail.summary();
+                }),
+            });
+            return;
+        }
+        // GET /api/audit/sessions/:id — load a specific session's audit trail
+        const auditSessionMatch = req.url?.match(/^\/api\/audit\/sessions\/([^/]+)$/);
+        if (auditSessionMatch && req.method === "GET") {
+            const sessionId = decodeURIComponent(auditSessionMatch[1]);
+            const trail = (0, auditTrace_1.loadAuditSession)(sessionId);
+            const entries = trail.readAll();
+            if (entries.length === 0) {
+                jsonResponse(res, 404, { error: `Audit session "${sessionId}" not found or empty` });
+            }
+            else {
+                jsonResponse(res, 200, {
+                    ...trail.summary(),
+                    entries,
+                });
+            }
+            return;
+        }
+        // GET /api/audit/search — search across ALL sessions
+        if (req.url?.startsWith("/api/audit/search") && req.method === "GET") {
+            const url = new URL(req.url, `http://localhost:${port}`);
+            const results = (0, auditTrace_1.searchAuditTrails)({
+                type: url.searchParams.get("type") ?? undefined,
+                agent: url.searchParams.get("agent") ?? undefined,
+                verdict: url.searchParams.get("verdict") ?? undefined,
+                after: url.searchParams.get("after") ?? undefined,
+                before: url.searchParams.get("before") ?? undefined,
+            });
+            jsonResponse(res, 200, {
+                count: results.length,
+                entries: results,
+            });
+            return;
+        }
+        // Serve the interactive dashboard
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(INTERACTIVE_DASHBOARD_HTML);
+    });
+    server.listen(port, () => {
+        onReady(`http://localhost:${port}`);
+    });
+    return { server };
+}
+const INTERACTIVE_DASHBOARD_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>NV-SIM — Scenario Control Platform</title>
+<style>
+  /* ── Theme Variables ── */
+  :root {
+    --bg-primary: #0f0f0f;
+    --bg-secondary: #141414;
+    --bg-surface: #1a1a1a;
+    --bg-elevated: #222;
+    --border: #2a2a2a;
+    --border-subtle: #333;
+    --text-primary: #f0f0f0;
+    --text-secondary: #b0b0b0;
+    --text-muted: #888;
+    --text-faint: #666;
+    --accent: #818cf8;
+    --accent-bg: #1e1e3a;
+    --green: #4ade80;
+    --green-bg: #0a2a14;
+    --red: #f87171;
+    --red-bg: #2d0a0a;
+    --yellow: #fbbf24;
+    --yellow-bg: #2d2006;
+    --blue: #60a5fa;
+    --blue-bg: #1e293b;
+    --purple: #a78bfa;
+  }
+  body.light {
+    --bg-primary: #f5f5f5;
+    --bg-secondary: #eaeaea;
+    --bg-surface: #e0e0e0;
+    --bg-elevated: #d4d4d4;
+    --border: #c0c0c0;
+    --border-subtle: #b0b0b0;
+    --text-primary: #1a1a1a;
+    --text-secondary: #444;
+    --text-muted: #666;
+    --text-faint: #888;
+    --accent: #6366f1;
+    --accent-bg: #e8e8ff;
+    --green: #16a34a;
+    --green-bg: #dcfce7;
+    --red: #dc2626;
+    --red-bg: #fee2e2;
+    --yellow: #ca8a04;
+    --yellow-bg: #fef9c3;
+    --blue: #2563eb;
+    --blue-bg: #dbeafe;
+    --purple: #7c3aed;
+  }
+
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body { font-family: 'SF Mono', 'Fira Code', monospace; background: var(--bg-primary); color: var(--text-primary); overflow: hidden; transition: background 0.3s, color 0.3s; }
+  .header { padding: 12px 20px; border-bottom: 1px solid var(--border); display: flex; justify-content: space-between; align-items: center; }
+  .header h1 { font-size: 15px; color: var(--text-primary); }
+  .header .sub { font-size: 11px; color: var(--text-muted); margin-left: 12px; }
+  .header-right { display: flex; align-items: center; gap: 12px; }
+  .theme-toggle { background: var(--bg-surface); border: 1px solid var(--border); color: var(--text-secondary); padding: 4px 10px; border-radius: 6px; font-family: inherit; font-size: 11px; cursor: pointer; transition: all 0.2s; }
+  .theme-toggle:hover { border-color: var(--accent); color: var(--accent); }
+  .status { font-size: 11px; padding: 3px 10px; border-radius: 10px; }
+  .status.idle { background: var(--accent-bg); color: var(--accent); }
+  .status.live { background: var(--green-bg); color: var(--green); animation: pulse 2s infinite; }
+  .status.complete { background: var(--accent-bg); color: var(--accent); }
+  @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.6; } }
+
+  .layout { display: grid; grid-template-columns: 340px 1fr; height: calc(100vh - 49px); }
+
+  /* LEFT PANEL — Controls */
+  .controls { background: var(--bg-secondary); border-right: 1px solid var(--border); overflow-y: auto; padding: 16px; }
+  .ctrl-section { margin-bottom: 20px; }
+  .ctrl-section h3 { font-size: 11px; color: var(--text-muted); text-transform: uppercase; letter-spacing: 1px; margin-bottom: 10px; padding-bottom: 6px; border-bottom: 1px solid var(--border); }
+
+  .ctrl-row { margin-bottom: 12px; }
+  .ctrl-label { font-size: 11px; color: var(--text-secondary); margin-bottom: 4px; display: flex; justify-content: space-between; }
+  .ctrl-label .val { color: var(--text-primary); font-weight: 600; }
+
+  input[type="range"] { width: 100%; height: 4px; -webkit-appearance: none; background: var(--bg-elevated); border-radius: 2px; outline: none; }
+  input[type="range"]::-webkit-slider-thumb { -webkit-appearance: none; width: 14px; height: 14px; border-radius: 50%; background: var(--accent); cursor: pointer; }
+  input[type="range"]::-moz-range-thumb { width: 14px; height: 14px; border-radius: 50%; background: var(--accent); cursor: pointer; border: none; }
+
+  select { width: 100%; background: var(--bg-surface); color: var(--text-primary); border: 1px solid var(--border-subtle); padding: 6px 8px; border-radius: 4px; font-family: inherit; font-size: 12px; }
+
+  .toggle-row { display: flex; align-items: center; gap: 8px; }
+  .toggle { position: relative; width: 36px; height: 20px; background: var(--border-subtle); border-radius: 10px; cursor: pointer; transition: background 0.2s; }
+  .toggle.on { background: var(--green); }
+  .toggle::after { content: ''; position: absolute; top: 2px; left: 2px; width: 16px; height: 16px; background: #fff; border-radius: 50%; transition: transform 0.2s; }
+  .toggle.on::after { transform: translateX(16px); }
+  .toggle-label { font-size: 12px; color: var(--text-secondary); }
+
+  .inject-row { display: flex; gap: 6px; margin-bottom: 6px; }
+  .inject-row select { flex: 1; }
+  .inject-row input { width: 50px; background: var(--bg-surface); color: var(--text-primary); border: 1px solid var(--border-subtle); padding: 4px 6px; border-radius: 4px; font-family: inherit; font-size: 12px; text-align: center; }
+  .inject-list { margin-bottom: 8px; }
+  .inject-item { font-size: 11px; color: var(--text-secondary); padding: 3px 6px; background: var(--bg-surface); border-radius: 3px; margin-bottom: 3px; display: flex; justify-content: space-between; }
+  .inject-item .remove { color: var(--red); cursor: pointer; }
+
+  .btn { width: 100%; padding: 10px; border: none; border-radius: 6px; font-family: inherit; font-size: 13px; font-weight: 700; cursor: pointer; text-transform: uppercase; letter-spacing: 1px; transition: all 0.2s; }
+  .btn-run { background: var(--green); color: #0a0a0a; }
+  .btn-run:hover { background: #22c55e; }
+  .btn-run:disabled { background: var(--bg-elevated); color: var(--text-faint); cursor: not-allowed; }
+  .btn-add { background: var(--bg-elevated); color: var(--accent); padding: 6px; font-size: 11px; }
+  .btn-add:hover { background: var(--accent-bg); }
+
+  .scenario-btn { display: block; width: 100%; padding: 8px 10px; margin-bottom: 4px; background: var(--bg-surface); border: 1px solid var(--bg-elevated); border-radius: 4px; color: var(--text-primary); font-family: inherit; font-size: 11px; text-align: left; cursor: pointer; }
+  .scenario-btn:hover { border-color: var(--accent); background: var(--accent-bg); }
+  .scenario-btn .stitle { font-weight: 600; color: var(--text-primary); }
+  .scenario-btn .sdesc { color: var(--text-muted); font-size: 10px; margin-top: 2px; }
+
+  /* Save variant */
+  .btn-save { background: var(--accent-bg); color: var(--accent); margin-top: 0; }
+  .btn-save:hover { background: var(--accent-bg); filter: brightness(1.2); }
+  .btn-confirm { flex: 1; background: var(--green); color: #0a0a0a; padding: 7px; font-size: 11px; }
+  .btn-cancel { flex: 1; background: var(--bg-elevated); color: var(--text-muted); padding: 7px; font-size: 11px; }
+  .save-input { width: 100%; background: var(--bg-surface); color: var(--text-primary); border: 1px solid var(--border-subtle); padding: 7px 8px; border-radius: 4px; font-family: inherit; font-size: 12px; }
+  .save-input:focus { border-color: var(--accent); outline: none; }
+
+  /* Variant cards */
+  .variant-card { background: var(--bg-surface); border: 1px solid var(--bg-elevated); border-radius: 4px; padding: 8px 10px; margin-bottom: 4px; cursor: pointer; position: relative; }
+  .variant-card:hover { border-color: var(--green); }
+  .variant-card .vname { font-size: 12px; font-weight: 600; color: var(--text-primary); }
+  .variant-card .vdesc { font-size: 10px; color: var(--text-muted); margin-top: 2px; }
+  .variant-card .vmeta { font-size: 10px; color: var(--text-faint); margin-top: 4px; }
+  .variant-card .vmeta .vresult { color: var(--green); }
+  .variant-card .vdelete { position: absolute; top: 6px; right: 8px; color: var(--red); font-size: 10px; cursor: pointer; opacity: 0; transition: opacity 0.2s; }
+  .variant-card:hover .vdelete { opacity: 1; }
+  .variant-card .vbase { display: inline-block; font-size: 9px; padding: 1px 5px; background: var(--accent-bg); color: var(--accent); border-radius: 3px; margin-top: 3px; }
+
+  /* RIGHT PANEL — Simulation viewer */
+  .viewer { display: grid; grid-template-rows: auto 1fr auto; overflow: hidden; }
+  .viewer-top { display: grid; grid-template-columns: 1fr 1fr; gap: 1px; background: var(--border); }
+  .viewer-mid { display: grid; grid-template-columns: 1fr 1fr; gap: 1px; background: var(--border); overflow: hidden; }
+  .viewer-bottom { background: var(--bg-primary); border-top: 1px solid var(--border); padding: 12px 16px; max-height: 180px; overflow-y: auto; }
+
+  .vpanel { background: var(--bg-primary); padding: 14px; overflow-y: auto; }
+  .vpanel h2 { font-size: 11px; color: var(--text-muted); text-transform: uppercase; letter-spacing: 1px; margin-bottom: 10px; }
+
+  /* Metrics */
+  .metric-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px; }
+  .metric-box { background: var(--bg-surface); border: 1px solid var(--bg-elevated); border-radius: 6px; padding: 10px; text-align: center; }
+  .metric-box .value { font-size: 20px; font-weight: 700; color: var(--text-primary); }
+  .metric-box .label { font-size: 10px; color: var(--text-muted); margin-top: 2px; }
+  .metric-box.good .value { color: var(--green); }
+  .metric-box.bad .value { color: var(--red); }
+  .metric-box.warn .value { color: var(--yellow); }
+
+  /* Agent bars */
+  .agent-row { display: flex; align-items: center; gap: 6px; padding: 3px 0; font-size: 11px; }
+  .agent-name { width: 130px; color: var(--text-secondary); flex-shrink: 0; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .impact-bar-bg { flex: 1; height: 14px; background: var(--bg-surface); border-radius: 3px; position: relative; overflow: hidden; }
+  .impact-bar { height: 100%; border-radius: 3px; transition: width 0.4s ease; position: absolute; top: 0; }
+  .impact-bar.positive { background: var(--green); right: 50%; }
+  .impact-bar.negative { background: var(--red); left: 50%; }
+  .impact-val { width: 44px; text-align: right; color: var(--text-secondary); font-size: 10px; }
+  .center-line { position: absolute; left: 50%; top: 0; bottom: 0; width: 1px; background: var(--border-subtle); }
+  .verdict { display: inline-block; padding: 1px 5px; border-radius: 3px; font-size: 9px; font-weight: 600; margin-left: 4px; }
+  .verdict.ALLOW { background: var(--green-bg); color: var(--green); }
+  .verdict.BLOCK { background: var(--red-bg); color: var(--red); }
+  .verdict.PAUSE { background: var(--yellow-bg); color: var(--yellow); }
+
+  /* Chart */
+  .chart-container { position: relative; height: 100%; min-height: 150px; }
+  canvas { width: 100% !important; height: 100% !important; }
+
+  /* Simulation Trace */
+  .trace-round { margin-bottom: 10px; border: 1px solid var(--border); border-radius: 4px; overflow: hidden; }
+  .trace-round-header { display: flex; align-items: center; gap: 8px; padding: 6px 10px; background: var(--bg-surface); cursor: pointer; user-select: none; }
+  .trace-round-header:hover { background: var(--bg-elevated); }
+  .trace-phase { font-size: 9px; font-weight: 700; padding: 1px 5px; border-radius: 3px; text-transform: uppercase; letter-spacing: 0.5px; }
+  .trace-phase.baseline { background: var(--blue-bg); color: var(--blue); }
+  .trace-phase.governed { background: var(--green-bg); color: var(--green); }
+  .trace-round-label { font-size: 11px; color: var(--text-primary); font-weight: 600; }
+  .trace-round-metrics { margin-left: auto; font-size: 10px; color: var(--text-muted); display: flex; gap: 10px; }
+  .trace-body { padding: 0 10px 8px; }
+  .trace-body[data-collapsed="true"] { display: none; }
+  .trace-section { margin-top: 6px; }
+  .trace-section-label { font-size: 9px; color: var(--text-muted); text-transform: uppercase; letter-spacing: 1px; margin-bottom: 3px; display: flex; align-items: center; gap: 5px; }
+  .trace-section-label::before { content: ''; display: inline-block; width: 6px; height: 6px; border-radius: 50%; }
+  .trace-section-label.event::before { background: #f59e0b; }
+  .trace-section-label.agents::before { background: #3b82f6; }
+  .trace-section-label.governance::before { background: #10b981; }
+  .trace-event-item { font-size: 10px; color: var(--text-primary); padding: 3px 0 3px 11px; border-left: 2px solid #f59e0b; margin-left: 2px; }
+  .trace-event-severity { font-size: 9px; font-weight: 600; padding: 0 4px; border-radius: 2px; margin-left: 4px; }
+  .trace-event-severity.major, .trace-event-severity.extreme { background: var(--red-bg); color: var(--red); }
+  .trace-event-severity.moderate { background: var(--yellow-bg); color: var(--yellow); }
+  .trace-event-severity.minor { background: var(--green-bg); color: var(--green); }
+  .trace-agent-item { font-size: 10px; padding: 2px 0 2px 11px; border-left: 2px solid #3b82f6; margin-left: 2px; display: flex; align-items: center; gap: 6px; }
+  .trace-agent-name { color: var(--blue); font-weight: 500; min-width: 80px; }
+  .trace-agent-action { color: var(--text-secondary); flex: 1; }
+  .trace-agent-impact { font-size: 9px; font-weight: 600; min-width: 36px; text-align: right; }
+  .trace-agent-impact.positive { color: var(--green); }
+  .trace-agent-impact.negative { color: var(--red); }
+  .trace-gov-item { font-size: 10px; padding: 3px 6px 3px 11px; border-left: 2px solid #10b981; margin-left: 2px; display: flex; align-items: center; gap: 6px; }
+  .trace-gov-rule { font-size: 9px; color: var(--text-muted); font-family: monospace; }
+  .trace-gov-reason { color: var(--text-secondary); flex: 1; }
+  .trace-dynamics { font-size: 10px; color: var(--purple); padding: 2px 0 2px 11px; border-left: 2px solid #7c3aed; margin-left: 2px; font-style: italic; }
+  .trace-arrow { color: var(--text-faint); font-size: 10px; text-align: center; padding: 2px 0; }
+  .trace-empty { font-size: 10px; color: var(--text-faint); font-style: italic; padding: 4px 0; }
+
+  /* World info */
+  .world-thesis { font-size: 11px; color: var(--text-secondary); font-style: italic; margin-bottom: 8px; }
+  .rule-card { background: var(--bg-secondary); border: 1px solid var(--border); border-radius: 8px; padding: 10px 12px; margin-bottom: 8px; transition: border-color 0.2s; }
+  .rule-card:hover { border-color: var(--text-muted); }
+  .rule-card.type-invariant { border-left: 4px solid var(--green); }
+  .rule-card.type-gate { border-left: 4px solid var(--red); }
+  .rule-card.type-warning { border-left: 4px solid var(--yellow); }
+  .rule-card.type-modify { border-left: 4px solid #60a5fa; }
+  .rule-card .rule-header { display: flex; align-items: center; gap: 6px; margin-bottom: 4px; }
+  .rule-card .rule-icon { font-size: 12px; flex-shrink: 0; }
+  .rule-card .rule-title { font-size: 12px; font-weight: 600; color: var(--text-primary); }
+  .rule-card .rule-desc { font-size: 11px; color: var(--text-secondary); line-height: 1.4; }
+  .rule-card .rule-meta { font-size: 10px; color: var(--text-muted); margin-top: 6px; opacity: 0.8; }
+  .rule-card .rule-why { font-size: 10px; color: var(--text-muted); margin-top: 5px; font-style: italic; padding-top: 5px; border-top: 1px solid var(--border); }
+  .rule-card .rule-impact { display: none; font-size: 10px; margin-top: 6px; padding: 5px 8px; border-radius: 4px; background: var(--bg-surface, var(--bg-secondary)); }
+  .rule-card .rule-impact.visible { display: block; }
+  .rule-card .rule-impact .impact-stat { color: var(--text-primary); font-weight: 600; }
+  .rule-card .rule-impact .impact-label { color: var(--text-muted); }
+  .rule-card.user-rule { border-left-color: #818cf8; background: rgba(129, 140, 248, 0.05); }
+  .rule-source-tag { font-size: 9px; font-weight: 700; color: #818cf8; background: rgba(129, 140, 248, 0.15); padding: 1px 5px; border-radius: 3px; margin-left: auto; letter-spacing: 0.5px; }
+
+  /* Empty state */
+  .empty-state { display: flex; flex-direction: column; align-items: center; justify-content: center; height: 100%; color: var(--text-faint); }
+  .empty-state .icon { font-size: 48px; margin-bottom: 12px; }
+  .empty-state .msg { font-size: 13px; color: var(--text-muted); }
+  .empty-state .hint { font-size: 11px; color: var(--text-faint); margin-top: 6px; }
+
+  /* System Shift Card */
+  .system-shift { display: none; margin: 12px 16px; border: 1px solid var(--green-bg); border-radius: 8px; background: var(--bg-secondary); overflow: hidden; animation: fadeInUp 0.4s ease; }
+  .system-shift.visible { display: block; }
+  @keyframes fadeInUp { from { opacity: 0; transform: translateY(8px); } to { opacity: 1; transform: translateY(0); } }
+  .ss-header { display: flex; align-items: center; gap: 8px; padding: 12px 14px; background: var(--green-bg); border-bottom: 1px solid var(--green-bg); }
+  .ss-icon { width: 8px; height: 8px; border-radius: 50%; background: var(--green); box-shadow: 0 0 6px rgba(74,222,128,0.4); }
+  .ss-title { font-size: 11px; font-weight: 700; color: var(--green); text-transform: uppercase; letter-spacing: 1.5px; }
+  .ss-rule { font-size: 13px; font-weight: 600; color: var(--text-primary); padding: 10px 14px 0; }
+  .ss-body { padding: 10px 14px 14px; display: grid; gap: 8px; }
+  .ss-section { background: var(--bg-surface); border: 1px solid var(--border); border-radius: 6px; padding: 10px 12px; }
+  .ss-section-label { font-size: 9px; font-weight: 700; color: var(--text-muted); text-transform: uppercase; letter-spacing: 1px; margin-bottom: 6px; }
+  .ss-adapt-rate { font-size: 20px; font-weight: 700; color: var(--green); }
+  .ss-adapt-desc { font-size: 11px; color: var(--text-secondary); margin-top: 2px; }
+  .ss-shift-item { font-size: 11px; color: var(--text-secondary); padding: 2px 0; display: flex; align-items: center; gap: 6px; }
+  .ss-shift-arrow { color: var(--green); font-weight: 600; }
+  .ss-pattern-tag { display: inline-block; font-size: 10px; padding: 2px 8px; background: var(--accent-bg); color: var(--accent); border-radius: 3px; margin-right: 4px; margin-bottom: 4px; }
+  .ss-impact-row { display: flex; justify-content: space-between; align-items: center; font-size: 11px; color: var(--text-secondary); padding: 2px 0; }
+  .ss-impact-delta { color: var(--green); font-weight: 600; }
+  .ss-impact-delta.negative { color: var(--red); }
+  .ss-narrative { font-size: 12px; color: var(--text-primary); line-height: 1.5; font-style: italic; border-left: 2px solid var(--green); padding-left: 10px; }
+  .ss-scale { font-size: 10px; color: var(--text-muted); padding: 0 14px 6px; }
+  .ss-scale strong { color: var(--text-secondary); }
+  .ss-flow { display: flex; align-items: center; gap: 6px; padding: 6px 14px; font-size: 10px; color: var(--text-faint); }
+  .ss-flow-arrow { color: var(--green); }
+  .ss-raw-toggle { display: flex; align-items: center; gap: 6px; padding: 8px 12px; background: var(--bg-secondary); border: none; border-top: 1px solid var(--border); color: var(--text-muted); font-family: inherit; font-size: 10px; cursor: pointer; width: 100%; text-align: left; transition: color 0.2s; }
+  .ss-raw-toggle:hover { color: var(--text-secondary); }
+  .ss-raw-toggle .arrow { transition: transform 0.2s; }
+  .ss-raw-toggle.open .arrow { transform: rotate(90deg); }
+  .ss-raw-detail { max-height: 0; overflow: hidden; transition: max-height 0.3s ease; }
+  .ss-raw-detail.open { max-height: 200px; overflow-y: auto; }
+  .ss-raw-list { padding: 6px 12px; }
+  .ss-raw-item { font-size: 10px; color: var(--text-muted); padding: 2px 0; display: flex; gap: 6px; }
+  .ss-raw-item .raw-agent { color: var(--text-secondary); min-width: 100px; }
+  .ss-raw-item .raw-action { color: var(--text-secondary); flex: 1; }
+  .ss-raw-item .raw-verdict { font-size: 9px; font-weight: 600; padding: 0 4px; border-radius: 2px; }
+  .ss-raw-item .raw-verdict.BLOCK { background: var(--red-bg); color: var(--red); }
+  .ss-raw-item .raw-verdict.MODIFY { background: var(--yellow-bg); color: var(--yellow); }
+
+  /* Integration Quick-Start (in controls panel) */
+  .integrate-section { background: var(--accent-bg); border: 1px solid var(--accent-bg); border-radius: 6px; padding: 10px 12px; margin-top: 8px; }
+  .integrate-section h4 { font-size: 10px; color: var(--accent); text-transform: uppercase; letter-spacing: 1px; margin-bottom: 8px; }
+  .integrate-code { font-size: 10px; color: var(--text-primary); background: var(--bg-surface); border: 1px solid var(--bg-elevated); border-radius: 4px; padding: 8px; overflow-x: auto; white-space: pre; line-height: 1.5; }
+  .integrate-code .kw { color: var(--accent); }
+  .integrate-code .str { color: var(--green); }
+  .integrate-code .comment { color: var(--text-muted); }
+  .integrate-endpoint { font-size: 11px; color: var(--text-secondary); margin-top: 6px; }
+  .integrate-endpoint code { color: var(--green); background: var(--bg-surface); padding: 1px 5px; border-radius: 3px; }
+
+  /* Rule editor */
+  .rule-editor { margin-top: 8px; }
+  .rule-input { width: 100%; min-height: 60px; background: var(--bg-surface); color: var(--text-primary); border: 1px solid var(--border-subtle); padding: 8px; border-radius: 4px; font-family: inherit; font-size: 12px; resize: vertical; line-height: 1.5; }
+  .rule-input:focus { border-color: var(--accent); outline: none; }
+  .rule-input::placeholder { color: var(--text-faint); }
+  .btn-parse { background: var(--accent-bg); color: var(--accent); margin-top: 6px; padding: 8px; font-size: 11px; }
+  .btn-parse:hover { filter: brightness(1.2); }
+  .btn-parse:disabled { opacity: 0.5; cursor: not-allowed; }
+  .parsed-rules { margin-top: 8px; }
+  .parsed-rule { background: var(--bg-secondary); border: 1px solid var(--border); border-radius: 8px; padding: 10px 12px; margin-bottom: 8px; transition: border-color 0.2s; }
+  .parsed-rule:hover { border-color: var(--text-muted); }
+  .parsed-rule.enforcement-block { border-left: 4px solid var(--red); }
+  .parsed-rule.enforcement-allow { border-left: 4px solid var(--green); }
+  .parsed-rule.enforcement-modify { border-left: 4px solid #60a5fa; }
+  .parsed-rule.enforcement-warn { border-left: 4px solid var(--yellow); }
+  .parsed-rule .pr-header { display: flex; align-items: center; gap: 6px; margin-bottom: 4px; }
+  .parsed-rule .pr-icon { font-size: 12px; }
+  .parsed-rule .pr-action { font-weight: 700; font-size: 12px; color: var(--text-primary); text-transform: capitalize; }
+  .parsed-rule .pr-desc { color: var(--text-secondary); font-size: 11px; line-height: 1.4; }
+  .parsed-rule .pr-patterns { color: var(--text-muted); font-size: 10px; margin-top: 6px; opacity: 0.8; }
+  .btn-apply-rules { background: var(--green); color: #0a0a0a; margin-top: 6px; padding: 8px; font-size: 11px; }
+  .btn-apply-rules:hover { filter: brightness(0.9); }
+  .rule-status { font-size: 10px; color: var(--text-muted); margin-top: 4px; }
+  .rule-status.success { color: var(--green); }
+  .rule-status.error { color: var(--red); }
+  .rule-examples { font-size: 10px; color: var(--text-faint); margin-top: 6px; line-height: 1.6; }
+  .rule-examples code { background: var(--bg-surface); padding: 1px 4px; border-radius: 2px; color: var(--text-secondary); }
+</style>
+</head>
+<body>
+<div class="header">
+  <div style="display:flex;align-items:center">
+    <h1>NV-SIM</h1>
+    <span class="sub">Scenario Control Platform</span>
+  </div>
+  <div class="header-right">
+    <button class="theme-toggle" id="theme-toggle" title="Toggle light/dark mode">Light Mode</button>
+    <span id="status" class="status idle">Ready</span>
+  </div>
+</div>
+
+<div class="layout">
+  <!-- LEFT: CONTROLS -->
+  <div class="controls" id="controls-panel">
+    <!-- Simulation Engine selector -->
+    <div class="ctrl-section">
+      <h3>Simulation Engine</h3>
+      <div class="ctrl-row">
+        <select id="engine-select">
+          <option value="nv-sim" selected>NV-SIM (Built-in)</option>
+        </select>
+      </div>
+      <div id="engine-status" style="font-size:10px;color:#555;margin-top:4px"></div>
+    </div>
+
+    <!-- World selector -->
+    <div class="ctrl-section">
+      <h3>World</h3>
+      <div class="ctrl-row">
+        <select id="world-select"></select>
+      </div>
+      <div id="world-thesis" class="world-thesis"></div>
+    </div>
+
+    <!-- State variables (dynamic sliders) -->
+    <div class="ctrl-section" id="state-vars-section" style="display:none">
+      <h3>World Rules</h3>
+      <div id="state-vars"></div>
+    </div>
+
+    <!-- Plain-English Rule Editor -->
+    <div class="ctrl-section">
+      <h3>Write Rules in Plain English</h3>
+      <div class="rule-editor">
+        <textarea class="rule-input" id="rule-input" placeholder="Type rules in plain English, one per line:&#10;&#10;Block panic selling during high volatility&#10;Limit leverage to 5x maximum&#10;Pause any trade over $10M for review"></textarea>
+        <button class="btn btn-parse" id="parse-rules-btn">Parse Rules</button>
+        <div id="parsed-rules" class="parsed-rules"></div>
+        <div id="rule-status" class="rule-status"></div>
+        <div class="rule-examples">
+          Examples:<br>
+          <code>Block panic selling</code><br>
+          <code>Limit leverage to 3x</code><br>
+          <code>Pause large trades for review</code><br>
+          <code>Allow hedging positions</code><br>
+          <code>Block short selling during circuit breaker</code>
+        </div>
+      </div>
+    </div>
+
+    <!-- Scenario presets -->
+    <div class="ctrl-section">
+      <h3>Scenario Presets</h3>
+      <div id="scenario-list"></div>
+    </div>
+
+    <!-- Narrative injection -->
+    <div class="ctrl-section">
+      <h3>Narrative Events</h3>
+      <div class="inject-row">
+        <select id="event-select"></select>
+        <input type="number" id="event-round" min="1" max="20" value="3" placeholder="R">
+      </div>
+      <button class="btn btn-add" id="add-event-btn">+ Add Event</button>
+      <div id="inject-list" class="inject-list" style="margin-top:8px"></div>
+    </div>
+
+    <!-- Rounds -->
+    <div class="ctrl-section">
+      <h3>Simulation</h3>
+      <div class="ctrl-row">
+        <div class="ctrl-label">
+          <span>Rounds</span>
+          <span class="val" id="rounds-val">5</span>
+        </div>
+        <input type="range" id="rounds-slider" min="3" max="12" value="5">
+      </div>
+    </div>
+
+    <!-- Run button -->
+    <button class="btn btn-run" id="run-btn">Run Simulation</button>
+
+    <!-- Save as variant -->
+    <div id="save-section" style="margin-top:12px">
+      <button class="btn btn-save" id="save-btn">Save as World Variant</button>
+      <div id="save-form" style="display:none;margin-top:8px">
+        <input type="text" id="variant-name" placeholder="Variant name (e.g. Hormuz Closed + 3x Leverage)" class="save-input">
+        <input type="text" id="variant-desc" placeholder="What does this variant test?" class="save-input" style="margin-top:4px">
+        <div style="display:flex;gap:6px;margin-top:6px">
+          <button class="btn btn-confirm" id="confirm-save-btn">Save</button>
+          <button class="btn btn-cancel" id="cancel-save-btn">Cancel</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Saved variants -->
+    <div class="ctrl-section" style="margin-top:16px">
+      <h3>Saved Variants</h3>
+      <div id="variant-list"><div style="font-size:11px;color:#333">No saved variants yet</div></div>
+    </div>
+
+    <!-- Integration Quick-Start -->
+    <div class="ctrl-section" style="margin-top:16px">
+      <h3>Integrate Your Simulator</h3>
+      <div class="integrate-section">
+        <h4>Connect in 3 lines</h4>
+        <div class="integrate-code"><span class="kw">from</span> neuroverse_bridge <span class="kw">import</span> evaluate
+
+verdict = evaluate(
+    actor=<span class="str">"agent_1"</span>,
+    action=<span class="str">"panic_sell"</span>,
+    world=<span class="str">"trading"</span>
+)
+
+<span class="kw">if</span> verdict[<span class="str">"decision"</span>] == <span class="str">"BLOCK"</span>:
+    action = <span class="str">"hold"</span>  <span class="comment"># adapted</span></div>
+        <div class="integrate-endpoint">
+          Endpoint: <code id="integrate-url">POST /api/evaluate</code>
+        </div>
+        <div style="font-size:10px;color:#444;margin-top:6px">
+          Fail-open · 500ms timeout · Stateless
+        </div>
+        <div style="margin-top:8px;font-size:10px">
+          <span style="display:inline-block;padding:2px 6px;background:#2d0606;color:#f87171;border-radius:3px;margin-right:3px">BLOCK</span> replaced
+          <span style="display:inline-block;padding:2px 6px;background:#2d2006;color:#fbbf24;border-radius:3px;margin-right:3px;margin-left:4px">MODIFY</span> constrained
+          <span style="display:inline-block;padding:2px 6px;background:#052e16;color:#4ade80;border-radius:3px;margin-left:4px">ALLOW</span> proceeds
+        </div>
+      </div>
+
+      <!-- Session Report Panel -->
+      <div class="ctrl-section" id="session-panel">
+        <h3 class="ctrl-label">SESSION</h3>
+        <div class="metric-grid" style="grid-template-columns:1fr 1fr;gap:6px;margin-bottom:8px">
+          <div class="metric-box"><div class="value" id="s-total">0</div><div class="label">Evaluations</div></div>
+          <div class="metric-box"><div class="value" id="s-blocked" style="color:#f87171">0</div><div class="label">Blocked</div></div>
+          <div class="metric-box"><div class="value" id="s-modified" style="color:#fbbf24">0</div><div class="label">Modified</div></div>
+          <div class="metric-box"><div class="value" id="s-allowed" style="color:#4ade80">0</div><div class="label">Allowed</div></div>
+        </div>
+        <div id="s-agents" style="font-size:10px;color:#888;margin-bottom:6px"></div>
+        <div style="display:flex;gap:6px;flex-wrap:wrap">
+          <button onclick="viewSessionReport()" style="flex:1;padding:6px 8px;background:#1e1b4b;color:#818cf8;border:1px solid #312e81;border-radius:4px;cursor:pointer;font-size:11px">View Report</button>
+          <button onclick="resetSession()" style="flex:1;padding:6px 8px;background:#1c1917;color:#a8a29e;border:1px solid #292524;border-radius:4px;cursor:pointer;font-size:11px">Reset &amp; Compare</button>
+          <button onclick="saveExperiment()" style="flex:1;padding:6px 8px;background:#052e16;color:#4ade80;border:1px solid #14532d;border-radius:4px;cursor:pointer;font-size:11px">Save</button>
+        </div>
+        <div id="session-history" style="margin-top:6px;font-size:10px;color:#666"></div>
+      </div>
+    </div>
+  </div>
+
+  <!-- RIGHT: VIEWER -->
+  <div class="viewer">
+    <div class="viewer-top">
+      <div class="vpanel">
+        <h2>Live Metrics</h2>
+        <div class="metric-grid">
+          <div class="metric-box"><div class="value" id="m-stability">--</div><div class="label">Stability</div></div>
+          <div class="metric-box"><div class="value" id="m-volatility">--</div><div class="label">Volatility</div></div>
+          <div class="metric-box"><div class="value" id="m-round">--</div><div class="label">Round</div></div>
+          <div class="metric-box"><div class="value" id="m-interventions">0</div><div class="label">Interventions</div></div>
+        </div>
+      </div>
+      <div class="vpanel">
+        <h2>World Rules Active</h2>
+        <div id="active-invariants"></div>
+      </div>
+    </div>
+
+    <div class="viewer-mid">
+      <div class="vpanel" id="agents-panel">
+        <h2>Agent Impacts</h2>
+        <div id="agents">
+          <div class="empty-state"><div class="icon">&gt;_</div><div class="msg">Configure world and run simulation</div><div class="hint">Adjust rules on the left, then press Run</div></div>
+        </div>
+      </div>
+      <div class="vpanel">
+        <h2>Impact Timeline</h2>
+        <div class="chart-container"><canvas id="chart"></canvas></div>
+      </div>
+    </div>
+
+    <!-- System Shift Card — the demo moment -->
+    <div id="system-shift" class="system-shift">
+      <div class="ss-header">
+        <div class="ss-icon"></div>
+        <span class="ss-title">System Shift</span>
+      </div>
+      <div class="ss-rule" id="ss-rule"></div>
+      <div class="ss-scale" id="ss-scale"></div>
+      <div class="ss-flow">
+        <span>Rule</span><span class="ss-flow-arrow">→</span>
+        <span>Behavioral Shift</span><span class="ss-flow-arrow">→</span>
+        <span>Emergent Pattern</span><span class="ss-flow-arrow">→</span>
+        <span>System Outcome</span>
+      </div>
+      <div class="ss-body">
+        <div class="ss-section">
+          <div class="ss-section-label">Behavioral Shift</div>
+          <div class="ss-adapt-rate" id="ss-adapt-rate"></div>
+          <div class="ss-adapt-desc" id="ss-adapt-desc"></div>
+          <div id="ss-shifts"></div>
+        </div>
+        <div class="ss-section">
+          <div class="ss-section-label">What Emerged</div>
+          <div id="ss-patterns"></div>
+        </div>
+        <div class="ss-section">
+          <div class="ss-section-label">System Outcome</div>
+          <div id="ss-impacts"></div>
+        </div>
+        <div class="ss-section">
+          <div class="ss-section-label">What Actually Happened</div>
+          <div class="ss-narrative" id="ss-narrative"></div>
+        </div>
+      </div>
+      <button class="ss-raw-toggle" id="ss-raw-toggle">
+        <span class="arrow">▶</span> View raw detail
+      </button>
+      <div class="ss-raw-detail" id="ss-raw-detail">
+        <div class="ss-raw-list" id="ss-raw-list"></div>
+      </div>
+    </div>
+
+    <div class="viewer-bottom">
+      <h2 style="font-size:11px;color:#555;text-transform:uppercase;letter-spacing:1px;margin-bottom:8px">Simulation Trace <span id="trace-source" style="color:#4ade80;font-weight:600;margin-left:6px"></span> <span style="color:#333;font-weight:400">— Events → Agents → Rules → Outcomes</span></h2>
+      <div id="log"></div>
+    </div>
+  </div>
+</div>
+
+<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.4/dist/chart.umd.min.js"><\/script>
+<script>
+// ============================================
+// STATE
+// ============================================
+let worlds = [];
+let scenarios = {};
+let narratives = {};
+let currentWorld = null;
+let injectedEvents = [];
+let totalInterventions = 0;
+let baselineImpacts = [];
+let governedImpacts = [];
+let chartLabels = [];
+let chart = null;
+let narrativeEventsByRound = {}; // { round: [{ id, headline, severity }] }
+let ruleImpactTracker = {}; // { ruleId: { blocks: N, label: string } }
+
+const statusEl = document.getElementById('status');
+const worldSelect = document.getElementById('world-select');
+const stateVarsSection = document.getElementById('state-vars-section');
+const stateVarsEl = document.getElementById('state-vars');
+const scenarioListEl = document.getElementById('scenario-list');
+const eventSelect = document.getElementById('event-select');
+const eventRoundInput = document.getElementById('event-round');
+const injectListEl = document.getElementById('inject-list');
+const roundsSlider = document.getElementById('rounds-slider');
+const roundsVal = document.getElementById('rounds-val');
+const runBtn = document.getElementById('run-btn');
+const agentsEl = document.getElementById('agents');
+const logEl = document.getElementById('log');
+const activeInvEl = document.getElementById('active-invariants');
+const engineSelect = document.getElementById('engine-select');
+const engineStatusEl = document.getElementById('engine-status');
+const traceSourceEl = document.getElementById('trace-source');
+
+// ============================================
+// INIT — Load worlds, scenarios, narratives, adapters
+// ============================================
+async function init() {
+  const [wRes, sRes, nRes, aRes] = await Promise.all([
+    fetch('/api/worlds').then(r => r.json()),
+    fetch('/api/scenarios').then(r => r.json()),
+    fetch('/api/narratives').then(r => r.json()),
+    fetch('/api/adapters').then(r => r.json()).catch(() => ({ adapters: [] })),
+  ]);
+
+  worlds = wRes.worlds;
+  scenarios = sRes.scenarios;
+  narratives = nRes.narratives;
+
+  // Populate engine selector with live adapters
+  (aRes.adapters || []).forEach(function(a) {
+    const opt = document.createElement('option');
+    opt.value = a.id;
+    opt.textContent = a.label;
+    engineSelect.appendChild(opt);
+  });
+
+  // Populate world select
+  worlds.forEach(w => {
+    const opt = document.createElement('option');
+    opt.value = w.id;
+    opt.textContent = w.title;
+    worldSelect.appendChild(opt);
+  });
+
+  // Populate event select
+  Object.entries(narratives).forEach(([id, ev]) => {
+    const opt = document.createElement('option');
+    opt.value = id;
+    opt.textContent = ev.headline.slice(0, 40);
+    eventSelect.appendChild(opt);
+  });
+
+  // Populate scenario presets
+  Object.entries(scenarios).forEach(([id, s]) => {
+    const btn = document.createElement('button');
+    btn.className = 'scenario-btn';
+    btn.innerHTML = '<div class="stitle">' + s.title + '</div><div class="sdesc">' + s.description + '</div>';
+    btn.onclick = () => loadScenario(id, s);
+    scenarioListEl.appendChild(btn);
+  });
+
+  // Select first world
+  if (worlds.length > 0) selectWorld(worlds[0].id);
+
+  // Load saved variants
+  await loadVariants();
+
+  // Connect SSE
+  connectSSE();
+}
+
+function selectWorld(worldId) {
+  currentWorld = worlds.find(w => w.id === worldId);
+  if (!currentWorld) return;
+
+  worldSelect.value = worldId;
+  document.getElementById('world-thesis').textContent = '"' + currentWorld.thesis + '"';
+
+  // Render state variable controls
+  if (currentWorld.stateVariables && currentWorld.stateVariables.length > 0) {
+    stateVarsSection.style.display = '';
+    stateVarsEl.innerHTML = '';
+    currentWorld.stateVariables.forEach(sv => {
+      const row = document.createElement('div');
+      row.className = 'ctrl-row';
+
+      if (sv.type === 'number' && sv.range) {
+        const step = sv.range.max <= 1 ? 0.01 : (sv.range.max <= 10 ? 0.1 : 1);
+        row.innerHTML =
+          '<div class="ctrl-label"><span>' + sv.label + '</span><span class="val" id="sv-val-' + sv.id + '">' + sv.default_value + '</span></div>' +
+          '<input type="range" id="sv-' + sv.id + '" min="' + sv.range.min + '" max="' + sv.range.max + '" step="' + step + '" value="' + sv.default_value + '" data-sv="' + sv.id + '">';
+        stateVarsEl.appendChild(row);
+        const slider = row.querySelector('input');
+        slider.addEventListener('input', () => {
+          document.getElementById('sv-val-' + sv.id).textContent = slider.value;
+        });
+      } else if (sv.type === 'enum' && sv.enum_values) {
+        row.innerHTML =
+          '<div class="ctrl-label"><span>' + sv.label + '</span></div>' +
+          '<select id="sv-' + sv.id + '" data-sv="' + sv.id + '">' +
+          sv.enum_values.map(v => '<option value="' + v + '"' + (v === sv.default_value ? ' selected' : '') + '>' + v + '</option>').join('') +
+          '</select>';
+        stateVarsEl.appendChild(row);
+      } else if (sv.type === 'boolean') {
+        row.innerHTML =
+          '<div class="toggle-row">' +
+          '<div class="toggle' + (sv.default_value ? ' on' : '') + '" id="sv-' + sv.id + '" data-sv="' + sv.id + '"></div>' +
+          '<span class="toggle-label">' + sv.label + '</span>' +
+          '</div>';
+        stateVarsEl.appendChild(row);
+        const toggle = row.querySelector('.toggle');
+        toggle.addEventListener('click', () => {
+          toggle.classList.toggle('on');
+        });
+      }
+    });
+  } else {
+    stateVarsSection.style.display = 'none';
+  }
+
+  // Show invariants
+  activeInvEl.innerHTML = currentWorld.invariants.map(inv =>
+    '<div class="inv-item">[' + inv.id + '] ' + inv.description + '</div>'
+  ).join('') + (currentWorld.gates || []).map(g =>
+    '<div class="inv-item" style="color:' + (g.severity === 'critical' ? '#f87171' : '#fbbf24') + '">[' + g.id + '] ' + g.label + '</div>'
+  ).join('');
+}
+
+function loadScenario(id, scenario) {
+  // Set world
+  selectWorld(scenario.world);
+  // Set events
+  injectedEvents = scenario.events.slice();
+  renderInjectedEvents();
+  // Set rounds
+  const r = scenario.rounds || 5;
+  roundsSlider.value = Math.min(r, 12);
+  roundsVal.textContent = Math.min(r, 12);
+}
+
+// ============================================
+// NARRATIVE EVENT INJECTION
+// ============================================
+document.getElementById('add-event-btn').addEventListener('click', () => {
+  const eventId = eventSelect.value;
+  const round = parseInt(eventRoundInput.value);
+  if (!eventId || isNaN(round)) return;
+  injectedEvents.push(eventId + '@' + round);
+  renderInjectedEvents();
+});
+
+function renderInjectedEvents() {
+  injectListEl.innerHTML = injectedEvents.map((ev, i) =>
+    '<div class="inject-item"><span>' + ev + '</span><span class="remove" data-idx="' + i + '">x</span></div>'
+  ).join('');
+  injectListEl.querySelectorAll('.remove').forEach(el => {
+    el.addEventListener('click', () => {
+      injectedEvents.splice(parseInt(el.dataset.idx), 1);
+      renderInjectedEvents();
+    });
+  });
+}
+
+// ============================================
+// WORLD SELECT
+// ============================================
+worldSelect.addEventListener('change', () => selectWorld(worldSelect.value));
+roundsSlider.addEventListener('input', () => { roundsVal.textContent = roundsSlider.value; });
+
+// ============================================
+// RUN SIMULATION
+// ============================================
+runBtn.addEventListener('click', async () => {
+  if (!currentWorld) return;
+  runBtn.disabled = true;
+  runBtn.textContent = 'Running...';
+
+  // Reset viewer state
+  totalInterventions = 0;
+  baselineImpacts = [];
+  governedImpacts = [];
+  chartLabels = [];
+  if (chart) { chart.destroy(); chart = null; }
+  agentsEl.innerHTML = '';
+  logEl.innerHTML = '';
+  document.getElementById('m-stability').textContent = '--';
+  document.getElementById('m-volatility').textContent = '--';
+  document.getElementById('m-round').textContent = '--';
+  document.getElementById('m-interventions').textContent = '0';
+
+  // Gather state overrides
+  const stateOverrides = {};
+  if (currentWorld.stateVariables) {
+    currentWorld.stateVariables.forEach(sv => {
+      const el = document.getElementById('sv-' + sv.id);
+      if (!el) return;
+      if (sv.type === 'number') stateOverrides[sv.id] = parseFloat(el.value);
+      else if (sv.type === 'boolean') stateOverrides[sv.id] = el.classList.contains('on');
+      else stateOverrides[sv.id] = el.value;
+    });
+  }
+
+  const selectedEngine = engineSelect.value;
+
+  try {
+    if (selectedEngine === 'nv-sim') {
+      // Built-in simulation
+      const config = {
+        worldId: currentWorld.id,
+        stateOverrides,
+        injectEvents: injectedEvents.length > 0 ? injectedEvents : undefined,
+        rounds: parseInt(roundsSlider.value),
+      };
+      await fetch('/api/run-sim', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(config),
+      });
+    } else {
+      // Live adapter (external simulator)
+      const payload = {
+        adapterId: selectedEngine,
+        worldId: currentWorld.id,
+        stateOverrides,
+      };
+      await fetch('/api/run-live', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+    }
+  } catch (err) {
+    addLog('Error starting simulation: ' + err.message, 'block');
+    runBtn.disabled = false;
+    runBtn.textContent = 'Run Simulation';
+  }
+});
+
+// ============================================
+// SSE — Live stream
+// ============================================
+function connectSSE() {
+  const es = new EventSource('/events');
+  es.onmessage = (e) => {
+    try { handleEvent(JSON.parse(e.data)); } catch {}
+  };
+  es.onerror = () => {};
+}
+
+function initChart() {
+  if (typeof Chart === 'undefined') return;
+  const ctx = document.getElementById('chart');
+  chart = new Chart(ctx, {
+    type: 'line',
+    data: {
+      labels: chartLabels,
+      datasets: [
+        { label: 'Baseline', data: baselineImpacts, borderColor: '#ef4444', backgroundColor: 'rgba(239,68,68,0.1)', fill: true, tension: 0.3, pointRadius: 3 },
+        { label: 'Governed', data: governedImpacts, borderColor: '#4ade80', backgroundColor: 'rgba(74,222,128,0.1)', fill: true, tension: 0.3, pointRadius: 3 },
+      ]
+    },
+    options: {
+      animation: { duration: 400 },
+      responsive: true,
+      maintainAspectRatio: false,
+      plugins: { legend: { labels: { color: getComputedStyle(document.body).getPropertyValue('--text-muted').trim() || '#888', font: { family: 'monospace', size: 10 } } } },
+      scales: {
+        x: { ticks: { color: getComputedStyle(document.body).getPropertyValue('--text-muted').trim() || '#888' }, grid: { color: getComputedStyle(document.body).getPropertyValue('--border').trim() || '#2a2a2a' } },
+        y: { ticks: { color: getComputedStyle(document.body).getPropertyValue('--text-muted').trim() || '#888' }, grid: { color: getComputedStyle(document.body).getPropertyValue('--border').trim() || '#2a2a2a' }, min: -1, max: 1 }
+      }
+    }
+  });
+}
+
+function addLog(msg, cls) {
+  const entry = document.createElement('div');
+  entry.style.cssText = 'font-size:10px;color:#666;padding:3px 0;';
+  entry.textContent = msg;
+  logEl.prepend(entry);
+}
+
+function addTraceRound(event) {
+  const el = document.createElement('div');
+  el.className = 'trace-round';
+
+  const phaseCls = event.phase === 'baseline' ? 'baseline' : 'governed';
+  const volatilityPct = (event.maxVolatility * 100).toFixed(0);
+  el.innerHTML = '<div class="trace-round-header" onclick="this.nextElementSibling.dataset.collapsed = this.nextElementSibling.dataset.collapsed === \\'true\\' ? \\'false\\' : \\'true\\'">' +
+    '<span class="trace-phase ' + phaseCls + '">' + event.phase + '</span>' +
+    '<span class="trace-round-label">Round ' + event.round + ' / ' + event.totalRounds + '</span>' +
+    '<span class="trace-round-metrics">' +
+      '<span>avg: ' + event.avgImpact.toFixed(2) + '</span>' +
+      '<span>vol: ' + volatilityPct + '%</span>' +
+      (event.interventionCount > 0 ? '<span style="color:#fbbf24">' + event.interventionCount + ' interventions</span>' : '') +
+    '</span>' +
+  '</div>';
+
+  let bodyHtml = '';
+
+  // 1) Narrative events injected this round
+  const roundEvents = (typeof narrativeEventsByRound !== 'undefined' && narrativeEventsByRound[event.round]) || [];
+  if (roundEvents.length > 0) {
+    bodyHtml += '<div class="trace-section"><div class="trace-section-label event">Event Injection</div>';
+    roundEvents.forEach(function(ev) {
+      bodyHtml += '<div class="trace-event-item">' + ev.headline + ' <span class="trace-event-severity ' + ev.severity + '">' + ev.severity + '</span></div>';
+    });
+    bodyHtml += '</div><div class="trace-arrow">↓</div>';
+  }
+
+  // 2) Agent reactions (cap at 30 to prevent DOM bloat with thousands of agents)
+  var MAX_TRACE_AGENTS = 30;
+  bodyHtml += '<div class="trace-section"><div class="trace-section-label agents">Agent Reactions (' + event.reactions.length + ')</div>';
+  event.reactions.slice(0, MAX_TRACE_AGENTS).forEach(function(r) {
+    const impactCls = r.impact >= 0 ? 'positive' : 'negative';
+    bodyHtml += '<div class="trace-agent-item">' +
+      '<span class="trace-agent-name">' + r.stakeholder_id + '</span>' +
+      '<span class="trace-agent-action">' + r.reaction + '</span>' +
+      '<span class="trace-agent-impact ' + impactCls + '">' + r.impact.toFixed(2) + '</span>' +
+    '</div>';
+  });
+  if (event.reactions.length > MAX_TRACE_AGENTS) {
+    var traceRemaining = event.reactions.length - MAX_TRACE_AGENTS;
+    bodyHtml += '<div style="font-size:10px;color:#444;padding:3px 0 3px 11px;border-left:2px solid #3b82f6;margin-left:2px">+ ' + traceRemaining + ' more agents</div>';
+  }
+  bodyHtml += '</div>';
+
+  // 3) Governance interventions
+  const governed = event.reactions.filter(function(r) { return r.verdict && r.verdict.status !== 'ALLOW'; });
+  if (governed.length > 0) {
+    bodyHtml += '<div class="trace-arrow">↓</div>';
+    bodyHtml += '<div class="trace-section"><div class="trace-section-label governance">Governance Interventions</div>';
+    governed.forEach(function(r) {
+      bodyHtml += '<div class="trace-gov-item">' +
+        '<span class="verdict ' + r.verdict.status + '">' + r.verdict.status + '</span>' +
+        (r.verdict.ruleId ? '<span class="trace-gov-rule">[' + r.verdict.ruleId + ']</span>' : '') +
+        '<span class="trace-gov-reason">' + r.stakeholder_id + ': ' + (r.verdict.reason || '') + '</span>' +
+      '</div>';
+    });
+    bodyHtml += '</div>';
+  }
+
+  // 4) Emergent dynamics
+  if (event.dynamics && event.dynamics.length > 0) {
+    bodyHtml += '<div class="trace-arrow">↓</div>';
+    bodyHtml += '<div class="trace-section"><div class="trace-section-label" style="color:#7c3aed">Emergent Dynamics</div>';
+    event.dynamics.forEach(function(d) {
+      bodyHtml += '<div class="trace-dynamics">' + d + '</div>';
+    });
+    bodyHtml += '</div>';
+  }
+
+  const bodyEl = document.createElement('div');
+  bodyEl.className = 'trace-body';
+  bodyEl.dataset.collapsed = 'false';
+  bodyEl.innerHTML = bodyHtml;
+  el.appendChild(bodyEl);
+
+  logEl.prepend(el);
+}
+
+function renderAgents(reactions) {
+  var MAX_AGENT_ROWS = 50;
+  var shown = reactions.slice(0, MAX_AGENT_ROWS);
+  var html = shown.map(r => {
+    const pct = Math.abs(r.impact) * 50;
+    const cls = r.impact >= 0 ? 'positive' : 'negative';
+    const dir = r.impact >= 0 ? 'right:50%;width:' + pct + '%' : 'left:50%;width:' + pct + '%';
+    const verdictHtml = r.verdict ? ' <span class="verdict ' + r.verdict.status + '">' + r.verdict.status + '</span>' : '';
+    return '<div class="agent-row">' +
+      '<span class="agent-name">' + r.stakeholder_id + verdictHtml + '</span>' +
+      '<div class="impact-bar-bg"><div class="center-line"></div><div class="impact-bar ' + cls + '" style="' + dir + '"></div></div>' +
+      '<span class="impact-val">' + r.impact.toFixed(2) + '</span>' +
+      '</div>';
+  }).join('');
+  if (reactions.length > MAX_AGENT_ROWS) {
+    var remaining = reactions.length - MAX_AGENT_ROWS;
+    var avgImpact = reactions.slice(MAX_AGENT_ROWS).reduce(function(s, r) { return s + r.impact; }, 0) / remaining;
+    html += '<div class="agent-row" style="color:#555;font-size:10px;justify-content:center">+ ' + remaining + ' more agents (avg impact: ' + avgImpact.toFixed(2) + ')</div>';
+  }
+  agentsEl.innerHTML = html;
+}
+
+function handleEvent(event) {
+  if (event.type === 'meta') {
+    statusEl.className = 'status live';
+    statusEl.textContent = 'LIVE';
+    // Show simulation source
+    const src = event.source || 'nv-sim';
+    if (src !== 'nv-sim') {
+      traceSourceEl.textContent = '● ' + src.toUpperCase() + ' (LIVE)';
+      traceSourceEl.style.color = '#4ade80';
+      engineStatusEl.textContent = 'Streaming from ' + src;
+      engineStatusEl.style.color = '#4ade80';
+    } else {
+      traceSourceEl.textContent = '';
+      engineStatusEl.textContent = '';
+    }
+    addLog('Simulation started: ' + event.agents.length + ' agents, ' + event.totalRounds + ' rounds' + (src !== 'nv-sim' ? ' [source: ' + src + ']' : ''));
+    resetShiftTracker();
+    // Store narrative events by round for trace rendering
+    narrativeEventsByRound = {};
+    (event.narrativeEvents || []).forEach(function(ev) {
+      if (!narrativeEventsByRound[ev.round]) narrativeEventsByRound[ev.round] = [];
+      narrativeEventsByRound[ev.round].push(ev);
+    });
+    function parseRuleTitle(id, text) {
+      var parts = text.split(/\s*[—–-]{1,}\s*/);
+      var title = parts.length > 1 ? parts[0].trim() : id.replace(/[-_]/g, ' ');
+      var desc = parts.length > 1 ? parts.slice(1).join(' — ').trim() : text;
+      title = title.replace(/\b\w/g, function(c) { return c.toUpperCase(); });
+      return { title: title, desc: desc };
+    }
+    function generateWhy(text, type) {
+      var t = text.toLowerCase();
+      if (t.includes('liquidity') || t.includes('drain')) return 'Prevents system collapse from liquidity crises';
+      if (t.includes('panic') || t.includes('cascade')) return 'Stops runaway feedback loops during market shocks';
+      if (t.includes('leverage')) return 'Limits systemic risk from over-leveraged positions';
+      if (t.includes('price') || t.includes('pricing')) return 'Stabilizes pricing mechanisms during volatility';
+      if (t.includes('sentiment') || t.includes('consumer')) return 'Tracks behavioral feedback between price and confidence';
+      if (t.includes('military') || t.includes('escalat')) return 'Models how escalation constrains available options';
+      if (t.includes('diplomatic') || t.includes('window')) return 'Preserves negotiation pathways before they close';
+      if (t.includes('grid') || t.includes('capacity')) return 'Prevents infrastructure overload from demand surges';
+      if (t.includes('election') || t.includes('political')) return 'Captures how political pressure amplifies responses';
+      if (t.includes('supply') || t.includes('energy') || t.includes('oil')) return 'Guards against cascading supply chain disruptions';
+      if (t.includes('fraud') || t.includes('suspicious')) return 'Detects and contains anomalous behavior patterns';
+      if (t.includes('withdraw') || t.includes('limit')) return 'Constrains individual actions to protect system stability';
+      if (type === 'gate') return 'Blocks dangerous actions before they propagate';
+      if (type === 'warning') return 'Provides early warning before thresholds are breached';
+      return 'Maintains system integrity under stress conditions';
+    }
+    // Reset per-rule impact counters
+    ruleImpactTracker = {};
+    activeInvEl.innerHTML = event.invariants.map(function(inv) {
+      var parsed = parseRuleTitle(inv.id, inv.description);
+      var why = generateWhy(inv.description, 'invariant');
+      var isUser = inv.source === 'user';
+      var isFull = inv.enforcement === 'full';
+      var enfLabel = isFull ? 'Fully enforced across system' : 'Advisory only';
+      var enfIcon = isFull ? '&#x2713;' : '&#x26A0;';
+      var sourceTag = isUser ? '<span class="rule-source-tag">USER RULE</span>' : '';
+      ruleImpactTracker[inv.id] = { blocks: 0, label: parsed.title };
+      return '<div class="rule-card type-invariant' + (isUser ? ' user-rule' : '') + '" data-rule-id="' + inv.id + '">' +
+        '<div class="rule-header"><span class="rule-icon">&#x1F7E2;</span><span class="rule-title">' + parsed.title + '</span>' + sourceTag + '</div>' +
+        '<div class="rule-desc">' + parsed.desc + '</div>' +
+        '<div class="rule-meta">Invariant &bull; ' + enfIcon + ' ' + enfLabel + '</div>' +
+        '<div class="rule-why">' + why + '</div>' +
+        '<div class="rule-impact" data-impact-id="' + inv.id + '"></div>' +
+      '</div>';
+    }).join('') + event.gates.map(function(g) {
+      var isCritical = g.severity === 'critical';
+      var typeClass = isCritical ? 'type-gate' : 'type-warning';
+      var icon = isCritical ? '&#x1F534;' : '&#x1F7E1;';
+      var typeLabel = isCritical ? 'Gate' : 'Warning';
+      var effect = isCritical ? 'Blocks actions' : 'Signals risk';
+      var why = generateWhy(g.label + ' ' + (g.condition || ''), isCritical ? 'gate' : 'warning');
+      ruleImpactTracker[g.id] = { blocks: 0, label: g.label };
+      return '<div class="rule-card ' + typeClass + '" data-rule-id="' + g.id + '">' +
+        '<div class="rule-header"><span class="rule-icon">' + icon + '</span><span class="rule-title">' + g.label + '</span></div>' +
+        '<div class="rule-desc">' + (g.condition || g.label) + '</div>' +
+        '<div class="rule-meta">' + typeLabel + ' &bull; ' + effect + '</div>' +
+        '<div class="rule-why">' + why + '</div>' +
+        '<div class="rule-impact" data-impact-id="' + g.id + '"></div>' +
+      '</div>';
+    }).join('');
+    initChart();
+  }
+
+  if (event.type === 'round') {
+    if (event.phase === 'baseline') {
+      chartLabels.push('R' + event.round);
+      baselineImpacts.push(event.avgImpact);
+    } else {
+      governedImpacts.push(event.avgImpact);
+    }
+    if (chart) chart.update();
+
+    renderAgents(event.reactions);
+    document.getElementById('m-round').textContent = event.round + '/' + event.totalRounds;
+    document.getElementById('m-volatility').textContent = (event.maxVolatility * 100).toFixed(0) + '%';
+    document.getElementById('m-volatility').parentElement.className = 'metric-box ' + (event.maxVolatility > 0.6 ? 'bad' : event.maxVolatility > 0.4 ? 'warn' : 'good');
+
+    totalInterventions += event.interventionCount;
+    document.getElementById('m-interventions').textContent = totalInterventions;
+
+    // Track system shifts for the card
+    trackShift(event);
+
+    // Render structured trace entry instead of flat log line
+    addTraceRound(event);
+  }
+
+  if (event.type === 'complete') {
+    statusEl.className = 'status complete';
+    statusEl.textContent = 'COMPLETE';
+    const r = event.result;
+    if (r.governed) {
+      document.getElementById('m-stability').textContent = (r.governed.metrics.stabilityScore * 100).toFixed(0) + '%';
+      document.getElementById('m-stability').parentElement.className = 'metric-box ' + (r.governed.metrics.stabilityScore > 0.7 ? 'good' : 'warn');
+      addLog('Complete. Governance effectiveness: ' + (r.comparison.governanceEffectiveness * 100).toFixed(0) + '%');
+      renderSystemShift(r);
+      renderRuleImpacts(r);
+      renderEnforcementClassification(r.enforcementClassification || []);
+      lastSimResult = {
+        stability: r.governed.metrics.stabilityScore,
+        volatility: r.governed.metrics.maxVolatility,
+        collapseProbability: r.governed.metrics.collapseProbability,
+        governanceEffectiveness: r.comparison.governanceEffectiveness,
+      };
+    }
+    runBtn.disabled = false;
+    runBtn.textContent = 'Run Simulation';
+  }
+}
+
+// ============================================
+// PER-RULE IMPACT RENDERING
+// ============================================
+function renderRuleImpacts(result) {
+  var totalBlocks = shiftTracker.blocks;
+  var cascadeAvoided = result && result.governed && result.baseline &&
+    result.governed.metrics.collapseProbability < result.baseline.metrics.collapseProbability;
+
+  Object.keys(ruleImpactTracker).forEach(function(ruleId) {
+    var tracker = ruleImpactTracker[ruleId];
+    var el = document.querySelector('[data-impact-id="' + ruleId + '"]');
+    if (!el) return;
+
+    var html = '';
+    if (tracker.blocks > 0) {
+      html += '<span class="impact-stat">' + tracker.blocks + ' action' + (tracker.blocks > 1 ? 's' : '') + ' blocked</span>';
+      if (cascadeAvoided) {
+        html += ' <span class="impact-label">&rarr; cascade avoided</span>';
+      } else {
+        html += ' <span class="impact-label">&rarr; behavior modified</span>';
+      }
+    } else {
+      // Rule was present but didn't fire — still useful info
+      html += '<span class="impact-label">No violations detected &mdash; agents complied</span>';
+    }
+    el.innerHTML = html;
+    el.classList.add('visible');
+  });
+}
+
+// ============================================
+// ENFORCEMENT CLASSIFICATION — Full vs Advisory
+// ============================================
+function renderEnforcementClassification(entries) {
+  if (!entries || entries.length === 0) return;
+  entries.forEach(function(entry) {
+    var card = document.querySelector('[data-rule-id="' + entry.id + '"]');
+    if (!card) return;
+    var metaEl = card.querySelector('.rule-meta');
+    if (!metaEl) return;
+    if (entry.level === 'full' && entry.fired) {
+      metaEl.innerHTML = 'Invariant &bull; &#x2713; Fully enforced &bull; <span style="color:#22c55e;font-weight:600">FIRED</span>';
+      card.style.borderLeftColor = '#22c55e';
+    } else if (entry.level === 'full' && !entry.fired) {
+      metaEl.innerHTML = 'Invariant &bull; &#x2713; Fully enforced &bull; <span style="color:var(--text-muted)">standby</span>';
+    } else if (entry.level === 'advisory') {
+      metaEl.innerHTML = 'Invariant &bull; &#x26A0; Advisory only &bull; <span style="color:var(--text-muted)">monitored</span>';
+      card.style.borderLeftColor = '#6b7280';
+      card.style.opacity = '0.75';
+    }
+  });
+}
+
+// ============================================
+// SYSTEM SHIFT CARD — The Demo Moment
+// ============================================
+const ssCard = document.getElementById('system-shift');
+const ssRuleEl = document.getElementById('ss-rule');
+const ssAdaptRateEl = document.getElementById('ss-adapt-rate');
+const ssAdaptDescEl = document.getElementById('ss-adapt-desc');
+const ssShiftsEl = document.getElementById('ss-shifts');
+const ssPatternsEl = document.getElementById('ss-patterns');
+const ssImpactsEl = document.getElementById('ss-impacts');
+const ssNarrativeEl = document.getElementById('ss-narrative');
+
+// Raw detail toggle
+document.getElementById('ss-raw-toggle').addEventListener('click', function() {
+  this.classList.toggle('open');
+  document.getElementById('ss-raw-detail').classList.toggle('open');
+});
+
+let shiftTracker = { blocks: 0, total: 0, shifts: {}, patterns: [], baselineVol: 0, governedVol: 0, narrative: '', rawGoverned: [] };
+
+function resetShiftTracker() {
+  shiftTracker = { blocks: 0, total: 0, shifts: {}, patterns: [], baselineVol: 0, governedVol: 0, narrative: '', rawGoverned: [] };
+  ssCard.classList.remove('visible');
+  var rawToggle = document.getElementById('ss-raw-toggle');
+  var rawDetail = document.getElementById('ss-raw-detail');
+  if (rawToggle) rawToggle.classList.remove('open');
+  if (rawDetail) rawDetail.classList.remove('open');
+}
+
+function trackShift(event) {
+  if (!event.reactions) return;
+  const governed = event.reactions.filter(function(r) { return r.verdict && r.verdict.status !== 'ALLOW'; });
+  shiftTracker.blocks += governed.length;
+  shiftTracker.total += event.reactions.length;
+  governed.forEach(function(r) {
+    const key = r.verdict.status + ': ' + (r.reaction || 'adapted');
+    shiftTracker.shifts[key] = (shiftTracker.shifts[key] || 0) + 1;
+    // Track per-rule impacts for card display
+    var ruleId = r.verdict.ruleId || '';
+    if (ruleId && ruleImpactTracker[ruleId]) {
+      ruleImpactTracker[ruleId].blocks++;
+    } else {
+      // Try to match by pattern — governance may report with NV- prefix
+      Object.keys(ruleImpactTracker).forEach(function(k) {
+        if (ruleId.includes(k) || (r.verdict.reason && r.verdict.reason.toLowerCase().includes(ruleImpactTracker[k].label.toLowerCase()))) {
+          ruleImpactTracker[k].blocks++;
+        }
+      });
+    }
+    // Store raw governed reactions for detail view
+    shiftTracker.rawGoverned.push({
+      agent: r.stakeholder_id,
+      action: r.reaction,
+      status: r.verdict.status,
+      reason: r.verdict.reason || '',
+      round: event.round,
+    });
+  });
+  if (event.phase === 'baseline') shiftTracker.baselineVol = Math.max(shiftTracker.baselineVol, event.maxVolatility || 0);
+  if (event.phase === 'governed') shiftTracker.governedVol = Math.max(shiftTracker.governedVol, event.maxVolatility || 0);
+  if (event.dynamics) {
+    event.dynamics.forEach(function(d) {
+      if (shiftTracker.patterns.indexOf(d) === -1) shiftTracker.patterns.push(d);
+    });
+  }
+}
+
+function renderSystemShift(result) {
+  if (shiftTracker.blocks === 0) return;
+
+  var adaptRate = shiftTracker.total > 0 ? Math.round((shiftTracker.blocks / shiftTracker.total) * 100) : 0;
+
+  // Determine rule label from world
+  var ruleName = 'Governance Rules Active';
+  if (currentWorld && currentWorld.invariants) {
+    var names = currentWorld.invariants.map(function(inv) { return inv.description || inv.id; });
+    ruleName = names.slice(0, 2).join(' + ');
+  }
+
+  ssRuleEl.textContent = ruleName;
+  ssAdaptRateEl.textContent = adaptRate + '%';
+  ssAdaptDescEl.textContent = 'adaptation across ' + shiftTracker.total.toLocaleString() + ' agents';
+
+  // Scale line — proves this is real
+  var scaleEl = document.getElementById('ss-scale');
+  scaleEl.innerHTML = '<strong>' + shiftTracker.blocks.toLocaleString() + '</strong> actions reshaped out of <strong>' + shiftTracker.total.toLocaleString() + '</strong> total';
+
+  // Shifts — show top 5 by count, collapse the rest
+  var shiftHtml = '';
+  var shiftKeys = Object.keys(shiftTracker.shifts).sort(function(a, b) {
+    return shiftTracker.shifts[b] - shiftTracker.shifts[a];
+  });
+  var MAX_SHIFTS = 5;
+  shiftKeys.slice(0, MAX_SHIFTS).forEach(function(k) {
+    shiftHtml += '<div class="ss-shift-item"><span class="ss-shift-arrow">→</span> ' + k + ' (' + shiftTracker.shifts[k] + ' agents)</div>';
+  });
+  if (shiftKeys.length > MAX_SHIFTS) {
+    var remaining = shiftKeys.slice(MAX_SHIFTS).reduce(function(sum, k) { return sum + shiftTracker.shifts[k]; }, 0);
+    shiftHtml += '<div class="ss-shift-item" style="color:#555">+ ' + (shiftKeys.length - MAX_SHIFTS) + ' more patterns (' + remaining + ' agents)</div>';
+  }
+  ssShiftsEl.innerHTML = shiftHtml;
+
+  // Patterns
+  var patternHtml = '';
+  if (shiftTracker.patterns.length > 0) {
+    shiftTracker.patterns.forEach(function(p) {
+      patternHtml += '<span class="ss-pattern-tag">' + p + '</span>';
+    });
+  } else {
+    // Infer patterns from data
+    if (shiftTracker.blocks >= 3) patternHtml += '<span class="ss-pattern-tag">Coordinated Holding</span>';
+    if (shiftTracker.blocks >= 2) patternHtml += '<span class="ss-pattern-tag">Panic Suppression</span>';
+    if (shiftTracker.governedVol < shiftTracker.baselineVol) patternHtml += '<span class="ss-pattern-tag">Stability Shift</span>';
+  }
+  ssPatternsEl.innerHTML = patternHtml || '<span style="font-size:11px;color:#555">No emergent patterns detected</span>';
+
+  // Impact
+  var impactHtml = '';
+  var volDelta = shiftTracker.governedVol - shiftTracker.baselineVol;
+  impactHtml += '<div class="ss-impact-row"><span>Volatility</span><span class="ss-impact-delta' + (volDelta > 0 ? ' negative' : '') + '">' +
+    (shiftTracker.baselineVol * 100).toFixed(0) + '% → ' + (shiftTracker.governedVol * 100).toFixed(0) + '%</span></div>';
+
+  if (result && result.governed && result.baseline) {
+    var stabDelta = result.governed.metrics.stabilityScore - result.baseline.metrics.stabilityScore;
+    impactHtml += '<div class="ss-impact-row"><span>Stability</span><span class="ss-impact-delta">' +
+      (result.baseline.metrics.stabilityScore * 100).toFixed(0) + '% → ' + (result.governed.metrics.stabilityScore * 100).toFixed(0) + '%</span></div>';
+
+    var cascadeAvoided = result.governed.metrics.collapseProbability < result.baseline.metrics.collapseProbability;
+    if (cascadeAvoided) {
+      impactHtml += '<div class="ss-impact-row"><span>Cascade</span><span class="ss-impact-delta">Avoided</span></div>';
+    }
+  }
+  ssImpactsEl.innerHTML = impactHtml;
+
+  // Narrative — tight cause → shift → outcome
+  var topShift = shiftKeys.length > 0 ? shiftKeys[0].split(': ')[1] || 'adapted' : 'adapted';
+  var narrative = '';
+
+  // What was the rule?
+  narrative += ruleName + '. ';
+
+  // What shifted?
+  narrative += shiftTracker.blocks + ' of ' + shiftTracker.total + ' agents reorganized';
+  if (topShift !== 'adapted') narrative += ' — most shifted to ' + topShift;
+  narrative += '. ';
+
+  // What emerged?
+  if (shiftTracker.patterns.length > 0) {
+    narrative += 'Pattern: ' + shiftTracker.patterns.slice(0, 2).join(', ') + '. ';
+  }
+
+  // What was the outcome?
+  if (volDelta < 0) narrative += 'Volatility dropped ' + Math.abs(volDelta * 100).toFixed(0) + '%.';
+  else if (volDelta === 0) narrative += 'System held steady.';
+  else narrative += 'Volatility increased ' + (volDelta * 100).toFixed(0) + '% — rules need tuning.';
+
+  ssNarrativeEl.textContent = narrative;
+
+  // Raw detail — virtualized list of governed actions (collapsed by default)
+  var rawListEl = document.getElementById('ss-raw-list');
+  var MAX_RAW = 100;
+  var rawItems = shiftTracker.rawGoverned.slice(0, MAX_RAW);
+  var rawHtml = rawItems.map(function(r) {
+    return '<div class="ss-raw-item">' +
+      '<span class="raw-agent">' + r.agent + '</span>' +
+      '<span class="raw-action">R' + r.round + ': ' + r.action + '</span>' +
+      '<span class="raw-verdict ' + r.status + '">' + r.status + '</span>' +
+    '</div>';
+  }).join('');
+  if (shiftTracker.rawGoverned.length > MAX_RAW) {
+    rawHtml += '<div style="font-size:10px;color:#444;padding:4px 0">+ ' + (shiftTracker.rawGoverned.length - MAX_RAW) + ' more governed actions</div>';
+  }
+  rawListEl.innerHTML = rawHtml;
+
+  ssCard.classList.add('visible');
+}
+
+// ============================================
+// WORLD VARIANTS — Save / Load / Delete
+// ============================================
+const variantListEl = document.getElementById('variant-list');
+const saveBtn = document.getElementById('save-btn');
+const saveForm = document.getElementById('save-form');
+const confirmSaveBtn = document.getElementById('confirm-save-btn');
+const cancelSaveBtn = document.getElementById('cancel-save-btn');
+const variantNameInput = document.getElementById('variant-name');
+const variantDescInput = document.getElementById('variant-desc');
+let lastSimResult = null;
+
+saveBtn.addEventListener('click', () => {
+  saveForm.style.display = saveForm.style.display === 'none' ? '' : 'none';
+  variantNameInput.focus();
+});
+
+cancelSaveBtn.addEventListener('click', () => {
+  saveForm.style.display = 'none';
+});
+
+confirmSaveBtn.addEventListener('click', async () => {
+  const name = variantNameInput.value.trim();
+  if (!name || !currentWorld) return;
+
+  // Gather current state overrides
+  const stateOverrides = {};
+  if (currentWorld.stateVariables) {
+    currentWorld.stateVariables.forEach(sv => {
+      const el = document.getElementById('sv-' + sv.id);
+      if (!el) return;
+      if (sv.type === 'number') stateOverrides[sv.id] = parseFloat(el.value);
+      else if (sv.type === 'boolean') stateOverrides[sv.id] = el.classList.contains('on');
+      else stateOverrides[sv.id] = el.value;
+    });
+  }
+
+  const payload = {
+    name,
+    description: variantDescInput.value.trim(),
+    baseWorld: currentWorld.id,
+    stateOverrides,
+    events: injectedEvents.slice(),
+    rounds: parseInt(roundsSlider.value),
+    lastResult: lastSimResult,
+  };
+
+  try {
+    const resp = await fetch('/api/save-variant', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    const data = await resp.json();
+    if (data.status === 'saved') {
+      addLog('Variant saved: ' + data.variant.name + ' (' + data.variant.id + ')', '');
+      saveForm.style.display = 'none';
+      variantNameInput.value = '';
+      variantDescInput.value = '';
+      await loadVariants();
+    }
+  } catch (err) {
+    addLog('Error saving variant: ' + err.message, 'block');
+  }
+});
+
+async function loadVariants() {
+  try {
+    const resp = await fetch('/api/variants');
+    const data = await resp.json();
+    renderVariants(data.variants || []);
+  } catch {}
+}
+
+function renderVariants(variants) {
+  if (variants.length === 0) {
+    variantListEl.innerHTML = '<div style="font-size:11px;color:#333">No saved variants yet</div>';
+    return;
+  }
+  variantListEl.innerHTML = variants.map(v => {
+    const resultHtml = v.lastResult
+      ? '<span class="vresult">Stability: ' + (v.lastResult.stability * 100).toFixed(0) + '% | Effectiveness: ' + (v.lastResult.governanceEffectiveness * 100).toFixed(0) + '%</span>'
+      : '<span style="color:#555">Not yet run</span>';
+    return '<div class="variant-card" data-vid="' + v.id + '">' +
+      '<div class="vname">' + v.name + '</div>' +
+      (v.description ? '<div class="vdesc">' + v.description + '</div>' : '') +
+      '<span class="vbase">' + v.baseWorld + '</span>' +
+      '<div class="vmeta">' + resultHtml + ' | ' + v.events.length + ' events | ' + v.rounds + ' rounds</div>' +
+      '<span class="vdelete" data-vid="' + v.id + '">delete</span>' +
+      '</div>';
+  }).join('');
+
+  // Bind load handlers
+  variantListEl.querySelectorAll('.variant-card').forEach(card => {
+    card.addEventListener('click', (e) => {
+      if (e.target.classList.contains('vdelete')) return;
+      const vid = card.dataset.vid;
+      const v = variants.find(x => x.id === vid);
+      if (v) loadVariant(v);
+    });
+  });
+
+  // Bind delete handlers
+  variantListEl.querySelectorAll('.vdelete').forEach(el => {
+    el.addEventListener('click', async (e) => {
+      e.stopPropagation();
+      const vid = el.dataset.vid;
+      if (!confirm('Delete variant "' + vid + '"?')) return;
+      try {
+        await fetch('/api/delete-variant/' + vid, { method: 'DELETE' });
+        addLog('Variant deleted: ' + vid, '');
+        await loadVariants();
+      } catch {}
+    });
+  });
+}
+
+function loadVariant(variant) {
+  // Set world
+  selectWorld(variant.baseWorld);
+
+  // Apply state overrides
+  if (variant.stateOverrides && currentWorld && currentWorld.stateVariables) {
+    currentWorld.stateVariables.forEach(sv => {
+      if (sv.id in variant.stateOverrides) {
+        const el = document.getElementById('sv-' + sv.id);
+        if (!el) return;
+        if (sv.type === 'boolean') {
+          const val = variant.stateOverrides[sv.id];
+          if (val && !el.classList.contains('on')) el.classList.add('on');
+          if (!val && el.classList.contains('on')) el.classList.remove('on');
+        } else {
+          el.value = variant.stateOverrides[sv.id];
+          // Update value display for sliders
+          const valEl = document.getElementById('sv-val-' + sv.id);
+          if (valEl) valEl.textContent = variant.stateOverrides[sv.id];
+        }
+      }
+    });
+  }
+
+  // Set events
+  injectedEvents = variant.events.slice();
+  renderInjectedEvents();
+
+  // Set rounds
+  roundsSlider.value = Math.min(variant.rounds, 12);
+  roundsVal.textContent = Math.min(variant.rounds, 12);
+
+  addLog('Loaded variant: ' + variant.name, '');
+}
+
+// ============================================
+// CAPTURE LAST RESULT FOR VARIANT SAVING
+// ============================================
+// (override handleEvent to capture results)
+const _origHandleEvent = handleEvent;
+handleEvent = function(event) {
+  _origHandleEvent(event);
+  if (event.type === 'complete' && event.result && event.result.governed) {
+    lastSimResult = {
+      stability: event.result.governed.metrics.stabilityScore,
+      volatility: event.result.governed.metrics.maxVolatility,
+      collapseProbability: event.result.governed.metrics.collapseProbability,
+      governanceEffectiveness: event.result.comparison.governanceEffectiveness,
+    };
+  }
+};
+
+// ============================================
+// THEME TOGGLE — Light / Dark mode
+// ============================================
+const themeToggleBtn = document.getElementById('theme-toggle');
+function applyTheme(theme) {
+  if (theme === 'light') {
+    document.body.classList.add('light');
+    themeToggleBtn.textContent = 'Dark Mode';
+  } else {
+    document.body.classList.remove('light');
+    themeToggleBtn.textContent = 'Light Mode';
+  }
+  localStorage.setItem('nv-theme', theme);
+  // Update chart colors if chart exists
+  if (chart && chart.options) {
+    const gridColor = theme === 'light' ? '#d4d4d4' : '#2a2a2a';
+    const tickColor = theme === 'light' ? '#666' : '#888';
+    const legendColor = theme === 'light' ? '#444' : '#888';
+    chart.options.scales.x.ticks.color = tickColor;
+    chart.options.scales.x.grid.color = gridColor;
+    chart.options.scales.y.ticks.color = tickColor;
+    chart.options.scales.y.grid.color = gridColor;
+    chart.options.plugins.legend.labels.color = legendColor;
+    chart.update();
+  }
+}
+themeToggleBtn.addEventListener('click', () => {
+  const current = document.body.classList.contains('light') ? 'light' : 'dark';
+  applyTheme(current === 'light' ? 'dark' : 'light');
+});
+// Restore saved theme
+const savedTheme = localStorage.getItem('nv-theme');
+if (savedTheme) applyTheme(savedTheme);
+
+// ============================================
+// PLAIN-ENGLISH RULE EDITOR
+// ============================================
+const ruleInput = document.getElementById('rule-input');
+const parseRulesBtn = document.getElementById('parse-rules-btn');
+const parsedRulesEl = document.getElementById('parsed-rules');
+const ruleStatusEl = document.getElementById('rule-status');
+let parsedRuleData = [];
+
+parseRulesBtn.addEventListener('click', async () => {
+  const text = ruleInput.value.trim();
+  if (!text) return;
+
+  parseRulesBtn.disabled = true;
+  parseRulesBtn.textContent = 'Parsing...';
+  ruleStatusEl.textContent = '';
+  ruleStatusEl.className = 'rule-status';
+
+  try {
+    const resp = await fetch('/api/parse-rules', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text, worldId: currentWorld ? currentWorld.id : 'trading' }),
+    });
+    const data = await resp.json();
+
+    if (data.error) {
+      ruleStatusEl.textContent = data.error;
+      ruleStatusEl.className = 'rule-status error';
+      parsedRulesEl.innerHTML = '';
+      parsedRuleData = [];
+    } else {
+      parsedRuleData = data.rules || [];
+      parsedRulesEl.innerHTML = parsedRuleData.map((r, i) => {
+        const enfType = r.enforcement || 'block';
+        const iconMap = { block: '&#x1F534;', allow: '&#x1F7E2;', modify: '&#x1F535;', warn: '&#x1F7E1;', pause: '&#x1F7E1;' };
+        const labelMap = { block: 'Gate', allow: 'Invariant', modify: 'Modifier', warn: 'Warning', pause: 'Warning' };
+        const effectMap = { block: 'Blocks actions', allow: 'Always enforced', modify: 'Adjusts behavior', warn: 'Signals risk', pause: 'Signals risk' };
+        const icon = iconMap[enfType] || '&#x1F7E2;';
+        const label = labelMap[enfType] || 'Rule';
+        const effect = effectMap[enfType] || 'Active';
+        return '<div class="parsed-rule enforcement-' + enfType + '">' +
+          '<div class="pr-header"><span class="pr-icon">' + icon + '</span><span class="pr-action">' + label + '</span></div>' +
+          '<div class="pr-desc">' + r.description + '</div>' +
+          '<div class="pr-patterns">' + effect + ' &bull; Matches: ' + r.intent_patterns.join(', ') + '</div>' +
+          '</div>';
+      }).join('');
+
+      if (parsedRuleData.length > 0) {
+        parsedRulesEl.innerHTML += '<button class="btn btn-apply-rules" id="apply-rules-btn">Apply ' + parsedRuleData.length + ' Rule' + (parsedRuleData.length > 1 ? 's' : '') + ' to Simulation</button>';
+        document.getElementById('apply-rules-btn').addEventListener('click', async () => {
+          try {
+            const applyResp = await fetch('/api/apply-rules', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ rules: parsedRuleData, worldId: currentWorld ? currentWorld.id : 'trading' }),
+            });
+            const applyData = await applyResp.json();
+            if (applyData.status === 'applied') {
+              ruleStatusEl.textContent = applyData.applied + ' rule(s) active. Run a simulation to see the effect.';
+              ruleStatusEl.className = 'rule-status success';
+            }
+          } catch (err) {
+            ruleStatusEl.textContent = 'Error applying rules: ' + err.message;
+            ruleStatusEl.className = 'rule-status error';
+          }
+        });
+        ruleStatusEl.textContent = 'Parsed ' + parsedRuleData.length + ' rule(s). Review and click Apply.';
+        ruleStatusEl.className = 'rule-status success';
+      }
+    }
+  } catch (err) {
+    ruleStatusEl.textContent = 'Error: ' + err.message;
+    ruleStatusEl.className = 'rule-status error';
+  }
+
+  parseRulesBtn.disabled = false;
+  parseRulesBtn.textContent = 'Parse Rules';
+});
+
+// ============================================
+// SESSION TRACKING
+// ============================================
+
+let sessionPollInterval = null;
+
+async function pollSessionStats() {
+  try {
+    const resp = await fetch('/api/session');
+    const data = await resp.json();
+    const el = (id) => document.getElementById(id);
+    if (el('s-total')) el('s-total').textContent = data.evaluations.total;
+    if (el('s-blocked')) el('s-blocked').textContent = data.evaluations.blocked;
+    if (el('s-modified')) el('s-modified').textContent = data.evaluations.modified;
+    if (el('s-allowed')) el('s-allowed').textContent = data.evaluations.allowed;
+    if (el('s-agents')) {
+      el('s-agents').textContent = data.agents.length > 0
+        ? data.agents.length + ' agent(s): ' + data.agents.slice(0, 5).join(', ') + (data.agents.length > 5 ? '...' : '')
+        : 'No agents connected yet';
+    }
+    if (el('session-history') && data.historyCount > 0) {
+      el('session-history').textContent = data.historyCount + ' previous session(s) saved for comparison';
+    }
+  } catch {}
+}
+
+async function viewSessionReport() {
+  try {
+    const resp = await fetch('/api/session/report');
+    const text = await resp.text();
+    const log = document.getElementById('sim-log');
+    if (log) {
+      const div = document.createElement('div');
+      div.className = 'log-round';
+      div.innerHTML = '<h4 style="color:#818cf8">Enforcement Report</h4><pre style="white-space:pre-wrap;font-size:11px;color:#d4d4d8">' + text.replace(/</g,'&lt;') + '</pre>';
+      log.prepend(div);
+      log.scrollTop = 0;
+    }
+  } catch (err) { console.error('Failed to load report', err); }
+}
+
+async function resetSession() {
+  if (!confirm('Reset session? Current data will be saved for comparison.')) return;
+  try {
+    const resp = await fetch('/api/session/reset', { method: 'POST' });
+    const data = await resp.json();
+    const log = document.getElementById('sim-log');
+    if (log) {
+      const div = document.createElement('div');
+      div.className = 'log-round';
+      div.innerHTML = '<h4 style="color:#fbbf24">Session Reset</h4><div style="font-size:11px;color:#a8a29e">' + data.message + '</div>';
+      log.prepend(div);
+    }
+    pollSessionStats();
+  } catch (err) { console.error('Failed to reset session', err); }
+}
+
+async function saveExperiment() {
+  try {
+    const resp = await fetch('/api/session/save', { method: 'POST' });
+    const data = await resp.json();
+    if (data.error) { alert(data.error); return; }
+    const log = document.getElementById('sim-log');
+    if (log) {
+      const div = document.createElement('div');
+      div.className = 'log-round';
+      div.innerHTML = '<h4 style="color:#4ade80">Experiment Saved</h4><div style="font-size:11px;color:#a8a29e">ID: ' + data.experimentId + '<br>File: ' + data.filePath + '<br>Stability: ' + (data.metrics.stability * 100).toFixed(0) + '% | Effectiveness: ' + (data.metrics.effectiveness * 100).toFixed(0) + '%</div>';
+      log.prepend(div);
+    }
+  } catch (err) { console.error('Failed to save experiment', err); }
+}
+
+// Poll session stats every 2 seconds
+sessionPollInterval = setInterval(pollSessionStats, 2000);
+pollSessionStats();
+
+// ============================================
+// BOOT
+// ============================================
+init();
+<\/script>
+</body>
+</html>`;