@neuroverseos/nv-sim 0.1.0

package/dist/engine/analyzer.js

@@ -0,0 +1,651 @@
+"use strict";
+/**
+ * MiroFish Simulation Analyzer
+ *
+ * THE VIRAL WEDGE: "Explain My MiroFish Simulation"
+ *
+ * Users paste MiroFish simulation output → Mirotir explains it.
+ * This is the feature that gets Mirotir adopted in the MiroFish community.
+ *
+ * The insight:
+ *   People run MiroFish simulations and post screenshots saying
+ *   "Look what the swarm did!" — but they don't know WHY.
+ *   Mirotir turns spectacle into meaning.
+ *
+ * Input:  MiroFish simulation JSON, logs, or raw output
+ * Output: Structured analysis — emergent patterns, dominant strategies,
+ *         unstable assumptions, coalition detection, projected futures
+ *
+ * Tagline: "Run MiroFish. Then ask Mirotir what it means."
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeMiroFishSimulation = analyzeMiroFishSimulation;
+const governance_1 = require("./governance");
+// ============================================
+// SIMULATION PARSER
+// ============================================
+/**
+ * Parse raw MiroFish output into structured format.
+ * Handles JSON strings, objects, and partial data.
+ */
+function parseSimulation(raw) {
+    if (typeof raw === "string") {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            // Try to extract JSON from mixed content (e.g., pasted log output)
+            const jsonMatch = raw.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                try {
+                    return JSON.parse(jsonMatch[0]);
+                }
+                catch {
+                    return null;
+                }
+            }
+            return null;
+        }
+    }
+    return raw;
+}
+// ============================================
+// PATTERN DETECTION
+// ============================================
+/**
+ * Detect emergent patterns from simulation steps.
+ */
+function detectEmergentPatterns(steps) {
+    const patterns = [];
+    // Track sentiment trajectories per agent
+    const agentSentiments = {};
+    for (const step of steps) {
+        for (const action of step.agent_actions) {
+            if (!agentSentiments[action.agent_id]) {
+                agentSentiments[action.agent_id] = [];
+            }
+            agentSentiments[action.agent_id].push(action.sentiment);
+        }
+    }
+    // Detect herd behavior (agents converging on same sentiment)
+    for (let i = 1; i < steps.length; i++) {
+        const sentiments = steps[i].agent_actions.map((a) => a.sentiment);
+        const avg = sentiments.reduce((s, v) => s + v, 0) / sentiments.length;
+        const variance = sentiments.reduce((s, v) => s + (v - avg) ** 2, 0) / sentiments.length;
+        if (variance < 0.05 && sentiments.length > 1) {
+            patterns.push({
+                pattern: "Herd behavior — agents converging on shared sentiment",
+                first_observed_step: i,
+                strength: variance < 0.02 ? "strong" : "moderate",
+                agents_involved: steps[i].agent_actions.map((a) => a.agent_id),
+                significance: "When agents stop disagreeing, the system may be approaching consensus or groupthink",
+            });
+            break; // Only report first occurrence
+        }
+    }
+    // Detect polarization (agents splitting into camps)
+    for (let i = 1; i < steps.length; i++) {
+        const sentiments = steps[i].agent_actions.map((a) => a.sentiment);
+        const positive = sentiments.filter((s) => s > 0.3);
+        const negative = sentiments.filter((s) => s < -0.3);
+        if (positive.length >= 2 && negative.length >= 2) {
+            patterns.push({
+                pattern: "Polarization — agents splitting into opposing camps",
+                first_observed_step: i,
+                strength: "strong",
+                agents_involved: steps[i].agent_actions.map((a) => a.agent_id),
+                significance: "Polarized systems are harder to steer and more likely to produce extreme outcomes",
+            });
+            break;
+        }
+    }
+    // Detect sentiment reversal (agent flipping position)
+    for (const [agentId, sentiments] of Object.entries(agentSentiments)) {
+        for (let i = 1; i < sentiments.length; i++) {
+            if (Math.abs(sentiments[i] - sentiments[i - 1]) > 0.6 &&
+                Math.sign(sentiments[i]) !== Math.sign(sentiments[i - 1])) {
+                patterns.push({
+                    pattern: `Sentiment reversal — ${agentId} flipped position`,
+                    first_observed_step: i,
+                    strength: "strong",
+                    agents_involved: [agentId],
+                    significance: "Position reversals indicate either new information or breaking of prior commitments",
+                });
+            }
+        }
+    }
+    // Detect escalation (overall sentiment getting more extreme)
+    if (steps.length >= 3) {
+        const earlyAvg = steps[0].agent_actions.reduce((s, a) => s + Math.abs(a.sentiment), 0) /
+            steps[0].agent_actions.length;
+        const lateAvg = steps[steps.length - 1].agent_actions.reduce((s, a) => s + Math.abs(a.sentiment), 0) / steps[steps.length - 1].agent_actions.length;
+        if (lateAvg > earlyAvg * 1.5) {
+            patterns.push({
+                pattern: "Escalation — positions becoming more extreme over time",
+                first_observed_step: Math.floor(steps.length / 2),
+                strength: lateAvg > earlyAvg * 2 ? "strong" : "moderate",
+                agents_involved: steps[steps.length - 1].agent_actions.map((a) => a.agent_id),
+                significance: "Escalating systems are harder to de-escalate and more likely to reach crisis points",
+            });
+        }
+    }
+    return patterns;
+}
+/**
+ * Identify dominant strategies from agent actions.
+ */
+function identifyDominantStrategies(steps) {
+    const strategies = [];
+    // Aggregate each agent's behavior across all steps
+    const agentBehaviors = {};
+    for (const step of steps) {
+        for (const action of step.agent_actions) {
+            if (!agentBehaviors[action.agent_id]) {
+                agentBehaviors[action.agent_id] = {
+                    actions: [],
+                    avgSentiment: 0,
+                    avgConfidence: 0,
+                };
+            }
+            agentBehaviors[action.agent_id].actions.push(action.action);
+        }
+    }
+    // Calculate averages
+    for (const [agentId, behavior] of Object.entries(agentBehaviors)) {
+        const agentActions = steps.flatMap((s) => s.agent_actions.filter((a) => a.agent_id === agentId));
+        behavior.avgSentiment =
+            agentActions.reduce((s, a) => s + a.sentiment, 0) / agentActions.length;
+        behavior.avgConfidence =
+            agentActions.reduce((s, a) => s + a.confidence, 0) / agentActions.length;
+        // Determine dominant strategy description
+        const sentiment = behavior.avgSentiment;
+        const confidence = behavior.avgConfidence;
+        let strategy;
+        let whyItWorks;
+        if (confidence > 0.7 && sentiment > 0.3) {
+            strategy = "Assertive positive — consistently pushing for favorable outcomes";
+            whyItWorks = "High confidence + positive positioning creates momentum and attracts allies";
+        }
+        else if (confidence > 0.7 && sentiment < -0.3) {
+            strategy = "Assertive opposition — consistently blocking unfavorable outcomes";
+            whyItWorks = "Strong opposition from a confident actor forces others to negotiate or adapt";
+        }
+        else if (confidence < 0.4) {
+            strategy = "Cautious observation — waiting for clearer signals before committing";
+            whyItWorks = "In uncertain environments, preserving optionality is often optimal";
+        }
+        else if (Math.abs(sentiment) < 0.2) {
+            strategy = "Neutral balancing — maintaining equilibrium between factions";
+            whyItWorks = "Neutral actors become kingmakers when factions polarize";
+        }
+        else {
+            strategy = "Adaptive positioning — adjusting stance based on evolving dynamics";
+            whyItWorks = "Flexibility allows exploitation of emerging opportunities";
+        }
+        strategies.push({
+            agent_id: agentId,
+            strategy,
+            effectiveness: Number(((Math.abs(sentiment) + confidence) / 2).toFixed(2)),
+            why_it_works: whyItWorks,
+        });
+    }
+    // Sort by effectiveness
+    return strategies.sort((a, b) => b.effectiveness - a.effectiveness);
+}
+/**
+ * Detect coalitions — groups of agents acting in concert.
+ */
+function detectCoalitions(steps) {
+    const coalitions = [];
+    if (steps.length < 2)
+        return coalitions;
+    // Get final step sentiment per agent
+    const finalStep = steps[steps.length - 1];
+    const positiveAgents = finalStep.agent_actions
+        .filter((a) => a.sentiment > 0.2)
+        .map((a) => a.agent_id);
+    const negativeAgents = finalStep.agent_actions
+        .filter((a) => a.sentiment < -0.2)
+        .map((a) => a.agent_id);
+    if (positiveAgents.length >= 2) {
+        coalitions.push({
+            members: positiveAgents,
+            basis: "Shared positive sentiment toward the scenario outcome",
+            strength: Number((finalStep.agent_actions
+                .filter((a) => positiveAgents.includes(a.agent_id))
+                .reduce((s, a) => s + a.confidence, 0) / positiveAgents.length).toFixed(2)),
+            threat_to: negativeAgents,
+        });
+    }
+    if (negativeAgents.length >= 2) {
+        coalitions.push({
+            members: negativeAgents,
+            basis: "Shared opposition to the scenario outcome",
+            strength: Number((finalStep.agent_actions
+                .filter((a) => negativeAgents.includes(a.agent_id))
+                .reduce((s, a) => s + a.confidence, 0) / negativeAgents.length).toFixed(2)),
+            threat_to: positiveAgents,
+        });
+    }
+    return coalitions;
+}
+/**
+ * Identify fragile points in the simulation.
+ */
+function identifyFragilePoints(steps) {
+    const fragile = [];
+    // Look for steps where small changes produced large effects
+    for (let i = 1; i < steps.length; i++) {
+        const prev = steps[i - 1];
+        const curr = steps[i];
+        for (const action of curr.agent_actions) {
+            const prevAction = prev.agent_actions.find((a) => a.agent_id === action.agent_id);
+            if (prevAction) {
+                const sentimentShift = Math.abs(action.sentiment - prevAction.sentiment);
+                if (sentimentShift > 0.5) {
+                    fragile.push({
+                        assumption: `${action.agent_id} would maintain their position`,
+                        fragility: sentimentShift > 0.7 ? "critical" : "high",
+                        what_breaks: `${action.agent_id} reversed position in step ${i}, suggesting their commitment was conditional on unstated factors`,
+                        step_observed: i,
+                    });
+                }
+            }
+        }
+    }
+    // Check for narrow margins (many agents near 0 sentiment = unstable equilibrium)
+    for (let i = 0; i < steps.length; i++) {
+        const neutralAgents = steps[i].agent_actions.filter((a) => Math.abs(a.sentiment) < 0.15);
+        if (neutralAgents.length > steps[i].agent_actions.length / 2) {
+            fragile.push({
+                assumption: "System is in stable equilibrium",
+                fragility: "high",
+                what_breaks: `Step ${i}: ${neutralAgents.length} of ${steps[i].agent_actions.length} agents are near-neutral — a small push in either direction could cascade`,
+                step_observed: i,
+            });
+            break;
+        }
+    }
+    return fragile;
+}
+/**
+ * Analyze equilibrium state.
+ */
+function analyzeEquilibrium(steps, finalState) {
+    if (steps.length < 2) {
+        return {
+            reached: false,
+            stability: 0,
+            type: "none",
+            description: "Insufficient simulation data to determine equilibrium",
+        };
+    }
+    // Calculate sentiment variance trend
+    const variances = steps.map((step) => {
+        const sentiments = step.agent_actions.map((a) => a.sentiment);
+        const avg = sentiments.reduce((s, v) => s + v, 0) / sentiments.length;
+        return (sentiments.reduce((s, v) => s + (v - avg) ** 2, 0) / sentiments.length);
+    });
+    const varianceTrend = variances[variances.length - 1] - variances[0];
+    const lastVariance = variances[variances.length - 1];
+    if (finalState.convergence && finalState.stability > 0.7) {
+        return {
+            reached: true,
+            step_reached: steps.length - 1,
+            stability: finalState.stability,
+            type: "stable",
+            description: "System reached stable equilibrium — agents converged on compatible positions. This outcome is likely to persist unless new external shocks are introduced.",
+        };
+    }
+    if (lastVariance < 0.05 && varianceTrend < 0) {
+        return {
+            reached: true,
+            step_reached: steps.length - 1,
+            stability: Number((1 - lastVariance * 10).toFixed(2)),
+            type: "stable",
+            description: "System is converging toward equilibrium — variance is decreasing. Additional steps would likely solidify this state.",
+        };
+    }
+    // Check for oscillation
+    if (variances.length >= 4) {
+        let oscillations = 0;
+        for (let i = 2; i < variances.length; i++) {
+            if ((variances[i] - variances[i - 1]) *
+                (variances[i - 1] - variances[i - 2]) <
+                0) {
+                oscillations++;
+            }
+        }
+        if (oscillations >= variances.length / 2 - 1) {
+            return {
+                reached: false,
+                stability: Number((0.5 - lastVariance).toFixed(2)),
+                type: "oscillating",
+                description: "System is oscillating — agents are cycling between positions without settling. This suggests competing feedback loops with similar strength.",
+            };
+        }
+    }
+    if (varianceTrend > 0.1) {
+        return {
+            reached: false,
+            stability: Number(Math.max(0, 1 - varianceTrend * 5).toFixed(2)),
+            type: "diverging",
+            description: "System is diverging — positions are becoming more extreme over time. Without intervention, this trajectory leads to polarization or breakdown.",
+        };
+    }
+    return {
+        reached: false,
+        stability: finalState.stability,
+        type: "unstable",
+        description: "System has not reached equilibrium. Agent positions remain contested. The outcome is sensitive to initial conditions and external factors.",
+    };
+}
+/**
+ * Analyze power dynamics — who's driving outcomes.
+ */
+function analyzePowerDynamics(steps) {
+    const dynamics = [];
+    const agentIds = new Set();
+    for (const step of steps) {
+        for (const action of step.agent_actions) {
+            agentIds.add(action.agent_id);
+        }
+    }
+    for (const agentId of agentIds) {
+        const actions = steps.flatMap((s) => s.agent_actions.filter((a) => a.agent_id === agentId));
+        const avgConfidence = actions.reduce((s, a) => s + a.confidence, 0) / actions.length;
+        const avgAbsSentiment = actions.reduce((s, a) => s + Math.abs(a.sentiment), 0) / actions.length;
+        const sentimentVariance = (() => {
+            const avg = actions.reduce((s, a) => s + a.sentiment, 0) / actions.length;
+            return (actions.reduce((s, a) => s + (a.sentiment - avg) ** 2, 0) /
+                actions.length);
+        })();
+        // Determine role
+        let role;
+        const influence = Number(((avgConfidence * 0.6 + avgAbsSentiment * 0.4)).toFixed(2));
+        if (avgConfidence > 0.7 && avgAbsSentiment > 0.5) {
+            role = "driver";
+        }
+        else if (sentimentVariance > 0.2) {
+            role = "reactor";
+        }
+        else if (avgAbsSentiment < 0.15) {
+            role = "stabilizer";
+        }
+        else if (avgConfidence > 0.6 && actions.some((a) => a.sentiment < -0.5)) {
+            role = "disruptor";
+        }
+        else {
+            role = "bystander";
+        }
+        dynamics.push({
+            agent_id: agentId,
+            influence: Math.min(1, influence),
+            role,
+            key_actions: actions.slice(-3).map((a) => a.action),
+        });
+    }
+    return dynamics.sort((a, b) => b.influence - a.influence);
+}
+/**
+ * Generate a human-readable narrative of what happened in the simulation.
+ */
+function generateNarrative(steps, patterns, coalitions, equilibrium, dynamics) {
+    const parts = [];
+    // Opening
+    parts.push(`Over ${steps.length} simulation rounds, ${new Set(steps.flatMap((s) => s.agent_actions.map((a) => a.agent_id))).size} agents interacted.`);
+    // Dominant actors
+    const drivers = dynamics.filter((d) => d.role === "driver");
+    if (drivers.length > 0) {
+        parts.push(`${drivers.map((d) => d.agent_id).join(" and ")} emerged as the primary ${drivers.length > 1 ? "drivers" : "driver"} of outcomes.`);
+    }
+    // Coalitions
+    if (coalitions.length > 0) {
+        parts.push(`${coalitions.length} coalition${coalitions.length > 1 ? "s" : ""} formed: ${coalitions.map((c) => c.members.join(" + ")).join("; ")}.`);
+    }
+    // Key patterns
+    const strongPatterns = patterns.filter((p) => p.strength === "strong");
+    if (strongPatterns.length > 0) {
+        parts.push(`Notable dynamics: ${strongPatterns.map((p) => p.pattern.toLowerCase()).join("; ")}.`);
+    }
+    // Equilibrium
+    parts.push(equilibrium.description);
+    return parts.join(" ");
+}
+// ============================================
+// MAIN ANALYZER
+// ============================================
+/**
+ * Analyze a MiroFish simulation and produce structured insights.
+ *
+ * This is THE viral feature:
+ *   Paste simulation → Get explanation
+ *   "Run MiroFish. Then ask Mirotir what it means."
+ */
+async function analyzeMiroFishSimulation(input) {
+    const startTime = Date.now();
+    const reasoningId = `rsn_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    // Parse the simulation data
+    const simulation = parseSimulation(input.simulation);
+    if (!simulation) {
+        return {
+            status: "error",
+            error: {
+                code: "INVALID_REQUEST",
+                message: "Could not parse MiroFish simulation data. Paste the JSON output from your simulation.",
+                detail: "Expected a MiroFish simulation response object with steps and agent_actions",
+            },
+            reasoning_id: reasoningId,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    if (!simulation.steps || simulation.steps.length === 0) {
+        return {
+            status: "error",
+            error: {
+                code: "INVALID_REQUEST",
+                message: "Simulation has no steps. Run your MiroFish simulation for at least 2 steps before analyzing.",
+            },
+            reasoning_id: reasoningId,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    // Extract all unique agents as stakeholders
+    const agentIds = new Set();
+    for (const step of simulation.steps) {
+        for (const action of step.agent_actions) {
+            agentIds.add(action.agent_id);
+        }
+    }
+    const stakeholders = Array.from(agentIds).map((id) => ({
+        id,
+        disposition: "unknown",
+    }));
+    // Run all analyses
+    const patterns = detectEmergentPatterns(simulation.steps);
+    const dominantStrategies = identifyDominantStrategies(simulation.steps);
+    const coalitions = detectCoalitions(simulation.steps);
+    const fragilePoints = identifyFragilePoints(simulation.steps);
+    const equilibrium = analyzeEquilibrium(simulation.steps, simulation.final_state ?? { convergence: false, stability: 0.5 });
+    const powerDynamics = analyzePowerDynamics(simulation.steps);
+    const narrative = generateNarrative(simulation.steps, patterns, coalitions, equilibrium, powerDynamics);
+    // Build simulation insights
+    const simulationInsights = {
+        emergent_patterns: patterns,
+        dominant_strategies: dominantStrategies,
+        coalitions,
+        fragile_points: fragilePoints,
+        equilibrium,
+        power_dynamics: powerDynamics,
+        narrative,
+    };
+    // Build reasoning paths from the analysis
+    const paths = [];
+    // Path based on equilibrium
+    if (equilibrium.reached) {
+        paths.push({
+            id: "path_accept_equilibrium",
+            label: "Accept Equilibrium",
+            description: "The system has reached a stable state. Work within this new equilibrium rather than fighting it.",
+            projected_outcome: "Predictable dynamics but potentially locked into suboptimal arrangements",
+            probability: 0.7,
+            risk: "low",
+            tradeoffs: [
+                "Stability vs. potentially better outcomes through disruption",
+                "Known dynamics vs. unknown alternatives",
+            ],
+        });
+    }
+    else {
+        paths.push({
+            id: "path_intervene_early",
+            label: "Intervene Before Equilibrium",
+            description: "The system hasn't settled. This is the window to influence outcomes before positions harden.",
+            projected_outcome: "Opportunity to shape the outcome, but intervention may trigger unintended cascades",
+            probability: 0.5,
+            risk: "moderate",
+            tradeoffs: [
+                "Influence opportunity vs. cascade risk",
+                "Speed vs. understanding",
+            ],
+        });
+    }
+    // Path based on coalition dynamics
+    if (coalitions.length > 0) {
+        const dominantCoalition = [...coalitions].sort((a, b) => b.strength - a.strength)[0];
+        paths.push({
+            id: "path_align_with_coalition",
+            label: `Align With ${dominantCoalition.members.join(" + ")}`,
+            description: `The strongest coalition (${dominantCoalition.members.join(", ")}) is forming around: ${dominantCoalition.basis}`,
+            projected_outcome: "Shared influence through coalition membership, but constrained by coalition consensus",
+            probability: 0.6,
+            risk: "moderate",
+            tradeoffs: [
+                "Coalition power vs. individual autonomy",
+                "Shared upside vs. shared downside",
+            ],
+            benefits_stakeholders: dominantCoalition.members,
+            harms_stakeholders: dominantCoalition.threat_to,
+        });
+    }
+    // Path based on disruptors
+    const disruptors = powerDynamics.filter((d) => d.role === "disruptor");
+    if (disruptors.length > 0) {
+        paths.push({
+            id: "path_neutralize_disruptors",
+            label: "Address Disruptive Agents",
+            description: `${disruptors.map((d) => d.agent_id).join(", ")} ${disruptors.length > 1 ? "are" : "is"} destabilizing the system. Addressing ${disruptors.length > 1 ? "them" : "this agent"} could change the trajectory.`,
+            projected_outcome: "Reduced volatility but risk of driving disruption underground",
+            probability: 0.45,
+            risk: "high",
+            tradeoffs: [
+                "Stability vs. innovation that disruption sometimes enables",
+                "Short-term relief vs. addressing root causes",
+            ],
+        });
+    }
+    // Build assumption challenges from fragile points
+    const challenges = fragilePoints.map((fp) => ({
+        assumption: fp.assumption,
+        challenge: `This assumption broke at step ${fp.step_observed}: ${fp.what_breaks}`,
+        impact_if_wrong: "The simulation trajectory would be fundamentally different under alternative assumptions",
+        severity: fp.fragility === "critical" ? "critical" : "high",
+    }));
+    // Build projected outcomes
+    const outcomes = [
+        {
+            id: "outcome_current_trajectory",
+            label: "Current Trajectory",
+            conditions: "If the dynamics observed in the simulation continue",
+            outcome: equilibrium.description,
+            likelihood: 0.5,
+            impact: equilibrium.type === "diverging" ? "negative" : "neutral",
+        },
+        {
+            id: "outcome_intervention",
+            label: "With Strategic Intervention",
+            conditions: "If the key fragile points are addressed proactively",
+            outcome: "System could be steered toward a more favorable equilibrium, but requires careful timing",
+            likelihood: 0.3,
+            impact: "positive",
+        },
+    ];
+    // Build recommendations
+    const driverAgents = powerDynamics.filter((d) => d.role === "driver");
+    const recommendations = [
+        {
+            priority: 1,
+            action: "Validate the simulation's key assumptions — the fragile points identified suggest the outcome is sensitive to conditions that may not hold",
+            rationale: `${fragilePoints.length} fragile points detected. The simulation may be overconfident in its trajectory.`,
+            timeframe: "Before acting on these results",
+        },
+        {
+            priority: 2,
+            action: `Monitor ${driverAgents.length > 0 ? driverAgents.map((d) => d.agent_id).join(" and ") : "the most influential agents"} — their next moves will determine the trajectory`,
+            rationale: "Power dynamics analysis shows these actors are driving outcomes",
+            timeframe: "Immediately",
+        },
+    ];
+    if (coalitions.length > 0) {
+        recommendations.push({
+            priority: 3,
+            action: "Map your position relative to the emerging coalitions — are you inside or outside?",
+            rationale: "Coalition dynamics will increasingly determine who benefits and who doesn't",
+            timeframe: "Within 24 hours",
+        });
+    }
+    // Build the analysis
+    const analysis = {
+        summary: narrative,
+        paths,
+        projected_outcomes: outcomes,
+        assumption_challenges: challenges,
+        recommendations,
+        key_uncertainties: [
+            "Whether the simulation accurately models real agent incentives",
+            "Whether external shocks not modeled could change the trajectory",
+            `Whether ${equilibrium.type === "stable" ? "the equilibrium will hold under stress" : "equilibrium will be reached at all"}`,
+        ],
+        missing_questions: input.question
+            ? undefined
+            : [
+                "What specific decision are you trying to make based on this simulation?",
+                "Which agent's perspective are you most interested in?",
+                "What would you change if you could re-run the simulation?",
+            ],
+    };
+    // Governance trace
+    const governance = {
+        trace_id: `gov_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
+        constitutional_checks: (0, governance_1.runGovernanceChecks)({
+            scenario: `MiroFish simulation analysis: ${simulation.simulation_id ?? "unknown"}`,
+        }),
+        authority_level: "ANALYSIS_ONLY",
+        enforced_constraints: [
+            "ANALYSIS_ONLY: Interpreting simulation results, no execution authority",
+            "STATELESS: No simulation data stored after response",
+            "GOVERNANCE_TRACED: Analysis provenance auditable",
+        ],
+        timestamp: new Date().toISOString(),
+        engine_version: "0.1.0",
+    };
+    const processingTime = Date.now() - startTime;
+    const meta = {
+        processing_time_ms: processingTime,
+        depth_used: "full",
+        paths_explored: paths.length,
+        assumptions_challenged: challenges.length,
+        timestamp: new Date().toISOString(),
+    };
+    const reasoning = {
+        reasoning_id: reasoningId,
+        status: "completed",
+        analysis,
+        governance,
+        meta,
+    };
+    return {
+        reasoning,
+        simulation_insights: simulationInsights,
+    };
+}