@neuroverseos/nv-sim 0.1.4 → 0.1.5

package/dist/lib/reasoningEngine.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * UI Adapter for the Echelon Reasoning Engine
+ *
+ * Bridges the engine's processReasonRequest() API to the UI component types.
+ * Also generates preset scenarios from SCENARIO_TEMPLATES.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presetScenarios = void 0;
+exports.generateReasoning = generateReasoning;
+const index_1 = require("../engine/index");
+// ============================================
+// PRESET SCENARIOS (from SCENARIO_TEMPLATES)
+// ============================================
+function templateIdToType(id) {
+    if (id.includes('hormuz') || id.includes('strait'))
+        return 'geopolitical';
+    if (id.includes('gas') || id.includes('price'))
+        return 'economic';
+    if (id.includes('ai') || id.includes('regulation'))
+        return 'regulation';
+    return 'custom';
+}
+function assumptionsToSliders(assumptions) {
+    const severityMap = { low: 20, moderate: 40, high: 70, critical: 90 };
+    const hostilityMap = { low: 20, moderate: 50, high: 80 };
+    const timeMap = { none: 10, low: 25, moderate: 50, urgent: 75, immediate: 95 };
+    const regMap = { permissive: 20, neutral: 40, strict: 70, adversarial: 90 };
+    return {
+        severity: severityMap[assumptions.severity ?? 'moderate'] ?? 50,
+        environmentalHostility: hostilityMap[assumptions.environmental_hostility ?? 'moderate'] ?? 50,
+        timePressure: timeMap[assumptions.time_pressure ?? 'moderate'] ?? 50,
+        regulatoryClimate: regMap[assumptions.regulatory_climate ?? 'neutral'] ?? 50,
+    };
+}
+function slidersToAssumptions(sliders) {
+    const severity = sliders.severity >= 80 ? 'critical' : sliders.severity >= 60 ? 'high' : sliders.severity >= 35 ? 'moderate' : 'low';
+    const hostility = sliders.environmentalHostility >= 60 ? 'high' : sliders.environmentalHostility >= 35 ? 'moderate' : 'low';
+    const time = sliders.timePressure >= 85 ? 'immediate' : sliders.timePressure >= 65 ? 'urgent' : sliders.timePressure >= 40 ? 'moderate' : sliders.timePressure >= 20 ? 'low' : 'none';
+    const reg = sliders.regulatoryClimate >= 80 ? 'adversarial' : sliders.regulatoryClimate >= 60 ? 'strict' : sliders.regulatoryClimate >= 35 ? 'neutral' : 'permissive';
+    return {
+        severity: severity,
+        environmental_hostility: hostility,
+        time_pressure: time,
+        regulatory_climate: reg,
+    };
+}
+exports.presetScenarios = Object.entries(index_1.SCENARIO_TEMPLATES).map(([id, template]) => ({
+    id,
+    title: template.title,
+    description: template.scenario.slice(0, 120) + (template.scenario.length > 120 ? '...' : ''),
+    tags: [...(template.tags ?? [])],
+    stakeholderCount: template.stakeholders.length,
+    type: templateIdToType(id),
+    defaultSliders: assumptionsToSliders(template.assumptions),
+}));
+// ============================================
+// ENGINE RESPONSE → UI TYPES MAPPING
+// ============================================
+function mapRiskLevel(risk) {
+    if (risk === 'critical' || risk === 'high')
+        return 'high';
+    if (risk === 'moderate')
+        return 'medium';
+    return 'low';
+}
+function mapPaths(response) {
+    const paths = response.analysis.paths;
+    const sorted = [...paths].sort((a, b) => {
+        const order = { low: 0, moderate: 1, high: 2, critical: 3 };
+        return order[a.risk] - order[b.risk];
+    });
+    const recommendedId = sorted[0]?.id;
+    return paths.map(p => ({
+        name: p.label,
+        description: p.description,
+        probability: Math.round(p.probability * 100),
+        riskLevel: mapRiskLevel(p.risk),
+        tradeoffs: [...p.tradeoffs],
+        recommended: p.id === recommendedId,
+    }));
+}
+function mapMatrix(response) {
+    const paths = response.analysis.paths.slice(0, 3);
+    const stakeholderIds = [
+        ...new Set([
+            ...paths.flatMap(p => [...(p.benefits_stakeholders ?? []), ...(p.harms_stakeholders ?? [])]),
+        ]),
+    ].slice(0, 6);
+    const strategies = paths.map(p => p.label);
+    const stakeholders = stakeholderIds.length > 0 ? stakeholderIds : ['Stakeholder A', 'Stakeholder B', 'Stakeholder C'];
+    const reactions = stakeholders.map((sh) => paths.map(p => {
+        if (p.benefits_stakeholders?.includes(sh))
+            return 'positive';
+        if (p.harms_stakeholders?.includes(sh))
+            return 'negative';
+        return 'neutral';
+    }));
+    return { strategies, stakeholders, reactions };
+}
+function mapOutcomes(response) {
+    const impactToRating = {
+        very_positive: 2, positive: 4, neutral: 5, negative: 7, very_negative: 9,
+    };
+    return response.analysis.projected_outcomes.map(o => ({
+        label: o.label,
+        type: (o.label.toLowerCase().includes('best') ? 'best' :
+            o.label.toLowerCase().includes('likely') ? 'likely' :
+                o.label.toLowerCase().includes('worst') ? 'worst' : 'tail'),
+        conditions: o.conditions,
+        description: o.outcome,
+        likelihood: Math.round(o.likelihood * 100),
+        impactRating: impactToRating[o.impact] ?? 5,
+    }));
+}
+function mapChallenges(response) {
+    return response.analysis.assumption_challenges.map(c => ({
+        assumption: c.assumption,
+        whyItMightFail: c.challenge,
+        whatChanges: c.impact_if_wrong,
+        severity: c.severity === 'critical' ? 'critical' : c.severity,
+    }));
+}
+function mapRecommendations(response) {
+    return response.analysis.recommendations.map(r => ({
+        priority: r.priority,
+        action: r.action,
+        rationale: r.rationale,
+        timeframe: r.timeframe,
+    }));
+}
+function mapGovernance(response) {
+    const g = response.governance;
+    if (!g)
+        return undefined;
+    return {
+        traceId: g.trace_id,
+        constitutionalChecks: g.constitutional_checks.map(c => ({
+            ruleId: c.rule_id,
+            rule: c.rule,
+            passed: c.passed,
+            detail: c.detail,
+        })),
+        authorityLevel: g.authority_level,
+        enforcedConstraints: [...g.enforced_constraints],
+        timestamp: g.timestamp,
+        engineVersion: g.engine_version,
+        neuroverse: g.neuroverse ? {
+            guardStatus: g.neuroverse.guard_status,
+            worldViability: g.neuroverse.world_viability,
+            worldCollapsed: g.neuroverse.world_collapsed,
+            collapseRisk: g.neuroverse.collapse_risk,
+            rulesFired: g.neuroverse.rules_fired,
+            worldHealthScore: g.neuroverse.world_health_score,
+            invariantCoverage: g.neuroverse.invariant_coverage,
+        } : undefined,
+    };
+}
+function deriveConfidence(response) {
+    const paths = response.analysis.paths;
+    const challenges = response.analysis.assumption_challenges;
+    const highRiskPaths = paths.filter(p => p.risk === 'high' || p.risk === 'critical').length;
+    const avgProbability = paths.reduce((s, p) => s + p.probability, 0) / Math.max(paths.length, 1);
+    // Factor in governance signals when available
+    const nv = response.governance?.neuroverse;
+    const worldHealth = nv?.world_health_score;
+    const collapseRisk = nv?.collapse_risk;
+    let level = 'medium';
+    let reason;
+    // Adjust thresholds based on simulation dynamics
+    const simPenalty = collapseRisk === 'high' ? 0.15 : collapseRisk === 'moderate' ? 0.08 : 0;
+    const adjustedAvgProb = avgProbability - simPenalty;
+    if (challenges.length <= 1 && highRiskPaths === 0 && adjustedAvgProb > 0.6) {
+        level = 'high';
+        reason = `Analysis covers ${paths.length} paths with low assumption risk and strong probability signals.`;
+        if (worldHealth && worldHealth < 70) {
+            level = 'medium';
+            reason += ` System stability at ${worldHealth}% — moderate uncertainty from simulation dynamics.`;
+        }
+    }
+    else if (challenges.length >= 4 || highRiskPaths >= 2 || adjustedAvgProb < 0.3) {
+        level = 'low';
+        reason = `High uncertainty: ${challenges.length} assumptions challenged, ${highRiskPaths} high-risk paths, average probability ${(avgProbability * 100).toFixed(0)}%.`;
+        if (collapseRisk === 'high') {
+            reason += ` Elevated collapse risk detected in simulation.`;
+        }
+    }
+    else {
+        reason = `Moderate confidence: ${paths.length} paths analyzed, ${challenges.length} assumptions challenged.`;
+        if (worldHealth) {
+            reason += ` System stability: ${worldHealth}%.`;
+        }
+        else {
+            reason += ` Some uncertainty remains.`;
+        }
+    }
+    return { level, reason };
+}
+function deriveKeyAssumptions(request, response) {
+    const assumptions = [];
+    // Caller-provided assumptions
+    if (request.assumptions?.severity) {
+        assumptions.push({ text: `Severity is ${request.assumptions.severity}`, source: 'caller' });
+    }
+    if (request.assumptions?.time_pressure) {
+        assumptions.push({ text: `Time pressure is ${request.assumptions.time_pressure}`, source: 'caller' });
+    }
+    if (request.assumptions?.environmental_hostility) {
+        assumptions.push({ text: `Environmental hostility is ${request.assumptions.environmental_hostility}`, source: 'caller' });
+    }
+    if (request.assumptions?.regulatory_climate) {
+        assumptions.push({ text: `Regulatory climate is ${request.assumptions.regulatory_climate}`, source: 'caller' });
+    }
+    // Inferred assumptions
+    if (request.stakeholders && request.stakeholders.length > 0) {
+        assumptions.push({ text: `${request.stakeholders.length} stakeholders identified with known dispositions`, source: 'inferred' });
+    }
+    // Default assumptions
+    if (!request.constraints?.time_horizon) {
+        assumptions.push({ text: 'No explicit time horizon — using general framework', source: 'default' });
+    }
+    if (!request.constraints?.risk_tolerance) {
+        assumptions.push({ text: 'Risk tolerance not specified — assuming moderate', source: 'default' });
+    }
+    return assumptions;
+}
+function mapResponseToResult(response, request) {
+    return {
+        paths: mapPaths(response),
+        matrix: mapMatrix(response),
+        outcomes: mapOutcomes(response),
+        challenges: mapChallenges(response),
+        recommendations: mapRecommendations(response),
+        governance: mapGovernance(response),
+        confidence: deriveConfidence(response),
+        keyAssumptions: deriveKeyAssumptions(request, response),
+        goalResult: response.goal_reasoning,
+        mode: response.mode,
+        lastRequest: request,
+    };
+}
+/**
+ * Generate reasoning using the Echelon engine.
+ * Maps UI types (Scenario + SliderValues) → engine ReasonRequest → UI ReasoningResult.
+ */
+async function generateReasoning(scenario, sliders, options) {
+    const scenarioText = typeof scenario === 'string'
+        ? scenario
+        : index_1.SCENARIO_TEMPLATES[scenario.id]?.scenario ?? scenario.description;
+    const assumptions = slidersToAssumptions(sliders);
+    // Get stakeholders from template if available, or from options
+    const templateId = typeof scenario === 'object' ? scenario.id : undefined;
+    const template = templateId ? index_1.SCENARIO_TEMPLATES[templateId] : undefined;
+    let stakeholders;
+    if (options?.stakeholders && options.stakeholders.length > 0) {
+        stakeholders = options.stakeholders.map(s => ({
+            id: s.id,
+            disposition: s.disposition,
+        }));
+    }
+    else if (template?.stakeholders) {
+        stakeholders = [...template.stakeholders];
+    }
+    const request = {
+        scenario: scenarioText,
+        stakeholders,
+        assumptions,
+        constraints: options?.constraints ? {
+            time_horizon: options.constraints.timeHorizon || undefined,
+            risk_tolerance: options.constraints.riskTolerance,
+            budget: options.constraints.budget || undefined,
+        } : template?.constraints,
+        depth: options?.depth ?? 'full',
+        perspective: 'strategic_advisor',
+        swarm: template?.swarm ?? { enabled: true, rounds: 3, reaction_model: 'mixed' },
+        mode: options?.mode,
+        goal: options?.goal,
+    };
+    const response = await (0, index_1.processReasonRequest)(request);
+    if (response.status === 'error') {
+        return {
+            paths: [],
+            matrix: { strategies: [], stakeholders: [], reactions: [] },
+            outcomes: [],
+            challenges: [],
+            recommendations: [],
+        };
+    }
+    return mapResponseToResult(response, request);
+}