@neuroverseos/nv-sim 0.1.2 → 0.1.5

package/dist/engine/worldStorage.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * World Storage — Decision Memory
+ *
+ * Save and load custom worlds as JSON. No cloud, no accounts.
+ * The world IS the data — portable, shareable, testable.
+ *
+ * Storage layers:
+ *   Browser: localStorage (for UI)
+ *   CLI: JSON files on disk (for dev workflows)
+ *
+ * A saved world captures:
+ *   - The base world it was built from (preset ID)
+ *   - Custom rules the user added
+ *   - Metadata (name, description, timestamp)
+ *
+ * This turns transient experiments into reusable decision artifacts.
+ *
+ * Powered by @neuroverseos/governance world format.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveWorldToStorage = saveWorldToStorage;
+exports.listWorldsFromStorage = listWorldsFromStorage;
+exports.loadWorldFromStorage = loadWorldFromStorage;
+exports.deleteWorldFromStorage = deleteWorldFromStorage;
+exports.exportWorldToJSON = exportWorldToJSON;
+exports.importWorldFromJSON = importWorldFromJSON;
+exports.createSavedWorld = createSavedWorld;
+exports.forkWorld = forkWorld;
+exports.saveWorldToFile = saveWorldToFile;
+exports.loadWorldFromFile = loadWorldFromFile;
+// ============================================
+// BROWSER STORAGE (localStorage)
+// ============================================
+const STORAGE_KEY = "nv-sim-saved-worlds";
+/**
+ * Runtime registry for worlds loaded from files (CLI context).
+ * Falls back to this when localStorage is unavailable.
+ */
+const runtimeRegistry = [];
+function hasLocalStorage() {
+    try {
+        return typeof localStorage !== "undefined" && localStorage !== null;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Save a world to browser localStorage (or runtime registry in CLI).
+ */
+function saveWorldToStorage(world) {
+    if (!hasLocalStorage()) {
+        const idx = runtimeRegistry.findIndex(w => w.id === world.id);
+        if (idx >= 0)
+            runtimeRegistry[idx] = world;
+        else
+            runtimeRegistry.push(world);
+        return;
+    }
+    const existing = listWorldsFromStorage();
+    const idx = existing.findIndex(w => w.id === world.id);
+    if (idx >= 0) {
+        existing[idx] = { ...world, modifiedAt: new Date().toISOString() };
+    }
+    else {
+        existing.push(world);
+    }
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(existing));
+}
+/**
+ * List all saved worlds from browser localStorage (or runtime registry).
+ */
+function listWorldsFromStorage() {
+    if (!hasLocalStorage()) {
+        return [...runtimeRegistry];
+    }
+    try {
+        const raw = localStorage.getItem(STORAGE_KEY);
+        if (!raw)
+            return [];
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Load a specific saved world by ID from localStorage (or runtime registry).
+ */
+function loadWorldFromStorage(id) {
+    const worlds = listWorldsFromStorage();
+    return worlds.find(w => w.id === id) ?? null;
+}
+/**
+ * Delete a saved world from localStorage (or runtime registry).
+ */
+function deleteWorldFromStorage(id) {
+    if (!hasLocalStorage()) {
+        const idx = runtimeRegistry.findIndex(w => w.id === id);
+        if (idx < 0)
+            return false;
+        runtimeRegistry.splice(idx, 1);
+        return true;
+    }
+    const worlds = listWorldsFromStorage();
+    const filtered = worlds.filter(w => w.id !== id);
+    if (filtered.length === worlds.length)
+        return false;
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(filtered));
+    return true;
+}
+// ============================================
+// JSON EXPORT / IMPORT
+// ============================================
+/**
+ * Export a saved world to a JSON string (for file download or CLI).
+ */
+function exportWorldToJSON(world) {
+    return JSON.stringify(world, null, 2);
+}
+/**
+ * Import a saved world from a JSON string.
+ * Validates the structure before returning.
+ */
+function importWorldFromJSON(json) {
+    const parsed = JSON.parse(json);
+    if (!parsed.version || !parsed.id || !parsed.name || !parsed.world) {
+        throw new Error("Invalid world format: missing required fields (version, id, name, world)");
+    }
+    if (!parsed.world.thesis || !Array.isArray(parsed.world.invariants)) {
+        throw new Error("Invalid world definition: missing thesis or invariants");
+    }
+    return parsed;
+}
+// ============================================
+// WORLD CREATION HELPERS
+// ============================================
+/**
+ * Create a new SavedWorld from a world definition.
+ */
+function createSavedWorld(name, world, basePreset, options) {
+    const id = `world_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const now = new Date().toISOString();
+    return {
+        version: "1.0",
+        id,
+        name,
+        description: options?.description,
+        basePreset,
+        world,
+        createdAt: now,
+        modifiedAt: now,
+        tags: options?.tags,
+    };
+}
+/**
+ * Fork an existing world with modifications.
+ */
+function forkWorld(source, name, modifications) {
+    const invariants = [
+        ...source.world.invariants.filter(i => !modifications.removeInvariantIds?.includes(i.id)),
+        ...(modifications.addInvariants ?? []),
+    ];
+    const gates = [
+        ...(source.world.gates ?? []).filter(g => !modifications.removeGateIds?.includes(g.id)),
+        ...(modifications.addGates ?? []),
+    ];
+    const world = {
+        ...source.world,
+        thesis: modifications.thesis ?? source.world.thesis,
+        invariants,
+        gates,
+    };
+    return createSavedWorld(name, world, source.id, {
+        description: `Forked from "${source.name}"`,
+        tags: [...(source.tags ?? []), "forked"],
+    });
+}
+// ============================================
+// FILE I/O (Node.js only — for CLI)
+// ============================================
+/**
+ * Save a world to a JSON file on disk.
+ * Only works in Node.js (CLI context).
+ */
+async function saveWorldToFile(world, filePath) {
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    fs.writeFileSync(filePath, exportWorldToJSON(world), "utf-8");
+}
+/**
+ * Load a world from a JSON file on disk.
+ * Only works in Node.js (CLI context).
+ */
+async function loadWorldFromFile(filePath) {
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    const content = fs.readFileSync(filePath, "utf-8");
+    return importWorldFromJSON(content);
+}

package/dist/index.html

@@ -0,0 +1,23 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>NV-SIM — NeuroVerse Simulation</title>
+    <meta name="description" content="Governed agent simulation — compare emergent outcomes with and without governance constraints.">
+    <meta name="author" content="NeuroverseOS" />
+    <meta property="og:type" content="website" />
+    <meta property="og:title" content="NV-SIM — NeuroVerse Simulation">
+    <meta property="og:description" content="Governed agent simulation — compare emergent outcomes with and without governance constraints.">
+    <meta name="twitter:card" content="summary" />
+    <meta name="twitter:site" content="@neuroverseos" />
+    <meta name="twitter:title" content="NV-SIM — NeuroVerse Simulation">
+    <meta name="twitter:description" content="Governed agent simulation — compare emergent outcomes with and without governance constraints.">
+    <link rel="icon" type="image/x-icon" href="/favicon.ico">
+    <script type="module" crossorigin src="/assets/index-DbzSnYxr.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B64NuIXu.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

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);
+}