@neuroverseos/nv-sim 0.1.2 → 0.1.6

package/dist/engine/scenarioLibrary.js

@@ -0,0 +1,231 @@
+"use strict";
+/**
+ * Scenario Library — Named Multi-Event Stress Scenarios
+ *
+ * The layer that turns NV-SIM from a simulation engine into
+ * a scenario modeling platform.
+ *
+ * Instead of manually wiring events:
+ *   nv-sim compare --inject tanker_explosion@3,sanctions@5
+ *
+ * Users run named scenarios:
+ *   nv-sim scenario taiwan_crisis
+ *
+ * Each scenario bundles a world preset + a sequence of narrative events
+ * that model a realistic multi-phase crisis.
+ *
+ * Usage:
+ *   nv-sim scenario taiwan_crisis
+ *   nv-sim scenario bank_run
+ *   nv-sim scenario oil_shock --compare
+ *   nv-sim scenarios                        # List all
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCENARIO_LIBRARY = void 0;
+exports.resolveScenarioEvents = resolveScenarioEvents;
+exports.getScenariosByCategory = getScenariosByCategory;
+const narrativeInjection_1 = require("./narrativeInjection");
+// ============================================
+// BUILT-IN SCENARIOS
+// ============================================
+exports.SCENARIO_LIBRARY = {
+    // --- Geopolitical ---
+    taiwan_crisis: {
+        id: "taiwan_crisis",
+        title: "Taiwan Strait Crisis",
+        description: "Military escalation near Taiwan triggers cascading economic and diplomatic shocks",
+        world: "strait_of_hormuz",
+        events: [
+            "taiwan_exercises@2",
+            "sanctions@4",
+            "flash_crash_rumor@5",
+            "rate_cut@7",
+        ],
+        compareWorlds: ["trading"],
+        category: "geopolitical",
+        rounds: 8,
+    },
+    hormuz_blockade: {
+        id: "hormuz_blockade",
+        title: "Strait of Hormuz Blockade",
+        description: "Tanker attack escalates to full shipping disruption with energy market cascade",
+        world: "strait_of_hormuz",
+        events: [
+            "tanker_explosion@2",
+            "sanctions@4",
+            "oil_discovery@6",
+        ],
+        compareWorlds: ["gas_price_spike"],
+        category: "geopolitical",
+        rounds: 7,
+    },
+    // --- Financial ---
+    bank_run: {
+        id: "bank_run",
+        title: "Banking Crisis — Contagion Cascade",
+        description: "Major bank insolvency triggers contagion, liquidity crisis, and emergency intervention",
+        world: "trading",
+        events: [
+            "bank_collapse@2",
+            "flash_crash_rumor@3",
+            "rate_cut@4",
+            "stimulus_package@6",
+        ],
+        compareWorlds: ["gas_price_spike"],
+        category: "financial",
+        rounds: 7,
+    },
+    flash_cascade: {
+        id: "flash_cascade",
+        title: "Flash Crash — Multi-Phase Cascade",
+        description: "Algorithmic failure triggers chain reaction across interconnected markets",
+        world: "trading",
+        events: [
+            "flash_crash_rumor@1",
+            "bank_collapse@3",
+            "rate_cut@5",
+        ],
+        category: "financial",
+        rounds: 6,
+    },
+    // --- Energy ---
+    oil_shock: {
+        id: "oil_shock",
+        title: "Oil Supply Shock",
+        description: "Tanker attack + sanctions create compound energy crisis",
+        world: "gas_price_spike",
+        events: [
+            "tanker_explosion@2",
+            "sanctions@4",
+            "grid_failure@5",
+            "oil_discovery@7",
+        ],
+        compareWorlds: ["strait_of_hormuz"],
+        category: "energy",
+        rounds: 8,
+    },
+    energy_transition_shock: {
+        id: "energy_transition_shock",
+        title: "Energy Transition Disruption",
+        description: "Grid failure during rapid transition triggers regulatory and market cascade",
+        world: "gas_price_spike",
+        events: [
+            "grid_failure@2",
+            "regulation_shock@3",
+            "stimulus_package@5",
+        ],
+        category: "energy",
+        rounds: 6,
+    },
+    // --- Political ---
+    election_shock: {
+        id: "election_shock",
+        title: "Election Crisis",
+        description: "Political shock cascades into market and regulatory disruption",
+        world: "trading",
+        events: [
+            "candidate_indicted@2",
+            "flash_crash_rumor@3",
+            "regulation_shock@5",
+            "stimulus_package@6",
+        ],
+        category: "political",
+        rounds: 7,
+    },
+    ai_crackdown: {
+        id: "ai_crackdown",
+        title: "AI Regulatory Crackdown",
+        description: "Overnight AI regulation triggers market panic and sector realignment",
+        world: "ai_regulation_crisis",
+        events: [
+            "regulation_shock@2",
+            "flash_crash_rumor@3",
+            "diplomatic_breakthrough@5",
+        ],
+        compareWorlds: ["trading"],
+        category: "political",
+        rounds: 6,
+    },
+    // --- Compound ---
+    perfect_storm: {
+        id: "perfect_storm",
+        title: "Perfect Storm — Multi-Domain Crisis",
+        description: "Geopolitical, financial, and energy shocks converge simultaneously",
+        world: "trading",
+        events: [
+            "tanker_explosion@1",
+            "bank_collapse@2",
+            "sanctions@3",
+            "grid_failure@4",
+            "rate_cut@5",
+            "ceasefire@7",
+        ],
+        compareWorlds: ["strait_of_hormuz", "gas_price_spike"],
+        category: "compound",
+        rounds: 8,
+    },
+    black_swan: {
+        id: "black_swan",
+        title: "Black Swan Cascade",
+        description: "Extreme low-probability events in rapid succession",
+        world: "trading",
+        events: [
+            "bank_collapse@1",
+            "tanker_explosion@2",
+            "taiwan_exercises@3",
+            "grid_failure@4",
+            "regulation_shock@5",
+        ],
+        compareWorlds: ["strait_of_hormuz"],
+        category: "compound",
+        rounds: 6,
+    },
+};
+// ============================================
+// SCENARIO RESOLUTION
+// ============================================
+/**
+ * Parse a scenario's event list into NarrativeEvent objects.
+ */
+function resolveScenarioEvents(scenario) {
+    const events = [];
+    for (const spec of scenario.events) {
+        const atIdx = spec.lastIndexOf("@");
+        if (atIdx === -1)
+            continue;
+        const eventId = spec.slice(0, atIdx).trim();
+        const round = parseInt(spec.slice(atIdx + 1), 10);
+        if (isNaN(round))
+            continue;
+        const preset = narrativeInjection_1.NARRATIVE_PRESETS[eventId];
+        if (preset) {
+            events.push({ ...preset, round });
+        }
+        else {
+            events.push({
+                id: `custom_${round}`,
+                headline: eventId,
+                round,
+                severity: "major",
+                targets: [],
+                direction: "mixed",
+                propagation: "normal",
+                category: "custom",
+            });
+        }
+    }
+    return events;
+}
+/**
+ * Get all scenarios grouped by category.
+ */
+function getScenariosByCategory() {
+    const grouped = {};
+    for (const scenario of Object.values(exports.SCENARIO_LIBRARY)) {
+        if (!grouped[scenario.category]) {
+            grouped[scenario.category] = [];
+        }
+        grouped[scenario.category].push(scenario);
+    }
+    return grouped;
+}

