@neuroverseos/nv-sim 0.1.4 → 0.1.6

package/dist/engine/liveVisualizer.js

@@ -48,6 +48,7 @@ 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");
@@ -97,9 +98,252 @@ function deleteVariant(variantId) {
  * 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) {
@@ -133,6 +377,18 @@ function startInteractiveServer(port, onReady) {
             });
             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]) {
@@ -156,7 +412,12 @@ function startInteractiveServer(port, onReady) {
             scenario: resolved.scenario,
             worldThesis: world.thesis,
             agents: resolved.stakeholders.map(s => s.id),
-            invariants: world.invariants.map(inv => ({ id: inv.id, description: inv.description })),
+            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,
@@ -372,47 +633,170 @@ function startInteractiveServer(port, onReady) {
                 // Without guards, everything defaults to ALLOW. These guards define what
                 // simulation actions should be governed.
                 if (!nvWorld.guards) {
-                    nvWorld.guards = {
-                        guards: [
-                            {
-                                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,
-                            },
-                        ],
-                        intent_vocabulary: {
-                            "panic_sell": { label: "Panic Sell", pattern: "panic_sell" },
-                            "increase_leverage": { label: "Increase Leverage", pattern: "increase_leverage" },
-                            "aggressive_buy": { label: "Aggressive Buy", pattern: "aggressive_buy" },
-                            "short": { label: "Short Position", pattern: "short" },
+                    // 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
@@ -423,7 +807,7 @@ function startInteractiveServer(port, onReady) {
                     tool: "simulation",
                     scope: `bridge/${payload.actor}`,
                     actionCategory: "execute",
-                    riskLevel: (["panic_sell", "panic_buy", "increase_leverage"].includes(payload.action) ? "high" : "medium"),
+                    riskLevel: (["panic_sell", "panic_buy", "increase_leverage", "create_post", "repost", "quote_post"].includes(payload.action) ? "high" : "medium"),
                     args: {
                         actor: payload.actor,
                         action: payload.action,
@@ -469,6 +853,31 @@ function startInteractiveServer(port, onReady) {
                     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,
@@ -478,6 +887,12 @@ function startInteractiveServer(port, onReady) {
                 });
             }
             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",
@@ -489,6 +904,274 @@ function startInteractiveServer(port, onReady) {
             }
             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 => ({
@@ -616,6 +1299,81 @@ function startInteractiveServer(port, onReady) {
             }
             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);
@@ -632,207 +1390,303 @@ const INTERACTIVE_DASHBOARD_HTML = `<!DOCTYPE html>
 <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: #0a0a0a; color: #e0e0e0; overflow: hidden; }
-  .header { padding: 12px 20px; border-bottom: 1px solid #1a1a1a; display: flex; justify-content: space-between; align-items: center; }
-  .header h1 { font-size: 15px; color: #fff; }
-  .header .sub { font-size: 11px; color: #555; margin-left: 12px; }
+  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: #1a1a2e; color: #818cf8; }
-  .status.live { background: #052e16; color: #4ade80; animation: pulse 2s infinite; }
-  .status.complete { background: #1e1b4b; color: #818cf8; }
+  .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: #0d0d0d; border-right: 1px solid #1a1a1a; overflow-y: auto; padding: 16px; }
+  .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: #555; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 10px; padding-bottom: 6px; border-bottom: 1px solid #1a1a1a; }
+  .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: #888; margin-bottom: 4px; display: flex; justify-content: space-between; }
-  .ctrl-label .val { color: #ccc; font-weight: 600; }
+  .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: #222; border-radius: 2px; outline: none; }
-  input[type="range"]::-webkit-slider-thumb { -webkit-appearance: none; width: 14px; height: 14px; border-radius: 50%; background: #818cf8; cursor: pointer; }
-  input[type="range"]::-moz-range-thumb { width: 14px; height: 14px; border-radius: 50%; background: #818cf8; cursor: pointer; border: none; }
+  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: #111; color: #ccc; border: 1px solid #333; padding: 6px 8px; border-radius: 4px; font-family: inherit; font-size: 12px; }
+  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: #333; border-radius: 10px; cursor: pointer; transition: background 0.2s; }
-  .toggle.on { background: #4ade80; }
+  .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: #999; }
+  .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: #111; color: #ccc; border: 1px solid #333; padding: 4px 6px; border-radius: 4px; font-family: inherit; font-size: 12px; text-align: center; }
+  .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: #888; padding: 3px 6px; background: #111; border-radius: 3px; margin-bottom: 3px; display: flex; justify-content: space-between; }
-  .inject-item .remove { color: #f87171; cursor: pointer; }
+  .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: #4ade80; color: #0a0a0a; }
+  .btn-run { background: var(--green); color: #0a0a0a; }
   .btn-run:hover { background: #22c55e; }
-  .btn-run:disabled { background: #1a3a1a; color: #555; cursor: not-allowed; }
-  .btn-add { background: #222; color: #818cf8; padding: 6px; font-size: 11px; }
-  .btn-add:hover { background: #2a2a3a; }
+  .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: #111; border: 1px solid #222; border-radius: 4px; color: #ccc; font-family: inherit; font-size: 11px; text-align: left; cursor: pointer; }
-  .scenario-btn:hover { border-color: #818cf8; background: #151520; }
-  .scenario-btn .stitle { font-weight: 600; color: #e0e0e0; }
-  .scenario-btn .sdesc { color: #666; font-size: 10px; margin-top: 2px; }
+  .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: #1a1a2e; color: #818cf8; margin-top: 0; }
-  .btn-save:hover { background: #252540; }
-  .btn-confirm { flex: 1; background: #4ade80; color: #0a0a0a; padding: 7px; font-size: 11px; }
-  .btn-cancel { flex: 1; background: #222; color: #888; padding: 7px; font-size: 11px; }
-  .save-input { width: 100%; background: #111; color: #ccc; border: 1px solid #333; padding: 7px 8px; border-radius: 4px; font-family: inherit; font-size: 12px; }
-  .save-input:focus { border-color: #818cf8; outline: none; }
+  .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: #111; border: 1px solid #222; border-radius: 4px; padding: 8px 10px; margin-bottom: 4px; cursor: pointer; position: relative; }
-  .variant-card:hover { border-color: #4ade80; background: #0f1f0f; }
-  .variant-card .vname { font-size: 12px; font-weight: 600; color: #e0e0e0; }
-  .variant-card .vdesc { font-size: 10px; color: #666; margin-top: 2px; }
-  .variant-card .vmeta { font-size: 10px; color: #444; margin-top: 4px; }
-  .variant-card .vmeta .vresult { color: #4ade80; }
-  .variant-card .vdelete { position: absolute; top: 6px; right: 8px; color: #f87171; font-size: 10px; cursor: pointer; opacity: 0; transition: opacity 0.2s; }
+  .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: #1a1a2e; color: #818cf8; border-radius: 3px; margin-top: 3px; }
+  .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: #1a1a1a; }
-  .viewer-mid { display: grid; grid-template-columns: 1fr 1fr; gap: 1px; background: #1a1a1a; overflow: hidden; }
-  .viewer-bottom { background: #0a0a0a; border-top: 1px solid #1a1a1a; padding: 12px 16px; max-height: 180px; overflow-y: auto; }
+  .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: #0a0a0a; padding: 14px; overflow-y: auto; }
-  .vpanel h2 { font-size: 11px; color: #555; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 10px; }
+  .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: #111; border: 1px solid #222; border-radius: 6px; padding: 10px; text-align: center; }
-  .metric-box .value { font-size: 20px; font-weight: 700; color: #fff; }
-  .metric-box .label { font-size: 10px; color: #555; margin-top: 2px; }
-  .metric-box.good .value { color: #4ade80; }
-  .metric-box.bad .value { color: #ef4444; }
-  .metric-box.warn .value { color: #fbbf24; }
+  .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: #777; flex-shrink: 0; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
-  .impact-bar-bg { flex: 1; height: 14px; background: #1a1a1a; border-radius: 3px; position: relative; overflow: hidden; }
+  .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: #4ade80; right: 50%; }
-  .impact-bar.negative { background: #ef4444; left: 50%; }
-  .impact-val { width: 44px; text-align: right; color: #999; font-size: 10px; }
-  .center-line { position: absolute; left: 50%; top: 0; bottom: 0; width: 1px; background: #333; }
+  .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: #052e16; color: #4ade80; }
-  .verdict.BLOCK { background: #2d0606; color: #f87171; }
-  .verdict.PAUSE { background: #2d2006; color: #fbbf24; }
+  .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 #1a1a1a; border-radius: 4px; overflow: hidden; }
-  .trace-round-header { display: flex; align-items: center; gap: 8px; padding: 6px 10px; background: #111; cursor: pointer; user-select: none; }
-  .trace-round-header:hover { background: #181818; }
+  .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: #1e293b; color: #60a5fa; }
-  .trace-phase.governed { background: #052e16; color: #4ade80; }
-  .trace-round-label { font-size: 11px; color: #ccc; font-weight: 600; }
-  .trace-round-metrics { margin-left: auto; font-size: 10px; color: #666; display: flex; gap: 10px; }
+  .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: #555; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 3px; display: flex; align-items: center; gap: 5px; }
+  .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: #e2e8f0; padding: 3px 0 3px 11px; border-left: 2px solid #f59e0b; margin-left: 2px; }
+  .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: #7f1d1d; color: #fca5a5; }
-  .trace-event-severity.moderate { background: #713f12; color: #fde68a; }
-  .trace-event-severity.minor { background: #1e3a2f; color: #86efac; }
+  .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: #93c5fd; font-weight: 500; min-width: 80px; }
-  .trace-agent-action { color: #a1a1aa; flex: 1; }
+  .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: #4ade80; }
-  .trace-agent-impact.negative { color: #f87171; }
+  .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: #999; font-family: monospace; }
-  .trace-gov-reason { color: #d1d5db; flex: 1; }
-  .trace-dynamics { font-size: 10px; color: #a78bfa; padding: 2px 0 2px 11px; border-left: 2px solid #7c3aed; margin-left: 2px; font-style: italic; }
-  .trace-arrow { color: #333; font-size: 10px; text-align: center; padding: 2px 0; }
-  .trace-empty { font-size: 10px; color: #444; font-style: italic; padding: 4px 0; }
+  .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: #ccc; font-style: italic; margin-bottom: 8px; }
-  .inv-item { font-size: 10px; color: #777; padding: 2px 0; }
+  .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: #333; }
+  .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; }
-  .empty-state .hint { font-size: 11px; color: #2a2a2a; margin-top: 6px; }
+  .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 #1a2e1a; border-radius: 8px; background: #0a0f0a; overflow: hidden; animation: fadeInUp 0.4s ease; }
+  .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: #0d150d; border-bottom: 1px solid #1a2e1a; }
-  .ss-icon { width: 8px; height: 8px; border-radius: 50%; background: #4ade80; box-shadow: 0 0 6px #4ade8066; }
-  .ss-title { font-size: 11px; font-weight: 700; color: #4ade80; text-transform: uppercase; letter-spacing: 1.5px; }
-  .ss-rule { font-size: 13px; font-weight: 600; color: #e0e0e0; padding: 10px 14px 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: #111; border: 1px solid #1a1a1a; border-radius: 6px; padding: 10px 12px; }
-  .ss-section-label { font-size: 9px; font-weight: 700; color: #555; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 6px; }
-  .ss-adapt-rate { font-size: 20px; font-weight: 700; color: #4ade80; }
-  .ss-adapt-desc { font-size: 11px; color: #888; margin-top: 2px; }
-  .ss-shift-item { font-size: 11px; color: #999; padding: 2px 0; display: flex; align-items: center; gap: 6px; }
-  .ss-shift-arrow { color: #4ade80; font-weight: 600; }
-  .ss-pattern-tag { display: inline-block; font-size: 10px; padding: 2px 8px; background: #1a1a2e; color: #818cf8; 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: #999; padding: 2px 0; }
-  .ss-impact-delta { color: #4ade80; font-weight: 600; }
-  .ss-impact-delta.negative { color: #f87171; }
-  .ss-narrative { font-size: 12px; color: #ccc; line-height: 1.5; font-style: italic; border-left: 2px solid #4ade80; padding-left: 10px; }
-  .ss-scale { font-size: 10px; color: #555; padding: 0 14px 6px; }
-  .ss-scale strong { color: #888; }
-  .ss-flow { display: flex; align-items: center; gap: 6px; padding: 6px 14px; font-size: 10px; color: #444; }
-  .ss-flow-arrow { color: #4ade80; }
-  .ss-raw-toggle { display: flex; align-items: center; gap: 6px; padding: 8px 12px; background: #0d0d0d; border: none; border-top: 1px solid #1a1a1a; color: #555; font-family: inherit; font-size: 10px; cursor: pointer; width: 100%; text-align: left; transition: color 0.2s; }
-  .ss-raw-toggle:hover { color: #888; }
+  .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: #666; padding: 2px 0; display: flex; gap: 6px; }
-  .ss-raw-item .raw-agent { color: #888; min-width: 100px; }
-  .ss-raw-item .raw-action { color: #999; flex: 1; }
+  .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: #2d0606; color: #f87171; }
-  .ss-raw-item .raw-verdict.MODIFY { background: #2d2006; color: #fbbf24; }
+  .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: #0d0d15; border: 1px solid #1a1a2e; border-radius: 6px; padding: 10px 12px; margin-top: 8px; }
-  .integrate-section h4 { font-size: 10px; color: #818cf8; text-transform: uppercase; letter-spacing: 1px; margin-bottom: 8px; }
-  .integrate-code { font-size: 10px; color: #ccc; background: #111; border: 1px solid #222; border-radius: 4px; padding: 8px; overflow-x: auto; white-space: pre; line-height: 1.5; }
-  .integrate-code .kw { color: #818cf8; }
-  .integrate-code .str { color: #4ade80; }
-  .integrate-code .comment { color: #555; }
-  .integrate-endpoint { font-size: 11px; color: #888; margin-top: 6px; }
-  .integrate-endpoint code { color: #4ade80; background: #111; padding: 1px 5px; border-radius: 3px; }
+  .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>
@@ -841,7 +1695,10 @@ const INTERACTIVE_DASHBOARD_HTML = `<!DOCTYPE html>
     <h1>NV-SIM</h1>
     <span class="sub">Scenario Control Platform</span>
   </div>
-  <span id="status" class="status idle">Ready</span>
+  <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">
@@ -873,6 +1730,25 @@ const INTERACTIVE_DASHBOARD_HTML = `<!DOCTYPE html>
       <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>
@@ -951,6 +1827,24 @@ verdict = evaluate(
           <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>
 
@@ -1050,6 +1944,7 @@ 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');
@@ -1321,10 +2216,10 @@ function initChart() {
       animation: { duration: 400 },
       responsive: true,
       maintainAspectRatio: false,
-      plugins: { legend: { labels: { color: '#888', font: { family: 'monospace', size: 10 } } } },
+      plugins: { legend: { labels: { color: getComputedStyle(document.body).getPropertyValue('--text-muted').trim() || '#888', font: { family: 'monospace', size: 10 } } } },
       scales: {
-        x: { ticks: { color: '#555' }, grid: { color: '#1a1a1a' } },
-        y: { ticks: { color: '#555' }, grid: { color: '#1a1a1a' }, min: -1, max: 1 }
+        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 }
       }
     }
   });
@@ -1461,11 +2356,65 @@ function handleEvent(event) {
       if (!narrativeEventsByRound[ev.round]) narrativeEventsByRound[ev.round] = [];
       narrativeEventsByRound[ev.round].push(ev);
     });
-    activeInvEl.innerHTML = event.invariants.map(inv =>
-      '<div class="inv-item">[' + inv.id + '] ' + inv.description + '</div>'
-    ).join('') + event.gates.map(g =>
-      '<div class="inv-item" style="color:' + (g.severity === 'critical' ? '#f87171' : '#fbbf24') + '">[' + g.id + '] ' + g.label + '</div>'
-    ).join('');
+    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();
   }
 
@@ -1502,6 +2451,8 @@ function handleEvent(event) {
       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,
@@ -1514,6 +2465,59 @@ function handleEvent(event) {
   }
 }
 
+// ============================================
+// 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
 // ============================================
@@ -1551,6 +2555,18 @@ function trackShift(event) {
   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,
@@ -1848,6 +2864,196 @@ handleEvent = function(event) {
   }
 };
 
+// ============================================
+// 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
 // ============================================