@neuroverseos/nv-sim 0.1.2 → 0.1.6

package/dist/engine/primeRadiant.js

@@ -0,0 +1,540 @@
+"use strict";
+/**
+ * Prime Radiant — The Unified Governance Intelligence Platform
+ *
+ * "MiroFish simulates how narratives emerge from interacting agents.
+ *  NeuroverseOS intervenes at the action level to shape how those narratives evolve."
+ *
+ * Or sharper:
+ *  "They simulate society. We control how it behaves."
+ *
+ * The Prime Radiant operates in three modes:
+ *
+ * MODE 1: WORLD BUILDER
+ *   Merge knowledge graph (MiroFish) + policy constraints (NeuroverseOS)
+ *   → Governed world file ready for simulation
+ *
+ * MODE 2: GOVERNED SIMULATION
+ *   Run simulations through both governance layers:
+ *   - Layer A: govern() — per-action, per-agent
+ *   - Layer B: governDynamics() — per-round, system-level
+ *   Compare governed vs ungoverned trajectories
+ *
+ * MODE 3: DECISION INTELLIGENCE
+ *   Run N scenarios × M policies
+ *   Score outcomes against user-defined metrics
+ *   Produce actionable recommendation
+ *
+ * Usage:
+ *   const radiant = createPrimeRadiant({
+ *     scenario: "University crisis...",
+ *     policyText: "Block inflammatory content. Boost official sources...",
+ *   })
+ *
+ *   // Mode 1: Build world
+ *   const world = radiant.buildWorld()
+ *
+ *   // Mode 2: Run governed sim
+ *   const sim = await radiant.runGovernedSimulation()
+ *
+ *   // Mode 3: Compare options
+ *   const decision = await radiant.compareOptions([
+ *     { id: "optionA", label: "Revoke", policyText: "..." },
+ *     { id: "optionB", label: "Maintain", policyText: "..." },
+ *   ])
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIME_RADIANT_PRESETS = void 0;
+exports.createPrimeRadiant = createPrimeRadiant;
+const policyEngine_1 = require("./policyEngine");
+const fullGovernedLoop_1 = require("./fullGovernedLoop");
+const scenarioComparison_1 = require("./scenarioComparison");
+const dynamicsGovernance_1 = require("./dynamicsGovernance");
+const govern_1 = require("../runtime/govern");
+// ============================================
+// DEFAULT STAKEHOLDERS & PATHS
+// ============================================
+function defaultStakeholders() {
+    return [
+        { id: "Public", disposition: "neutral", priorities: ["trust", "fairness", "information"] },
+        { id: "Media", disposition: "hostile", priorities: ["story", "audience", "speed"] },
+        { id: "Officials", disposition: "supportive", priorities: ["stability", "legitimacy", "control"] },
+        { id: "Opposition", disposition: "hostile", priorities: ["accountability", "change", "leverage"] },
+        { id: "Affected Parties", disposition: "neutral", priorities: ["justice", "resolution", "voice"] },
+    ];
+}
+function defaultPaths() {
+    return [
+        {
+            id: "path_escalation",
+            label: "Escalation",
+            description: "Situation escalates as narratives spread and positions harden",
+            projected_outcome: "Increased polarization, media cycle extends, institutional trust erodes",
+            probability: 0.6,
+            risk: "high",
+            tradeoffs: ["Speed of response vs. quality of response", "Transparency vs. institutional protection"],
+            benefits_stakeholders: ["Media"],
+            harms_stakeholders: ["Officials", "Affected Parties"],
+        },
+        {
+            id: "path_containment",
+            label: "Containment",
+            description: "Governance constraints contain the situation within manageable bounds",
+            projected_outcome: "Reduced volatility, shortened media cycle, trust preserved",
+            probability: 0.5,
+            risk: "moderate",
+            tradeoffs: ["Constraint vs. freedom of expression", "Short-term calm vs. suppression perception"],
+            benefits_stakeholders: ["Officials", "Public"],
+            harms_stakeholders: ["Media"],
+        },
+        {
+            id: "path_resolution",
+            label: "Resolution",
+            description: "Active engagement and transparency lead to constructive resolution",
+            projected_outcome: "Trust recovery, narrative shifts to institutional learning, opposition de-escalates",
+            probability: 0.35,
+            risk: "moderate",
+            tradeoffs: ["Time investment vs. other priorities", "Admitting fault vs. maintaining position"],
+            benefits_stakeholders: ["Affected Parties", "Public"],
+            harms_stakeholders: [],
+        },
+    ];
+}
+// ============================================
+// FACTORY: createPrimeRadiant()
+// ============================================
+function createPrimeRadiant(config) {
+    const stakeholders = config.stakeholders ?? defaultStakeholders();
+    const paths = config.paths ?? defaultPaths();
+    const swarmConfig = config.swarmConfig ?? {
+        enabled: true,
+        rounds: 8,
+        reaction_model: "mixed",
+    };
+    // Parse policy and build world
+    const parsedPolicy = (0, policyEngine_1.parseRulesFromText)(config.policyText);
+    const healthCheck = (0, policyEngine_1.validatePolicy)(parsedPolicy);
+    const worldDef = config.worldDef ?? (0, policyEngine_1.policyToWorld)(parsedPolicy);
+    // Create governors
+    const actionGov = (0, govern_1.createGovernor)({
+        policyText: config.policyText,
+        sensitivity: 0.5,
+    });
+    const dynamicsGov = (0, dynamicsGovernance_1.createDynamicsGovernor)(config.policyText, config.initialState);
+    // --- MODE 1: WORLD BUILDER ---
+    function buildWorld() {
+        const dynamicsRules = (0, dynamicsGovernance_1.createDynamicsGovernor)(config.policyText).rules;
+        const coveredVars = new Set(parsedPolicy.rules.flatMap((r) => r.affectedVariables));
+        const criticalVars = ["liquidity", "leverage", "volatility", "risk", "stability", "trust", "contagion"];
+        const uncovered = criticalVars.filter((v) => !coveredVars.has(v));
+        return {
+            policy: parsedPolicy,
+            health: healthCheck,
+            world: worldDef,
+            stakeholders,
+            coverageReport: {
+                totalRules: parsedPolicy.summary.total,
+                enforcedRules: parsedPolicy.summary.enforced,
+                advisoryRules: parsedPolicy.summary.advisory,
+                coveredVariables: [...coveredVars],
+                uncoveredCritical: uncovered,
+                dynamicsRulesDetected: dynamicsRules.length,
+                healthScore: healthCheck.healthScore,
+            },
+        };
+    }
+    // --- MODE 2: GOVERNED SIMULATION ---
+    async function runGovernedSim() {
+        // Run governed simulation
+        const governed = await (0, fullGovernedLoop_1.runFullGovernedSimulation)({
+            scenario: config.scenario,
+            stakeholders,
+            paths,
+            swarmConfig,
+            policyText: config.policyText,
+            worldDef,
+            narrativeEvents: config.narrativeEvents,
+            agentTypes: config.agentTypes,
+            initialSystemState: config.initialState,
+        });
+        // Run ungoverned baseline (empty policy)
+        const baseline = await (0, fullGovernedLoop_1.runFullGovernedSimulation)({
+            scenario: config.scenario,
+            stakeholders,
+            paths,
+            swarmConfig,
+            policyText: "", // No rules — ungoverned
+            worldDef: {
+                thesis: "Ungoverned baseline — no rules applied",
+                state_variables: [],
+                invariants: [],
+                gates: [],
+            },
+            narrativeEvents: config.narrativeEvents,
+            agentTypes: config.agentTypes,
+            initialSystemState: config.initialState,
+        });
+        // Compute delta
+        const delta = {
+            trustDelta: Number((governed.finalState.trust - baseline.finalState.trust).toFixed(3)),
+            polarizationDelta: Number((governed.finalState.polarization - baseline.finalState.polarization).toFixed(3)),
+            outrageDelta: Number((governed.finalState.outrage - baseline.finalState.outrage).toFixed(3)),
+            cascadeRiskDelta: Number((governed.finalState.cascadeRisk - baseline.finalState.cascadeRisk).toFixed(3)),
+            healthDelta: governed.systemHealthScore - baseline.systemHealthScore,
+            interventionCount: governed.dynamicsGovernance.totalInterventions,
+            trajectoryShift: `${baseline.trajectory} → ${governed.trajectory}`,
+            governanceEffectiveness: computeEffectiveness(governed, baseline),
+        };
+        const narrative = buildNarrative(governed, baseline, delta);
+        return { governed, baseline, delta, narrative };
+    }
+    // --- MODE 3: DECISION INTELLIGENCE ---
+    async function compareOpts(options, metrics) {
+        return (0, scenarioComparison_1.runScenarioMatrix)({
+            scenario: config.scenario,
+            stakeholders,
+            paths,
+            swarmConfig,
+            policyOptions: options,
+            defaultWorldDef: worldDef,
+            evaluationMetrics: metrics ?? scenarioComparison_1.DEFAULT_METRICS,
+            narrativeEvents: config.narrativeEvents,
+            agentTypes: config.agentTypes,
+        });
+    }
+    return {
+        buildWorld,
+        runGovernedSimulation: runGovernedSim,
+        compareOptions: compareOpts,
+        get actionGovernor() { return actionGov; },
+        get dynamicsGovernor() { return dynamicsGov; },
+        get config() { return config; },
+    };
+}
+// ============================================
+// HELPERS
+// ============================================
+function computeEffectiveness(governed, baseline) {
+    let score = 0;
+    // Trust improvement
+    const trustDelta = governed.finalState.trust - baseline.finalState.trust;
+    if (trustDelta > 0)
+        score += trustDelta * 0.3;
+    // Polarization reduction
+    const polDelta = baseline.finalState.polarization - governed.finalState.polarization;
+    if (polDelta > 0)
+        score += polDelta * 0.25;
+    // Outrage reduction
+    const outDelta = baseline.finalState.outrage - governed.finalState.outrage;
+    if (outDelta > 0)
+        score += outDelta * 0.2;
+    // Cascade risk reduction
+    const cascDelta = baseline.finalState.cascadeRisk - governed.finalState.cascadeRisk;
+    if (cascDelta > 0)
+        score += cascDelta * 0.15;
+    // Health improvement
+    const healthDelta = (governed.systemHealthScore - baseline.systemHealthScore) / 100;
+    if (healthDelta > 0)
+        score += healthDelta * 0.1;
+    return Math.max(0, Math.min(1, Number(score.toFixed(3))));
+}
+function buildNarrative(governed, baseline, delta) {
+    const parts = [];
+    parts.push(`Governed simulation vs. ungoverned baseline:`);
+    // Trust
+    if (delta.trustDelta > 0.05) {
+        parts.push(`Trust improved by ${(delta.trustDelta * 100).toFixed(0)} points (${(baseline.finalState.trust * 100).toFixed(0)}% → ${(governed.finalState.trust * 100).toFixed(0)}%).`);
+    }
+    else if (delta.trustDelta < -0.05) {
+        parts.push(`Trust declined despite governance (${(baseline.finalState.trust * 100).toFixed(0)}% → ${(governed.finalState.trust * 100).toFixed(0)}%).`);
+    }
+    // Polarization
+    if (delta.polarizationDelta < -0.05) {
+        parts.push(`Polarization reduced by ${(Math.abs(delta.polarizationDelta) * 100).toFixed(0)} points.`);
+    }
+    else if (delta.polarizationDelta > 0.05) {
+        parts.push(`Polarization increased despite governance — dynamics may need adjustment.`);
+    }
+    // Outrage
+    if (delta.outrageDelta < -0.1) {
+        parts.push(`Outrage dampened significantly (${(Math.abs(delta.outrageDelta) * 100).toFixed(0)} point reduction).`);
+    }
+    // Cascade
+    if (delta.cascadeRiskDelta < -0.1) {
+        parts.push(`Cascade risk reduced from ${(baseline.finalState.cascadeRisk * 100).toFixed(0)}% to ${(governed.finalState.cascadeRisk * 100).toFixed(0)}%.`);
+    }
+    // Dynamics
+    if (delta.interventionCount > 0) {
+        parts.push(`${delta.interventionCount} dynamics interventions executed across ${governed.rounds.length} rounds.`);
+        const dynStats = governed.dynamicsGovernance;
+        const details = [];
+        if (dynStats.propagationLimits > 0)
+            details.push(`${dynStats.propagationLimits} propagation limits`);
+        if (dynStats.amplificationDampens > 0)
+            details.push(`${dynStats.amplificationDampens} amplification dampens`);
+        if (dynStats.cascadeBreakers > 0)
+            details.push(`${dynStats.cascadeBreakers} cascade breakers`);
+        if (dynStats.trustBoosts > 0)
+            details.push(`${dynStats.trustBoosts} trust boosts`);
+        if (dynStats.coolingPeriods > 0)
+            details.push(`${dynStats.coolingPeriods} cooling periods`);
+        if (details.length > 0) {
+            parts.push(`Breakdown: ${details.join(", ")}.`);
+        }
+    }
+    // Trajectory
+    parts.push(`Trajectory: ${delta.trajectoryShift}.`);
+    // Health
+    if (delta.healthDelta > 0) {
+        parts.push(`System health: ${baseline.systemHealthScore}/100 → ${governed.systemHealthScore}/100 (+${delta.healthDelta}).`);
+    }
+    // Overall
+    parts.push(`Governance effectiveness: ${(delta.governanceEffectiveness * 100).toFixed(0)}%.`);
+    return parts.join(" ");
+}
+// ============================================
+// PRESET DEMOS
+// ============================================
+/**
+ * Pre-built Prime Radiant configurations for common scenarios.
+ */
+exports.PRIME_RADIANT_PRESETS = {
+    /** University disciplinary crisis (inspired by MiroFish demo) */
+    university_crisis: {
+        scenario: "A university's disciplinary decision sparks widespread backlash. " +
+            "Students, media, alumni, and government stakeholders react across social platforms. " +
+            "Narratives shift from individual case to systemic institutional critique. " +
+            "Media rationalizes, platforms amplify, and polarization deepens.",
+        policyText: [
+            "Block inflammatory content that contains unverified accusations",
+            "Limit media amplification when polarization exceeds threshold",
+            "Require evidence tags on all claims about institutional decisions",
+            "Halt coordinated inauthentic behavior campaigns",
+            "Boost official institutional response visibility during trust crisis",
+            "Dampen outrage feedback loops when escalation detected for 2+ rounds",
+            "Pause reactive posting during peak outrage periods",
+            "Monitor all content spread patterns for cascade detection",
+            "Require transparency for all coordinated multi-platform campaigns",
+            "Encourage constructive dialogue by promoting evidence-based responses",
+        ].join("\n"),
+        stakeholders: [
+            { id: "Students", disposition: "hostile", priorities: ["justice", "voice", "accountability"] },
+            { id: "University Admin", disposition: "supportive", priorities: ["reputation", "stability", "process"] },
+            { id: "Media", disposition: "hostile", priorities: ["story", "clicks", "narrative"] },
+            { id: "Alumni", disposition: "neutral", priorities: ["value", "reputation", "community"] },
+            { id: "Government", disposition: "neutral", priorities: ["oversight", "standards", "stability"] },
+            { id: "Online Coalitions", disposition: "hostile", priorities: ["amplification", "mobilization", "pressure"] },
+        ],
+        policyOptions: [
+            {
+                id: "revoke",
+                label: "Revoke Decision",
+                description: "University reverses the disciplinary decision entirely",
+                policyText: [
+                    "Block inflammatory content during reversal announcement period",
+                    "Boost official reversal communication across all platforms",
+                    "Require evidence-based responses to ongoing narratives",
+                    "Dampen residual outrage after positive institutional action",
+                    "Monitor for narrative shift from critique to institutional learning",
+                ].join("\n"),
+            },
+            {
+                id: "partial_apology",
+                label: "Partial Apology",
+                description: "University acknowledges concerns but maintains core decision",
+                policyText: [
+                    "Limit media amplification of conflicting narratives",
+                    "Require balanced coverage of both institutional and student perspectives",
+                    "Dampen polarization feedback loops between opposing camps",
+                    "Boost transparency in institutional decision-making process",
+                    "Monitor sentiment for signs of escalation or de-escalation",
+                ].join("\n"),
+            },
+            {
+                id: "maintain",
+                label: "Maintain Decision",
+                description: "University stands firm on the original decision",
+                policyText: [
+                    "Block coordinated harassment campaigns targeting institution",
+                    "Halt spread of unverified claims about institutional motives",
+                    "Require all criticism to include specific evidence",
+                    "Monitor and report escalation patterns",
+                    "Encourage dialogue through official channels only",
+                ].join("\n"),
+            },
+        ],
+    },
+    /** Flash crash / financial crisis (existing demo enhanced) */
+    financial_crisis: {
+        scenario: "A major algorithmic trading firm's risk model fails during a volatility spike, " +
+            "triggering a cascade of automated sell-offs across interconnected markets. " +
+            "Liquidity evaporates in key sectors. Contagion spreads to sovereign debt markets.",
+        policyText: [
+            "Block all panic selling during extreme volatility",
+            "Halt automated trading when volatility exceeds critical threshold",
+            "Limit maximum leverage to 5x during elevated conditions",
+            "Maintain minimum liquidity floor at 15% of baseline",
+            "Require transparency for all large position changes",
+            "Dampen cascade contagion by limiting cross-market propagation",
+            "Pause all new leveraged positions during circuit breaker activation",
+            "Monitor and report correlated position clusters",
+            "Require rebalancing when concentration exceeds safe thresholds",
+        ].join("\n"),
+        stakeholders: [
+            { id: "Algorithmic Traders", disposition: "hostile", priorities: ["survival", "risk management"] },
+            { id: "Institutional Investors", disposition: "neutral", priorities: ["portfolio protection", "liquidity"] },
+            { id: "Retail Investors", disposition: "hostile", priorities: ["savings", "information"] },
+            { id: "Central Banks", disposition: "neutral", priorities: ["stability", "credibility"] },
+            { id: "Market Makers", disposition: "supportive", priorities: ["spread", "inventory"] },
+            { id: "Regulators", disposition: "neutral", priorities: ["integrity", "protection"] },
+        ],
+        policyOptions: [
+            {
+                id: "aggressive_intervention",
+                label: "Full Intervention",
+                description: "Central bank injects liquidity, regulators halt trading, emergency measures",
+                policyText: [
+                    "Halt all automated trading immediately",
+                    "Block all sell orders exceeding $1M during crisis",
+                    "Require central bank liquidity injection at critical thresholds",
+                    "Freeze all new leveraged positions",
+                    "Mandate position disclosure for all institutional holders",
+                ].join("\n"),
+            },
+            {
+                id: "targeted_response",
+                label: "Targeted Response",
+                description: "Selective intervention in worst-hit sectors, market remains partially open",
+                policyText: [
+                    "Limit automated trading speed during elevated volatility",
+                    "Block panic selling in sovereign debt markets",
+                    "Require staged liquidation for large positions",
+                    "Dampen cross-market contagion propagation",
+                    "Monitor and report cascade indicators in real-time",
+                ].join("\n"),
+            },
+            {
+                id: "market_correction",
+                label: "Let Market Correct",
+                description: "Minimal intervention, let market find new equilibrium",
+                policyText: [
+                    "Monitor all market activity for systemic risk indicators",
+                    "Require transparency in all position changes",
+                    "Encourage orderly liquidation over panic selling",
+                    "Report cascade risk levels to all market participants",
+                ].join("\n"),
+            },
+        ],
+    },
+    /** Geopolitical crisis */
+    geopolitical_crisis: {
+        scenario: "Rising tensions between major powers trigger military exercises near a contested strait. " +
+            "Oil prices spike, shipping lanes face disruption, regional allies face pressure to take sides. " +
+            "Information warfare campaigns amplify on social media across multiple languages.",
+        policyText: [
+            "Block unverified military intelligence claims on public platforms",
+            "Limit amplification of inflammatory geopolitical content",
+            "Require source attribution for all claims about military movements",
+            "Halt spread of content designed to incite panic about supply chains",
+            "Boost diplomatic and de-escalation narratives",
+            "Dampen feedback loops between military posturing and public fear",
+            "Monitor for coordinated information warfare patterns",
+            "Require cooling period before spreading unconfirmed escalation reports",
+        ].join("\n"),
+        stakeholders: [
+            { id: "Military Command", disposition: "neutral", priorities: ["deterrence", "readiness", "intelligence"] },
+            { id: "Diplomatic Corps", disposition: "supportive", priorities: ["de-escalation", "dialogue", "stability"] },
+            { id: "Energy Markets", disposition: "hostile", priorities: ["supply security", "price stability"] },
+            { id: "Regional Allies", disposition: "neutral", priorities: ["security guarantees", "non-alignment"] },
+            { id: "Media", disposition: "hostile", priorities: ["coverage", "narrative", "speed"] },
+            { id: "Public", disposition: "hostile", priorities: ["safety", "information", "preparation"] },
+        ],
+        policyOptions: [
+            {
+                id: "deterrence",
+                label: "Strong Deterrence",
+                policyText: "Block defeatist narratives. Boost military readiness communications. Limit enemy propaganda spread. Halt panic content about supply disruption.",
+            },
+            {
+                id: "diplomacy",
+                label: "Diplomatic Priority",
+                policyText: "Boost diplomatic channel visibility. Dampen military escalation narratives. Require verification for all military claims. Encourage back-channel communication.",
+            },
+            {
+                id: "information_control",
+                label: "Information Control",
+                policyText: "Block all unverified military intelligence. Halt foreign information warfare campaigns. Require official source attribution. Monitor and limit cascade propagation of crisis content.",
+            },
+        ],
+    },
+    /** Autonomous scientific discovery (ScienceClaw integration) */
+    scientific_discovery: {
+        scenario: "An autonomous multi-agent research swarm is investigating a novel material property. " +
+            "Agents independently generate hypotheses, run computational experiments, publish artifacts, " +
+            "and cite each other's work. The ArtifactReactor matches findings across agents. " +
+            "Without governance, popular hypotheses dominate through citation amplification " +
+            "rather than evidence strength. False positives cascade through derivative work. " +
+            "The system converges fast — but on noise, not truth.",
+        policyText: [
+            "Limit propagation of causal claims that lack multi-source evidence",
+            "Contain unvalidated hypotheses within originating research group",
+            "Quarantine findings that have not passed independent reproduction",
+            "Dampen amplification of self-citation loops exceeding 3 generations",
+            "Limit influence of popular findings that lack independent validation",
+            "Circuit break when cascade of dependent findings exceeds validation capacity",
+            "Halt chain reaction of derivative conclusions from unvalidated premises",
+            "Boost visibility of independently reproduced findings",
+            "Require transparency in methodology for all published artifacts",
+            "Dampen rush-to-publish behavior during high-competition periods",
+            "Cool down reactive publication patterns when controversy index rises",
+            "Stabilize publication rate during peer review bottlenecks",
+            "Pause redundant investigation paths when convergence detected",
+        ].join("\n"),
+        stakeholders: [
+            { id: "Lead Investigator", disposition: "supportive", priorities: ["accuracy", "novelty", "methodology"] },
+            { id: "Computational Agents", disposition: "neutral", priorities: ["throughput", "exploration", "efficiency"] },
+            { id: "Validation Oracle", disposition: "supportive", priorities: ["reproducibility", "rigor", "provenance"] },
+            { id: "Citation Network", disposition: "hostile", priorities: ["amplification", "popularity", "speed"] },
+            { id: "Artifact Reactor", disposition: "neutral", priorities: ["matching", "synthesis", "convergence"] },
+            { id: "Peer Reviewers", disposition: "neutral", priorities: ["quality", "standards", "thoroughness"] },
+        ],
+        policyOptions: [
+            {
+                id: "strict_validation",
+                label: "Strict Validation Gate",
+                description: "All findings must pass independent reproduction before entering the citation network",
+                policyText: [
+                    "Block all artifacts that lack independent validation from entering citation network",
+                    "Halt propagation of any finding with fewer than 2 independent confirmations",
+                    "Require full methodology transparency for all published results",
+                    "Quarantine derivative work until parent findings are validated",
+                    "Dampen citation amplification for all unreviewed artifacts",
+                ].join("\n"),
+            },
+            {
+                id: "adaptive_governance",
+                label: "Adaptive Quality Control",
+                description: "Governance intensity scales with false positive risk — light touch when healthy, aggressive when cascading",
+                policyText: [
+                    "Limit propagation of unvalidated hypotheses based on current cascade risk level",
+                    "Dampen citation amplification when self-citation loops detected",
+                    "Circuit break false positive cascades when validation gap exceeds threshold",
+                    "Boost visibility of reproduced findings over popular-but-unvalidated ones",
+                    "Stabilize publication rate when peer review queue exceeds capacity",
+                    "Cool down competitive publication surges during high-discovery periods",
+                ].join("\n"),
+            },
+            {
+                id: "minimal_governance",
+                label: "Minimal Governance",
+                description: "Only intervene on catastrophic cascades — let the swarm self-organize",
+                policyText: [
+                    "Monitor all artifact publication patterns for cascade detection",
+                    "Circuit break only when false positive cascade probability exceeds critical threshold",
+                    "Require basic provenance metadata on all published artifacts",
+                    "Report citation health metrics to all agents",
+                ].join("\n"),
+            },
+        ],
+    },
+};