package/dist/engine/swarmSimulation.js

@@ -19,6 +19,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSwarmSimulation = runSwarmSimulation;
+const aiProvider_1 = require("./aiProvider");
 // ============================================
 // REACTION MODELS
 // ============================================
@@ -205,10 +206,16 @@ function findInflectionPoints(rounds) {
  * This is Echelon's native reaction model — NOT MiroFish.
  * It simulates how stakeholders react to different reasoning paths
  * over multiple rounds, detecting emergent dynamics.
+ *
+ * When ANTHROPIC_API_KEY is set, agents use Claude for real reasoning.
+ * Otherwise, falls back to the deterministic Math.random() model.
  */
 async function runSwarmSimulation(scenario, stakeholders, paths, config) {
     const roundCount = config.rounds ?? 3;
     const model = config.reaction_model ?? "mixed";
+    // Detect if AI reasoning is available and requested
+    const defaultProvider = (0, aiProvider_1.getDefaultProviderName)();
+    const useAI = config.ai_reasoning !== false && defaultProvider !== "deterministic";
     // Filter stakeholders if specific ones requested
     const activeStakeholders = config.simulate_stakeholders
         ? stakeholders.filter((s) => config.simulate_stakeholders.includes(s.id))
@@ -224,8 +231,54 @@ async function runSwarmSimulation(scenario, stakeholders, paths, config) {
     }
     // Run simulation rounds
     const rounds = [];
+    let aiProvider;
+    if (useAI) {
+        try {
+            aiProvider = (0, aiProvider_1.getAIProvider)(defaultProvider);
+        }
+        catch {
+            // No API key or provider unavailable — fall back silently
+        }
+    }
     for (let round = 0; round < roundCount; round++) {
-        const reactions = activeStakeholders.map((stakeholder) => modelReaction(stakeholder, primaryPath, model, round));
+        let reactions;
+        if (aiProvider) {
+            // AI-POWERED REASONING: Each agent gets a Claude call
+            const previousReactions = round > 0
+                ? rounds[round - 1].reactions.map(r => `${r.stakeholder_id}: ${r.reaction}`)
+                : [];
+            reactions = await Promise.all(activeStakeholders.map(async (stakeholder) => {
+                try {
+                    const aiResult = await (0, aiProvider_1.generateAIReaction)({
+                        stakeholderId: stakeholder.id,
+                        stakeholderDescription: stakeholder.description,
+                        stakeholderDisposition: stakeholder.disposition,
+                        stakeholderPriorities: stakeholder.priorities,
+                        scenario,
+                        pathDescription: primaryPath.description,
+                        pathRisk: primaryPath.risk,
+                        round,
+                        previousReactions,
+                        provider: aiProvider,
+                    });
+                    return {
+                        stakeholder_id: stakeholder.id,
+                        reaction: aiResult.reaction,
+                        confidence: aiResult.confidence,
+                        impact: aiResult.impact,
+                        trigger: aiResult.trigger,
+                    };
+                }
+                catch {
+                    // Individual agent fallback to deterministic
+                    return modelReaction(stakeholder, primaryPath, model, round);
+                }
+            }));
+        }
+        else {
+            // DETERMINISTIC: Original Math.random() model
+            reactions = activeStakeholders.map((stakeholder) => modelReaction(stakeholder, primaryPath, model, round));
+        }
         const emergentDynamics = detectEmergentDynamics(reactions);
         rounds.push({
             round,

package/dist/engine/worldComparison.js

@@ -0,0 +1,358 @@
+"use strict";
+/**
+ * World Comparison Engine — Same Swarm, Different Rule Environments
+ *
+ * "NV-SIM lets you run the same swarm through different rule environments
+ *  to see how governance changes emergent behavior."
+ *
+ * Unlike `compare` (baseline vs governed), this runs TWO governed simulations
+ * with different world rules. Same agents, same scenario — only the rules change.
+ *
+ * Usage:
+ *   nv-sim worlds strait_of_hormuz gas_price_spike
+ *   nv-sim worlds trading strait_of_hormuz
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWorld = resolveWorld;
+exports.runWorldComparison = runWorldComparison;
+exports.getAvailableWorlds = getAvailableWorlds;
+exports.explainWorldGovernance = explainWorldGovernance;
+exports.generateComparisonImpact = generateComparisonImpact;
+const scenarioCapsule_1 = require("./scenarioCapsule");
+const governedSimulation_1 = require("./governedSimulation");
+const worldStorage_1 = require("./worldStorage");
+function resolveWorld(presetId) {
+    // Check saved worlds first (browser localStorage)
+    const saved = resolveSavedWorld(presetId);
+    if (saved)
+        return saved;
+    if (presetId === "trading" || presetId === "flash_crash") {
+        return {
+            id: "trading-flash-crash",
+            title: "Flash Crash — Algorithmic Cascade",
+            scenario: governedSimulation_1.TRADING_DEMO.scenario.scenario,
+            stakeholders: governedSimulation_1.TRADING_DEMO.scenario.stakeholders,
+            assumptions: governedSimulation_1.TRADING_DEMO.scenario.assumptions,
+            constraints: governedSimulation_1.TRADING_DEMO.scenario.constraints,
+            swarm: governedSimulation_1.TRADING_DEMO.scenario.swarm,
+            depth: governedSimulation_1.TRADING_DEMO.scenario.depth,
+            world: governedSimulation_1.TRADING_DEMO.world,
+            paths: governedSimulation_1.TRADING_DEMO.paths,
+        };
+    }
+    const template = scenarioCapsule_1.SCENARIO_TEMPLATES[presetId];
+    if (!template) {
+        throw new Error(`Unknown preset: ${presetId}. Available: trading, ${Object.keys(scenarioCapsule_1.SCENARIO_TEMPLATES).join(", ")}`);
+    }
+    if (!template.world?.inline_definition) {
+        throw new Error(`Preset "${presetId}" has no world definition.`);
+    }
+    return {
+        id: template.world.world_id,
+        title: template.title,
+        scenario: template.scenario,
+        stakeholders: template.stakeholders,
+        assumptions: template.assumptions,
+        constraints: template.constraints,
+        swarm: (template.swarm ?? { enabled: true, rounds: 5, reaction_model: "mixed" }),
+        depth: template.depth,
+        world: template.world.inline_definition,
+        paths: [
+            {
+                id: "path_primary",
+                label: "Primary Response",
+                description: "Most likely course of action",
+                projected_outcome: "Moderate disruption with cascading effects",
+                probability: 0.6,
+                risk: "high",
+                tradeoffs: ["Speed vs. thoroughness", "Short-term vs. long-term"],
+                benefits_stakeholders: template.stakeholders.filter(s => s.disposition === "supportive").map(s => s.id),
+                harms_stakeholders: template.stakeholders.filter(s => s.disposition === "hostile").map(s => s.id),
+            },
+            {
+                id: "path_defensive",
+                label: "Defensive Posture",
+                description: "Conservative approach prioritizing stability",
+                projected_outcome: "Reduced damage but slower recovery",
+                probability: 0.7,
+                risk: "moderate",
+                tradeoffs: ["Safety vs. opportunity cost"],
+                benefits_stakeholders: template.stakeholders.filter(s => s.disposition !== "hostile").map(s => s.id),
+                harms_stakeholders: [],
+            },
+        ],
+    };
+}
+/**
+ * Resolve a saved world (from localStorage) into a ResolvedWorld.
+ * Saved worlds get merged with the base preset's scenario/stakeholders
+ * so they work in the comparison engine.
+ */
+function resolveSavedWorld(id) {
+    try {
+        const saved = (0, worldStorage_1.loadWorldFromStorage)(id);
+        if (!saved)
+            return null;
+        // Try to get scenario context from the base preset
+        let baseScenario = `Simulation with custom world: ${saved.world.thesis}`;
+        let baseStakeholders = [
+            { id: "System", disposition: "neutral", priorities: ["stability"] },
+            { id: "Agents", disposition: "unknown", priorities: ["execution"] },
+        ];
+        let baseAssumptions = { severity: "high" };
+        let baseConstraints = {};
+        try {
+            const base = resolveWorld(saved.basePreset);
+            baseScenario = base.scenario;
+            baseStakeholders = base.stakeholders;
+            baseAssumptions = base.assumptions;
+            baseConstraints = base.constraints;
+        }
+        catch {
+            // Base preset not found — use defaults
+        }
+        return {
+            id: saved.id,
+            title: saved.name,
+            scenario: baseScenario,
+            stakeholders: baseStakeholders,
+            assumptions: baseAssumptions,
+            constraints: baseConstraints,
+            swarm: { enabled: true, rounds: 5, reaction_model: "mixed" },
+            depth: "full",
+            world: saved.world,
+            paths: [
+                {
+                    id: "path_primary",
+                    label: "Primary Response",
+                    description: "Most likely course of action",
+                    projected_outcome: "Moderate disruption with cascading effects",
+                    probability: 0.6,
+                    risk: "high",
+                    tradeoffs: ["Speed vs. thoroughness", "Short-term vs. long-term"],
+                    benefits_stakeholders: baseStakeholders.filter(s => s.disposition === "supportive").map(s => s.id),
+                    harms_stakeholders: baseStakeholders.filter(s => s.disposition === "hostile").map(s => s.id),
+                },
+            ],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function runWorldComparison(worldAId, worldBId, options) {
+    const worldADef = resolveWorld(worldAId);
+    const worldBDef = resolveWorld(worldBId);
+    // Use the scenario from world A as the shared scenario,
+    // but merge stakeholders from both worlds for richer simulation
+    const sharedScenario = worldADef.scenario + " " + worldBDef.scenario;
+    const mergedStakeholders = mergeStakeholders(worldADef.stakeholders, worldBDef.stakeholders);
+    // Build paths that work for both worlds
+    const sharedPaths = worldADef.paths;
+    options?.onProgress?.("World A", "simulating");
+    // Run World A governed comparison
+    const resultA = await (0, governedSimulation_1.runGovernedComparison)({
+        scenario: sharedScenario,
+        stakeholders: mergedStakeholders,
+        assumptions: worldADef.assumptions,
+        constraints: worldADef.constraints,
+        depth: worldADef.depth,
+        swarm: worldADef.swarm,
+    }, worldADef.world, sharedPaths);
+    options?.onProgress?.("World B", "simulating");
+    // Run World B governed comparison
+    const resultB = await (0, governedSimulation_1.runGovernedComparison)({
+        scenario: sharedScenario,
+        stakeholders: mergedStakeholders,
+        assumptions: worldBDef.assumptions,
+        constraints: worldBDef.constraints,
+        depth: worldBDef.depth,
+        swarm: worldBDef.swarm,
+    }, worldBDef.world, sharedPaths);
+    // Extract round snapshots
+    const roundsA = extractRoundSnapshots(resultA);
+    const roundsB = extractRoundSnapshots(resultB);
+    // Build delta
+    const metricsA = resultA.governed.metrics;
+    const metricsB = resultB.governed.metrics;
+    const stabilityDiff = metricsA.stabilityScore - metricsB.stabilityScore;
+    const volatilityDiff = metricsA.maxVolatility - metricsB.maxVolatility;
+    const coalitionRiskDiff = metricsA.coalitionRisks - metricsB.coalitionRisks;
+    const collapseDiff = metricsA.collapseProbability - metricsB.collapseProbability;
+    const moreStable = Math.abs(stabilityDiff) < 0.02 ? "equal"
+        : stabilityDiff > 0 ? "A" : "B";
+    const narrative = buildWorldNarrative(worldADef, worldBDef, metricsA, metricsB, moreStable);
+    return {
+        scenario: sharedScenario,
+        worldA: {
+            id: worldAId,
+            thesis: worldADef.world.thesis,
+            invariantCount: worldADef.world.invariants.length,
+            gateCount: (worldADef.world.gates ?? []).length,
+            metrics: metricsA,
+            trajectory: resultA.governed.swarm.trajectory,
+            governanceStats: resultA.governanceStats,
+            rounds: roundsA,
+        },
+        worldB: {
+            id: worldBId,
+            thesis: worldBDef.world.thesis,
+            invariantCount: worldBDef.world.invariants.length,
+            gateCount: (worldBDef.world.gates ?? []).length,
+            metrics: metricsB,
+            trajectory: resultB.governed.swarm.trajectory,
+            governanceStats: resultB.governanceStats,
+            rounds: roundsB,
+        },
+        delta: {
+            stabilityDiff: Number((stabilityDiff * 100).toFixed(1)),
+            volatilityDiff: Number((volatilityDiff * 100).toFixed(1)),
+            coalitionRiskDiff,
+            collapseDiff: Number((collapseDiff * 100).toFixed(1)),
+            moreStable,
+            narrative,
+        },
+    };
+}
+function mergeStakeholders(a, b) {
+    const seen = new Set();
+    const merged = [];
+    for (const s of [...a, ...b]) {
+        if (!seen.has(s.id)) {
+            seen.add(s.id);
+            merged.push(s);
+        }
+    }
+    return merged;
+}
+function extractRoundSnapshots(result) {
+    return result.governed.swarm.rounds.map((r) => ({
+        round: r.round,
+        avgImpact: r.reactions.reduce((s, rx) => s + rx.impact, 0) / r.reactions.length,
+        maxVolatility: Math.max(...r.reactions.map((rx) => Math.abs(rx.impact))),
+        agentImpacts: r.reactions.map((rx) => ({
+            id: rx.stakeholder_id,
+            impact: rx.impact,
+            confidence: rx.confidence,
+        })),
+        interventions: r.emergent_dynamics ?? [],
+    }));
+}
+function buildWorldNarrative(worldA, worldB, metricsA, metricsB, moreStable) {
+    const parts = [];
+    parts.push(`World A ("${worldA.world.thesis.slice(0, 60)}...") vs World B ("${worldB.world.thesis.slice(0, 60)}...").`);
+    if (moreStable === "A") {
+        parts.push(`World A produced a more stable system (${(metricsA.stabilityScore * 100).toFixed(0)}% vs ${(metricsB.stabilityScore * 100).toFixed(0)}%).`);
+    }
+    else if (moreStable === "B") {
+        parts.push(`World B produced a more stable system (${(metricsB.stabilityScore * 100).toFixed(0)}% vs ${(metricsA.stabilityScore * 100).toFixed(0)}%).`);
+    }
+    else {
+        parts.push(`Both worlds produced similar stability levels.`);
+    }
+    const invDiff = worldA.world.invariants.length - worldB.world.invariants.length;
+    if (invDiff !== 0) {
+        parts.push(`World ${invDiff > 0 ? "A" : "B"} has ${Math.abs(invDiff)} more invariant${Math.abs(invDiff) > 1 ? "s" : ""}, providing tighter structural constraints.`);
+    }
+    parts.push("Same agents, different rules — the world shapes the outcome.");
+    return parts.join(" ");
+}
+/**
+ * Get all available world presets for the comparison picker.
+ */
+function getAvailableWorlds() {
+    const worlds = [
+        {
+            id: "trading",
+            title: "Flash Crash — Algorithmic Cascade",
+            thesis: governedSimulation_1.TRADING_DEMO.world.thesis,
+            invariantCount: governedSimulation_1.TRADING_DEMO.world.invariants.length,
+            gateCount: (governedSimulation_1.TRADING_DEMO.world.gates ?? []).length,
+        },
+    ];
+    for (const [key, template] of Object.entries(scenarioCapsule_1.SCENARIO_TEMPLATES)) {
+        if (template.world?.inline_definition) {
+            worlds.push({
+                id: key,
+                title: template.title,
+                thesis: template.world.inline_definition.thesis,
+                invariantCount: template.world.inline_definition.invariants.length,
+                gateCount: (template.world.inline_definition.gates ?? []).length,
+            });
+        }
+    }
+    return worlds;
+}
+/**
+ * Generate a plain-English explanation of a world's governance posture.
+ * Uses the governance engine's own data — no LLM needed.
+ */
+function explainWorldGovernance(presetId) {
+    const world = resolveWorld(presetId);
+    const invariants = world.world.invariants;
+    const gates = world.world.gates ?? [];
+    const enforceableCount = invariants.filter(i => i.enforceable).length;
+    const advisoryCount = invariants.length - enforceableCount;
+    const invariantSummary = invariants.length === 0
+        ? "No invariants defined — ungoverned."
+        : `${invariants.length} rules (${enforceableCount} enforced, ${advisoryCount} advisory): ${invariants.map(i => i.description).join("; ")}`;
+    const criticalGates = gates.filter(g => g.severity === "critical");
+    const warningGates = gates.filter(g => g.severity === "warning");
+    const gateSummary = gates.length === 0
+        ? "No viability gates — no collapse detection."
+        : `${gates.length} gates (${criticalGates.length} critical, ${warningGates.length} warning): ${gates.map(g => `${g.label} [${g.severity}]`).join(", ")}`;
+    const riskProfile = criticalGates.length >= 2 ? "high"
+        : criticalGates.length >= 1 || warningGates.length >= 2 ? "moderate"
+            : "low";
+    return {
+        worldId: presetId,
+        title: world.title,
+        thesis: world.world.thesis,
+        invariantSummary,
+        gateSummary,
+        riskProfile,
+    };
+}
+/**
+ * Generate a counterfactual impact summary from comparison results.
+ * "What would have happened without these rules?"
+ *
+ * Powered by @neuroverseos/governance engine data.
+ */
+function generateComparisonImpact(result) {
+    const { worldA, worldB, delta } = result;
+    const winner = delta.moreStable;
+    const winnerSide = winner === "A" ? worldA : winner === "B" ? worldB : worldA;
+    const loserSide = winner === "A" ? worldB : winner === "B" ? worldA : worldB;
+    const interventionDiff = winnerSide.governanceStats.totalEvaluations - loserSide.governanceStats.totalEvaluations;
+    const blockDiff = winnerSide.governanceStats.verdicts.block - loserSide.governanceStats.verdicts.block;
+    const keyFindings = [];
+    if (Math.abs(delta.stabilityDiff) >= 5) {
+        keyFindings.push(`${Math.abs(delta.stabilityDiff).toFixed(0)}% stability ${delta.stabilityDiff > 0 ? "advantage for World A" : "advantage for World B"}`);
+    }
+    if (Math.abs(delta.collapseDiff) >= 5) {
+        keyFindings.push(`${Math.abs(delta.collapseDiff).toFixed(0)}% ${delta.collapseDiff > 0 ? "higher" : "lower"} cascade risk in World A`);
+    }
+    if (blockDiff !== 0) {
+        keyFindings.push(`${Math.abs(blockDiff)} more governance interventions in ${blockDiff > 0 ? "World A" : "World B"}`);
+    }
+    if (Math.abs(delta.volatilityDiff) >= 5) {
+        keyFindings.push(`${Math.abs(delta.volatilityDiff).toFixed(0)}% volatility ${delta.volatilityDiff > 0 ? "higher in A" : "higher in B"}`);
+    }
+    if (keyFindings.length === 0) {
+        keyFindings.push("Both worlds produced similar outcomes — rules had minimal differential effect.");
+    }
+    return {
+        winner,
+        stabilityDelta: `${delta.stabilityDiff > 0 ? "+" : ""}${delta.stabilityDiff.toFixed(1)}%`,
+        cascadeRiskDelta: `${delta.collapseDiff > 0 ? "+" : ""}${delta.collapseDiff.toFixed(1)}%`,
+        volatilityDelta: `${delta.volatilityDiff > 0 ? "+" : ""}${delta.volatilityDiff.toFixed(1)}%`,
+        totalInterventionsA: worldA.governanceStats.totalEvaluations,
+        totalInterventionsB: worldB.governanceStats.totalEvaluations,
+        blockedActionsA: worldA.governanceStats.verdicts.block,
+        blockedActionsB: worldB.governanceStats.verdicts.block,
+        keyFindings,
+        verdict: delta.narrative,
+        poweredBy: "@neuroverseos/governance — simulateWorld() + evaluateGuard()",
+    };
+}