@neuroverseos/nv-sim 0.1.9 → 0.1.11

package/dist/engine/primeRadiant.js

@@ -2,16 +2,10 @@
 /**
  * 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)
+ *   Merge knowledge graph + policy constraints (NeuroverseOS)
  *   → Governed world file ready for simulation
  *
  * MODE 2: GOVERNED SIMULATION
@@ -299,7 +293,7 @@ function buildNarrative(governed, baseline, delta) {
  * Pre-built Prime Radiant configurations for common scenarios.
  */
 exports.PRIME_RADIANT_PRESETS = {
-    /** University disciplinary crisis (inspired by MiroFish demo) */
+    /** University disciplinary crisis */
     university_crisis: {
         scenario: "A university's disciplinary decision sparks widespread backlash. " +
             "Students, media, alumni, and government stakeholders react across social platforms. " +

package/dist/engine/reasoningEngine.js

@@ -20,7 +20,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processReasonRequest = processReasonRequest;
-const mirofish_1 = require("./mirofish");
+const swarmSimulation_1 = require("./swarmSimulation");
 const governance_1 = require("./governance");
 const goalEngine_1 = require("./goalEngine");
 // ============================================
@@ -420,14 +420,9 @@ async function processReasonRequest(request) {
         missing_questions: identifyMissingQuestions(request, stakeholders),
     };
     // 9. Run swarm simulation (if requested)
-    //    Uses MiroFish when available, falls back to Echelon-native.
-    //    MiroFish shows WHAT happens. Echelon reasons about WHAT IT MEANS.
     let swarmResult = undefined;
-    let simulationSource;
     if (request.swarm?.enabled && stakeholders.length > 0) {
-        const unified = await (0, mirofish_1.runUnifiedSimulation)(request.scenario, stakeholders, paths, request.swarm);
-        swarmResult = unified.result;
-        simulationSource = unified.source;
+        swarmResult = await (0, swarmSimulation_1.runSwarmSimulation)(request.scenario, stakeholders, paths, request.swarm);
     }
     // 10. Goal-directed reasoning (if goal mode)
     //     "How do I get here?" — works backward from desired outcome

package/dist/engine/scenarioCapsule.js

@@ -11,7 +11,7 @@
  * - initial evidence signals
  *
  * Capsules can be:
- * 1. Encoded in a URL: mirotir.com/run#capsule=<encoded>
+ * 1. Encoded in a URL: neuroverse.dev/run#capsule=<encoded>
  * 2. Downloaded as JSON: scenario.capsule.json
  * 3. Generated via API: POST /api/v1/scenario → capsule
  * 4. Created by agents: autonomous agents generate decision worlds
@@ -81,7 +81,7 @@ function capsuleToReasonRequest(capsule) {
 // ============================================
 /**
  * Encode a capsule for URL embedding.
- * Result can be used as: mirotir.com/run#capsule=<encoded>
+ * Result can be used as: neuroverse.dev/run#capsule=<encoded>
  */
 function encodeCapsule(capsule) {
     const json = JSON.stringify(capsule);
@@ -123,7 +123,7 @@ function decodeCapsule(encoded) {
 /**
  * Build a shareable URL from a capsule.
  */
-function buildShareableUrl(capsule, baseUrl = "https://mirotir.com") {
+function buildShareableUrl(capsule, baseUrl = "https://neuroverse.dev") {
     const encoded = encodeCapsule(capsule);
     return `${baseUrl}/run#capsule=${encoded}`;
 }
@@ -158,7 +158,7 @@ function computeCapsuleHash(data) {
 // PRESET SCENARIO TEMPLATES
 // ============================================
 /**
- * Built-in scenario templates that demonstrate Mirotir's capabilities.
+ * Built-in scenario templates that demonstrate NeuroVerse's capabilities.
  * These are the "instant insight" scenarios that make people share.
  */
 exports.SCENARIO_TEMPLATES = {
@@ -189,7 +189,7 @@ exports.SCENARIO_TEMPLATES = {
         depth: "full",
         perspective: "strategic_advisor",
         swarm: { enabled: true, rounds: 6, reaction_model: "mixed" },
-        tags: ["social", "simulation", "agents", "mirofish", "opinion", "discourse"],
+        tags: ["social", "simulation", "agents", "opinion", "discourse"],
         world: {
             world_id: "social_simulation",
             name: "Multi-Agent Social Simulation",

package/dist/engine/swarmSimulation.js

@@ -4,18 +4,10 @@
  *
  * Lightweight stakeholder reaction simulation for POST /reason.
  *
- * IMPORTANT — MiroFish License Compliance:
- * This is NOT MiroFish. This is Echelon's own lightweight reaction model.
- * MiroFish is a separate product with its own license.
- * If/when MiroFish integration is desired, it would be called as an
- * external service via its REST API, respecting its license terms.
- *
  * This simulation layer uses:
  * - Echelon-native stakeholder modeling
  * - Simplified reaction dynamics (rational, emotional, mixed)
  * - Projected reactions based on scenario decomposition
- *
- * It does NOT use MiroFish internals, algorithms, or data structures.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSwarmSimulation = runSwarmSimulation;
@@ -203,7 +195,7 @@ function findInflectionPoints(rounds) {
 /**
  * Run the swarm simulation.
  *
- * This is Echelon's native reaction model — NOT MiroFish.
+ * This is Echelon's native reaction model.
  * It simulates how stakeholders react to different reasoning paths
  * over multiple rounds, detecting emergent dynamics.
  *

package/dist/engine/universalAdapter.js

@@ -0,0 +1,371 @@
+"use strict";
+/**
+ * Universal Adapter — Normalize ANY agent system output into governable actions.
+ *
+ * This is the core abstraction that makes NeuroVerse work with ANY system:
+ *
+ *   External Output (JSONL/JSON) → EngineProfile maps fields → AgentAction → govern()
+ *
+ * Pre-built profiles for known systems (ScienceClaw, MiroFish).
+ * Custom profile auto-detects common field patterns.
+ *
+ * Usage:
+ *   const adapter = createUniversalAdapter("scienceclaw");
+ *   const results = adapter.evaluateAll(jsonlLines, policyText);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENGINE_PROFILES = void 0;
+exports.mapToAgentAction = mapToAgentAction;
+exports.parseInput = parseInput;
+exports.createUniversalAdapter = createUniversalAdapter;
+exports.getEngineProfiles = getEngineProfiles;
+exports.detectEngine = detectEngine;
+const govern_1 = require("../runtime/govern");
+// ============================================
+// PRE-BUILT ENGINE PROFILES
+// ============================================
+exports.ENGINE_PROFILES = {
+    scienceclaw: {
+        id: "scienceclaw",
+        name: "ScienceClaw",
+        description: "Autonomous research discovery agent. Evaluates artifacts like hypotheses, papers, synthesis, and ML predictions.",
+        outputFormat: "jsonl",
+        color: "blue",
+        icon: "Microscope",
+        fieldMap: {
+            agentId: ["agent_id", "agentId", "agent"],
+            actionType: ["type", "artifact_type", "action"],
+            description: ["description", "title", "summary"],
+            magnitude: ["confidence", "magnitude"],
+            cycle: ["cycle", "step", "round"],
+            contextFields: ["citations", "paper_count", "insight_count", "sources", "features", "reproduced", "provenance"],
+        },
+        exampleLine: '{"agent_id": "harry", "type": "synthesis", "description": "Cross-domain analysis of coordination failures", "confidence": 0.85, "cycle": 3, "paper_count": 0, "insight_count": 0}',
+        exampleRules: [
+            "Block synthesis when paper_count is 0",
+            "Block results with no peer-reviewed sources",
+            "Require at least 2 independent data sources before analysis",
+            "Penalize agents that publish without citations",
+            "Halt investigation when confidence drops below 0.4",
+            "Reward findings validated by multiple methods",
+        ].join("\n"),
+        captureInstructions: [
+            "# Option A: Use the replay demo (no ScienceClaw needed)",
+            "# Place your ScienceClaw JSONL output in examples/scienceclaw/",
+            "",
+            "# Option B: Capture live output",
+            "# Run ScienceClaw and save output to JSONL:",
+            "scienceclaw run --topic 'your topic' --output artifacts.jsonl",
+            "",
+            "# Option C: Use existing demo data",
+            "# We include Harry's investigation: examples/scienceclaw/harry-investigation.jsonl",
+        ].join("\n"),
+        tags: ["science", "research", "discovery"],
+    },
+    mirofish: {
+        id: "mirofish",
+        name: "MiroFish / OASIS",
+        description: "Social simulation platform. Evaluates agent behaviors like posting, sharing, belief formation, and swarm dynamics.",
+        outputFormat: "jsonl",
+        color: "violet",
+        icon: "Users",
+        fieldMap: {
+            agentId: ["agent_id", "agentId", "user_id", "agent"],
+            actionType: ["action", "type", "action_type", "event_type"],
+            description: ["content", "text", "description", "message"],
+            magnitude: ["influence", "reach", "magnitude", "impact"],
+            cycle: ["step", "tick", "round", "cycle", "timestamp"],
+            contextFields: ["sentiment", "hashtags", "mentions", "followers", "retweets", "likes", "belief", "confidence", "group", "coalition"],
+        },
+        exampleLine: '{"agent_id": "user_42", "action": "create_post", "content": "Breaking: new study confirms X", "influence": 0.7, "step": 5, "sentiment": "positive", "followers": 1200}',
+        exampleRules: [
+            "Block posts that amplify unverified claims",
+            "Penalize agents that repeat unvalidated information",
+            "Halt cascade when echo amplification exceeds 60%",
+            "Require independent sources before sharing conclusions",
+            "Reward agents that challenge dominant consensus",
+            "Slow viral spread of unverified content",
+        ].join("\n"),
+        captureInstructions: [
+            "# Option A: Capture OASIS output",
+            "# Run your OASIS/MiroFish simulation and save agent actions:",
+            "python run_simulation.py --output agent_actions.jsonl",
+            "",
+            "# Option B: Export from existing run",
+            "# If you have a completed simulation, export the action log:",
+            "python export_actions.py --run-id <id> --format jsonl > actions.jsonl",
+            "",
+            "# Each line should have: agent_id, action, content, step",
+        ].join("\n"),
+        tags: ["social", "swarm", "simulation"],
+    },
+    langchain: {
+        id: "langchain",
+        name: "LangChain / LangGraph",
+        description: "LLM agent framework. Evaluates tool calls, chain steps, and agent decisions.",
+        outputFormat: "jsonl",
+        color: "green",
+        icon: "Link",
+        fieldMap: {
+            agentId: ["agent_id", "agent", "chain_id", "run_id"],
+            actionType: ["tool", "action", "type", "step_type"],
+            description: ["input", "description", "query", "tool_input"],
+            magnitude: ["confidence", "score", "magnitude"],
+            cycle: ["step", "iteration", "cycle"],
+            contextFields: ["output", "tool_output", "tokens", "latency", "model"],
+        },
+        exampleLine: '{"agent_id": "researcher", "tool": "web_search", "input": "latest findings on CRISPR efficiency", "step": 2, "confidence": 0.6}',
+        exampleRules: [
+            "Block web searches without clear research purpose",
+            "Require source validation before generating conclusions",
+            "Penalize agents that skip verification steps",
+            "Halt chain when confidence drops below 0.5",
+            "Reward tool use that cross-references multiple sources",
+        ].join("\n"),
+        captureInstructions: [
+            "# Enable LangChain callback logging:",
+            "from langchain.callbacks import FileCallbackHandler",
+            "handler = FileCallbackHandler('agent_log.jsonl')",
+            "agent.run('your query', callbacks=[handler])",
+            "",
+            "# Or use LangSmith export:",
+            "langsmith export --run-id <id> --format jsonl > actions.jsonl",
+        ].join("\n"),
+        tags: ["llm", "agent", "tools"],
+    },
+    custom: {
+        id: "custom",
+        name: "Custom / Any System",
+        description: "Any agent system that produces structured output. We auto-detect common field patterns.",
+        outputFormat: "jsonl",
+        color: "zinc",
+        icon: "FileJson",
+        fieldMap: {
+            agentId: ["agent_id", "agentId", "agent", "id", "user_id", "actor", "name"],
+            actionType: ["type", "action", "action_type", "event", "event_type", "tool", "step_type"],
+            description: ["description", "content", "text", "message", "summary", "title", "input", "query"],
+            magnitude: ["confidence", "magnitude", "score", "impact", "influence", "weight", "intensity"],
+            cycle: ["cycle", "step", "round", "tick", "iteration", "timestamp", "sequence"],
+            contextFields: [],
+        },
+        exampleLine: '{"agent_id": "agent_1", "type": "decision", "description": "Chose option A based on analysis", "confidence": 0.75, "step": 1}',
+        exampleRules: [
+            "Block actions with confidence below 0.5",
+            "Require validation before final decisions",
+            "Penalize agents that skip verification",
+            "Halt when error rate exceeds threshold",
+            "Reward independent convergence on same conclusion",
+        ].join("\n"),
+        captureInstructions: [
+            "# Save your agent system's output as JSONL (one JSON object per line).",
+            "# Each line should have at minimum:",
+            "#   - An agent identifier (agent_id, agent, id, etc.)",
+            "#   - An action type (type, action, event, etc.)",
+            "#   - A description (description, content, text, etc.)",
+            "",
+            "# Example:",
+            '# {"agent_id": "bot_1", "type": "decision", "description": "Selected strategy X", "step": 1}',
+            '# {"agent_id": "bot_2", "type": "analysis", "description": "Analyzed data from source Y", "step": 1}',
+        ].join("\n"),
+        tags: ["custom", "generic"],
+    },
+};
+// ============================================
+// FIELD EXTRACTION — resolve multi-name fields
+// ============================================
+function extractField(record, candidates) {
+    const names = typeof candidates === "string" ? [candidates] : candidates;
+    for (const name of names) {
+        if (name in record && record[name] != null) {
+            return record[name];
+        }
+    }
+    return undefined;
+}
+function extractString(record, candidates, fallback) {
+    const val = extractField(record, candidates);
+    if (typeof val === "string")
+        return val;
+    if (val != null)
+        return String(val);
+    return fallback;
+}
+function extractNumber(record, candidates, fallback) {
+    const val = extractField(record, candidates);
+    if (typeof val === "number")
+        return Math.max(0, Math.min(1, val));
+    if (typeof val === "string") {
+        const n = parseFloat(val);
+        if (!isNaN(n))
+            return Math.max(0, Math.min(1, n));
+    }
+    return fallback;
+}
+// ============================================
+// MAP RAW RECORD → AgentAction
+// ============================================
+function mapToAgentAction(record, profile, cycleOverride) {
+    const fm = profile.fieldMap;
+    const agentId = extractString(record, fm.agentId, "");
+    if (!agentId)
+        return { error: "No agent identifier found" };
+    const actionType = extractString(record, fm.actionType, "unknown");
+    const description = extractString(record, fm.description, `${agentId}: ${actionType}`);
+    const magnitude = extractNumber(record, fm.magnitude, 0.5);
+    const cycle = cycleOverride ?? (typeof extractField(record, fm.cycle) === "number"
+        ? extractField(record, fm.cycle)
+        : 0);
+    // Build context from contextFields
+    const context = { source: profile.id, cycle };
+    if (fm.contextFields) {
+        for (const field of fm.contextFields) {
+            if (field in record) {
+                context[field] = record[field];
+            }
+        }
+    }
+    return {
+        action: { agentId, type: actionType, description, magnitude, context },
+        cycle,
+    };
+}
+// ============================================
+// PARSE INPUT — handle JSONL, JSON array, pasted text
+// ============================================
+function parseInput(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    // Try JSON array first
+    if (trimmed.startsWith("[")) {
+        try {
+            const arr = JSON.parse(trimmed);
+            if (Array.isArray(arr))
+                return arr;
+        }
+        catch { /* fall through to JSONL */ }
+    }
+    // JSONL: one JSON object per line
+    const records = [];
+    for (const line of trimmed.split("\n")) {
+        const l = line.trim();
+        if (!l || l.startsWith("#") || l.startsWith("//"))
+            continue;
+        try {
+            const obj = JSON.parse(l);
+            if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+                records.push(obj);
+            }
+        }
+        catch { /* skip unparseable lines */ }
+    }
+    return records;
+}
+function createUniversalAdapter(engineId) {
+    const profile = exports.ENGINE_PROFILES[engineId];
+    if (!profile) {
+        throw new Error(`Unknown engine: ${engineId}. Available: ${Object.keys(exports.ENGINE_PROFILES).join(", ")}`);
+    }
+    return {
+        profile,
+        evaluateAll(rawInput, policyText) {
+            const records = parseInput(rawInput);
+            const results = [];
+            const parseErrors = [];
+            const governor = (0, govern_1.createGovernor)({ policyText });
+            for (let i = 0; i < records.length; i++) {
+                const mapped = mapToAgentAction(records[i], profile);
+                if ("error" in mapped) {
+                    parseErrors.push({ index: i, error: mapped.error });
+                    continue;
+                }
+                const verdict = governor.evaluate(mapped.action);
+                results.push({
+                    raw: records[i],
+                    action: mapped.action,
+                    verdict,
+                    cycle: mapped.cycle,
+                    index: i,
+                });
+            }
+            // Compute summary
+            const counts = { allowed: 0, blocked: 0, modified: 0, paused: 0, rewarded: 0, penalized: 0 };
+            const agentSet = new Set();
+            const typeSet = new Set();
+            const reasonSet = new Set();
+            for (const r of results) {
+                const s = r.verdict.status;
+                if (s === "ALLOW")
+                    counts.allowed++;
+                else if (s === "BLOCK")
+                    counts.blocked++;
+                else if (s === "MODIFY")
+                    counts.modified++;
+                else if (s === "PAUSE")
+                    counts.paused++;
+                else if (s === "REWARD")
+                    counts.rewarded++;
+                else if (s === "PENALIZE")
+                    counts.penalized++;
+                agentSet.add(r.action.agentId);
+                typeSet.add(r.action.type);
+                if (s === "BLOCK" || s === "PENALIZE") {
+                    reasonSet.add(r.verdict.reason);
+                }
+            }
+            const total = results.length;
+            const failRate = total > 0 ? (counts.blocked + counts.penalized) / total : 0;
+            return {
+                results,
+                total,
+                counts,
+                failRate,
+                agents: [...agentSet],
+                actionTypes: [...typeSet],
+                blockReasons: [...reasonSet],
+                parseErrors,
+                engineId: profile.id,
+            };
+        },
+        evaluateOne(record, policyText) {
+            const mapped = mapToAgentAction(record, profile);
+            if ("error" in mapped)
+                return mapped;
+            const verdict = (0, govern_1.govern)(mapped.action, {}, policyText);
+            return {
+                raw: record,
+                action: mapped.action,
+                verdict,
+                cycle: mapped.cycle,
+                index: 0,
+            };
+        },
+    };
+}
+// ============================================
+// HELPERS
+// ============================================
+/** Get all available engine profiles */
+function getEngineProfiles() {
+    return Object.values(exports.ENGINE_PROFILES);
+}
+/** Auto-detect which engine profile best matches a set of records */
+function detectEngine(records) {
+    if (records.length === 0)
+        return "custom";
+    const sample = records[0];
+    const keys = Object.keys(sample).join(",").toLowerCase();
+    // ScienceClaw signatures
+    if (keys.includes("paper_count") || keys.includes("insight_count") || keys.includes("artifact_type")) {
+        return "scienceclaw";
+    }
+    // MiroFish/OASIS signatures
+    if (keys.includes("followers") || keys.includes("retweets") || keys.includes("hashtags") || keys.includes("sentiment")) {
+        return "mirofish";
+    }
+    // LangChain signatures
+    if (keys.includes("tool_input") || keys.includes("tool_output") || keys.includes("chain_id")) {
+        return "langchain";
+    }
+    return "custom";
+}

package/dist/engine/worldBridge.js

@@ -59,18 +59,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.initNeuroverseModule = initNeuroverseModule;
 exports.buildWorldFromScenario = buildWorldFromScenario;
 exports.evaluateScenarioGuard = evaluateScenarioGuard;
+exports.getIncentiveSystem = getIncentiveSystem;
 exports.runWorldSimulation = runWorldSimulation;
 exports.validateScenarioWorld = validateScenarioWorld;
 exports.verdictToConstitutionalChecks = verdictToConstitutionalChecks;
 exports.simulationToGovernanceSignals = simulationToGovernanceSignals;
 exports.validationToEnforcedConstraints = validationToEnforcedConstraints;
-// ============================================
-// LAZY MODULE LOADER
-// ============================================
-/**
- * Lazy-load @neuroverseos/governance at runtime.
- * Returns null in browser environments where Node modules aren't available.
- */
 let _nvModule;
 async function getNVModule() {
     if (_nvModule !== undefined)
@@ -81,6 +75,10 @@ async function getNVModule() {
             evaluateGuard: mod.evaluateGuard,
             simulateWorld: mod.simulateWorld,
             validateWorld: mod.validateWorld,
+            createAgentState: mod.createAgentState,
+            applyConsequence: mod.applyConsequence,
+            applyReward: mod.applyReward,
+            tickAgentStates: mod.tickAgentStates,
         };
         return _nvModule;
     }
@@ -314,10 +312,26 @@ function evaluateScenarioGuard(request, world, options) {
             has_goal: !!request.goal,
         },
     };
-    return nv.evaluateGuard(event, world, {
+    const verdict = nv.evaluateGuard(event, world, {
         trace: options?.trace ?? true,
         level: options?.level ?? "standard",
     });
+    return verdict;
+}
+/**
+ * Get the incentive system functions from the loaded NeuroverseOS module.
+ * Returns null if the module isn't loaded or doesn't export incentive functions.
+ */
+function getIncentiveSystem() {
+    const nv = getNVModuleSync();
+    if (!nv || !nv.createAgentState)
+        return null;
+    return {
+        createAgentState: nv.createAgentState,
+        applyConsequence: nv.applyConsequence,
+        applyReward: nv.applyReward,
+        tickAgentStates: nv.tickAgentStates,
+    };
 }
 // ============================================
 // SIMULATION — World state evolution

package/dist/index.html

@@ -14,8 +14,8 @@
     <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-BMkPevVr.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-B64NuIXu.css">
+    <script type="module" crossorigin src="/assets/index-sT4b_z7w.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CH_VswRM.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/lib/reasoningEngine.js

@@ -276,7 +276,23 @@ async function generateReasoning(scenario, sliders, options) {
         mode: options?.mode,
         goal: options?.goal,
     };
-    const response = await (0, index_1.processReasonRequest)(request);
+    // All governance evaluation goes through the server.
+    // The browser NEVER evaluates governance locally — the server runs
+    // @neuroverseos/governance with full Node.js access and real enforcement.
+    const apiUrl = `${window.location.protocol}//${window.location.hostname}:3456/api/v1/reason`;
+    let response;
+    try {
+        const res = await fetch(apiUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
+        });
+        response = await res.json();
+    }
+    catch (err) {
+        console.error('Failed to reach governance server:', err);
+        response = { status: 'error' };
+    }
     if (response.status === 'error') {
         return {
             paths: [],

package/dist/lib/simulationAdapter.js

@@ -5,7 +5,7 @@
  * Converts output from ANY simulation engine into a normalized schema
  * that Echelon can reason about. Supported formats:
  *
- *   - MiroFish (JSON with agents + emergent_behaviors)
+ *   - Agent Swarm (JSON with agents + emergent_behaviors)
  *   - NetLogo (tick-based key:value output)
  *   - Mesa (Python agent action logs)
  *   - AnyLogic / CSV (time-series tabular data)
@@ -37,8 +37,8 @@ function detectFormat(input) {
     if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
         try {
             const data = JSON.parse(trimmed);
-            if (looksLikeMiroFish(data))
-                return "mirofish";
+            if (looksLikeAgentSwarm(data))
+                return "agent_swarm";
             return "generic_json";
         }
         catch {
@@ -56,7 +56,7 @@ function detectFormat(input) {
         return "mesa";
     return "freeform_text";
 }
-function looksLikeMiroFish(data) {
+function looksLikeAgentSwarm(data) {
     if (typeof data !== "object" || data === null)
         return false;
     const d = data;
@@ -107,8 +107,8 @@ function looksLikeMesa(text) {
 function parseSimulation(input) {
     const format = detectFormat(input);
     switch (format) {
-        case "mirofish":
-            return parseMiroFish(input);
+        case "agent_swarm":
+            return parseAgentSwarm(input);
         case "netlogo":
             return parseNetLogo(input);
         case "mesa":
@@ -121,8 +121,8 @@ function parseSimulation(input) {
             return parseFreeformText(input);
     }
 }
-// ── MiroFish Parser ──────────────────────────────────
-function parseMiroFish(input) {
+// ── Agent Swarm Parser ──────────────────────────────────
+function parseAgentSwarm(input) {
     const data = JSON.parse(input.trim());
     const agents = [];
     const events = [];
@@ -172,7 +172,7 @@ function parseMiroFish(input) {
             }
         }
     }
-    // Parse steps (MiroFish simulation output)
+    // Parse steps (simulation output)
     if (data.steps && Array.isArray(data.steps)) {
         for (const step of data.steps) {
             const t = step.step ?? step.round ?? timeline.length;
@@ -196,7 +196,7 @@ function parseMiroFish(input) {
         }
     }
     return {
-        sourceFormat: "mirofish",
+        sourceFormat: "agent_swarm",
         agents,
         events,
         stateChanges,
@@ -677,7 +677,7 @@ function extractAttributes(obj, exclude) {
 // FORMAT LABELS (for UI)
 // ============================================
 exports.FORMAT_LABELS = {
-    mirofish: "MiroFish",
+    agent_swarm: "Agent Swarm",
     netlogo: "NetLogo",
     mesa: "Mesa (Python)",
     anylogic_csv: "AnyLogic / CSV",