package/dist/engine/reasoningEngine.js

@@ -444,13 +444,67 @@ async function processReasonRequest(request) {
         ...governanceResult.enforcedConstraints,
     ];
     // Build NeuroverseOS governance summary
+    // Compute world_health_score from actual simulation dynamics, not static validation
+    let dynamicWorldHealth;
+    if (swarmResult) {
+        const allReactions = swarmResult.rounds.flatMap((r) => r.reactions ?? []);
+        if (allReactions.length > 0) {
+            const allImpacts = allReactions.map((r) => r.impact ?? 0);
+            const avgImpact = allImpacts.reduce((s, i) => s + i, 0) / allImpacts.length;
+            const maxVolatility = Math.max(...allImpacts.map((i) => Math.abs(i)));
+            const impactVariance = allImpacts.reduce((s, i) => s + (i - avgImpact) ** 2, 0) / allImpacts.length;
+            // Stability = f(variance, volatility, trajectory, negative sentiment)
+            let stability = 1 - Math.min(1, impactVariance * 3 + Math.max(0, -avgImpact));
+            if (swarmResult.trajectory === "converging" || swarmResult.trajectory === "stabilizing") {
+                stability = Math.min(1, stability + 0.15);
+            }
+            if (swarmResult.trajectory === "escalating") {
+                stability = Math.max(0, stability - 0.2);
+            }
+            if (swarmResult.trajectory === "diverging") {
+                stability = Math.max(0, stability - 0.15);
+            }
+            // Factor in governance interventions
+            const enforcedCount = enforcedConstraints.length;
+            stability = Math.min(1, stability + enforcedCount * 0.02);
+            dynamicWorldHealth = Math.round(Math.max(0, Math.min(100, stability * 100)));
+        }
+    }
+    // Compute dynamic collapse risk from simulation
+    let dynamicCollapseRisk;
+    if (swarmResult) {
+        const allReactions = swarmResult.rounds.flatMap((r) => r.reactions ?? []);
+        if (allReactions.length > 0) {
+            const allImpacts = allReactions.map((r) => r.impact ?? 0);
+            const avgImpact = allImpacts.reduce((s, i) => s + i, 0) / allImpacts.length;
+            const maxVol = Math.max(...allImpacts.map((i) => Math.abs(i)));
+            let risk = 0;
+            if (swarmResult.trajectory === "escalating")
+                risk += 0.35;
+            if (swarmResult.trajectory === "diverging")
+                risk += 0.25;
+            if (avgImpact < -0.3)
+                risk += 0.25;
+            if (maxVol > 0.7)
+                risk += 0.15;
+            risk = Math.min(0.95, risk);
+            if (risk > 0.5)
+                dynamicCollapseRisk = "high";
+            else if (risk > 0.3)
+                dynamicCollapseRisk = "moderate";
+            else if (risk > 0.1)
+                dynamicCollapseRisk = "low";
+            else
+                dynamicCollapseRisk = "none";
+        }
+    }
     const neuroverseTrace = governanceResult.guardVerdict ? {
         guard_status: governanceResult.guardVerdict.status,
         world_viability: governanceResult.governanceSignals?.viability,
         world_collapsed: governanceResult.governanceSignals?.collapsed,
-        collapse_risk: governanceResult.governanceSignals?.collapseRisk,
-        rules_fired: governanceResult.governanceSignals?.rulesFired,
-        world_health_score: governanceResult.validationReport?.summary.completenessScore,
+        collapse_risk: dynamicCollapseRisk ?? governanceResult.governanceSignals?.collapseRisk,
+        rules_fired: governanceResult.governanceSignals?.rulesFired ?? enforcedConstraints.length,
+        world_health_score: dynamicWorldHealth ?? governanceResult.validationReport?.summary.completenessScore,
         invariant_coverage: governanceResult.validationReport?.summary.invariantCoverage,
     } : undefined;
     const governance = {