@neuroverseos/nv-sim 0.1.0 → 0.1.4

package/dist/engine/governance.js

@@ -110,10 +110,15 @@ function runFullGovernanceChecks(request, worldLite) {
         // Convert verdict to constitutional checks
         const nvChecks = (0, worldBridge_1.verdictToConstitutionalChecks)(guardVerdict);
         results.push(...nvChecks);
-        // If guard blocks, stop reasoning
+        // If guard blocks, note the intervention but continue in advisory mode
+        // (Reasoning continues so user can see what governance changed)
         if (guardVerdict.status === "BLOCK") {
-            allowed = false;
-            blockReason = `NeuroverseOS governance: ${guardVerdict.reason ?? "Action blocked by guard"}`;
+            results.push({
+                rule_id: "NV-BLOCK",
+                rule: "NeuroverseOS guard issued BLOCK — governance intervention active",
+                passed: false,
+                detail: `Guard blocked: ${guardVerdict.reason ?? "Action blocked by guard"}. Continuing in governed advisory mode.`,
+            });
         }
         // If guard pauses, note it but continue (reasoning is advisory)
         if (guardVerdict.status === "PAUSE") {

package/dist/engine/governedSimulation.js

@@ -17,6 +17,7 @@ exports.TRADING_DEMO = void 0;
 exports.runGovernedComparison = runGovernedComparison;
 const swarmSimulation_1 = require("./swarmSimulation");
 const worldBridge_1 = require("./worldBridge");
+const narrativeInjection_1 = require("./narrativeInjection");
 // ============================================
 // GOVERNED REACTION MODEL
 // ============================================
@@ -39,11 +40,11 @@ function applyGovernanceToReactions(reactions, invariants, gates, roundIndex, cu
         // Cap extreme negative impacts (e.g., "maintain liquidity floor")
         if (desc.includes("floor") || desc.includes("maintain") || desc.includes("minimum")) {
             for (const agent of governed) {
-                if (agent.impact < -0.6) {
+                if (agent.impact < -0.35) {
                     const original = agent.impact;
-                    agent.impact = Math.max(agent.impact, -0.5);
+                    agent.impact = Math.max(agent.impact, -0.3);
                     if (original !== agent.impact) {
-                        interventions.push(`[${inv.id}] Capped ${agent.stakeholder_id} negative impact: ${original.toFixed(2)} → ${agent.impact.toFixed(2)} (${inv.description})`);
+                        interventions.push(`[BLOCK] ${agent.stakeholder_id}: Liquidity floor violated — impact capped ${original.toFixed(2)} → ${agent.impact.toFixed(2)} (${inv.description})`);
                     }
                 }
             }
@@ -51,11 +52,11 @@ function applyGovernanceToReactions(reactions, invariants, gates, roundIndex, cu
         // Limit excessive positive speculation (e.g., "no leverage > 5x")
         if (desc.includes("leverage") || desc.includes("limit") || desc.includes("cap") || desc.includes("restrict")) {
             for (const agent of governed) {
-                if (agent.impact > 0.7) {
+                if (agent.impact > 0.45) {
                     const original = agent.impact;
-                    agent.impact = Math.min(agent.impact, 0.6);
+                    agent.impact = Math.min(agent.impact, 0.4);
                     if (original !== agent.impact) {
-                        interventions.push(`[${inv.id}] Capped ${agent.stakeholder_id} excessive position: ${original.toFixed(2)} → ${agent.impact.toFixed(2)} (${inv.description})`);
+                        interventions.push(`[BLOCK] ${agent.stakeholder_id}: Leverage limit exceeded — position capped ${original.toFixed(2)} → ${agent.impact.toFixed(2)} (${inv.description})`);
                     }
                 }
             }
@@ -65,10 +66,10 @@ function applyGovernanceToReactions(reactions, invariants, gates, roundIndex, cu
             // Pull extreme reactions toward the mean
             const avgImpact = governed.reduce((s, a) => s + a.impact, 0) / governed.length;
             for (const agent of governed) {
-                if (Math.abs(agent.impact - avgImpact) > 0.4) {
+                if (Math.abs(agent.impact - avgImpact) > 0.25) {
                     const original = agent.impact;
                     agent.impact = agent.impact * 0.7 + avgImpact * 0.3;
-                    interventions.push(`[${inv.id}] Rebalanced ${agent.stakeholder_id}: ${original.toFixed(2)} → ${agent.impact.toFixed(2)} (${inv.description})`);
+                    interventions.push(`[PAUSE] Rebalanced ${agent.stakeholder_id}: drift ${original.toFixed(2)} → ${agent.impact.toFixed(2)} (${inv.description})`);
                 }
             }
         }
@@ -92,7 +93,7 @@ function applyGovernanceToReactions(reactions, invariants, gates, roundIndex, cu
         if (gate.severity === "critical") {
             // Critical gates act as circuit breakers — compress all impacts toward zero
             const avgAbsImpact = governed.reduce((s, a) => s + Math.abs(a.impact), 0) / governed.length;
-            if (avgAbsImpact > 0.5 || cumulativeAvgImpact < -0.3) {
+            if (avgAbsImpact > 0.3 || cumulativeAvgImpact < -0.15) {
                 const dampingFactor = 0.6;
                 for (const agent of governed) {
                     const original = agent.impact;
@@ -131,13 +132,14 @@ function applyGovernanceToReactions(reactions, invariants, gates, roundIndex, cu
  * Same agents, same scenario, same reaction model —
  * but world rules reshape the outcomes.
  */
-async function runGovernedSwarmSimulation(scenario, stakeholders, paths, config, worldDef, nvWorld, request) {
+async function runGovernedSwarmSimulation(scenario, stakeholders, paths, config, worldDef, nvWorld, request, narrativeEvents) {
     // First run the unmodified simulation to get raw reactions
     const rawResult = await (0, swarmSimulation_1.runSwarmSimulation)(scenario, stakeholders, paths, config);
     // Now re-run applying governance to each round
     const governedRounds = [];
     const allInterventions = [];
     const allGuardVerdicts = [];
+    const allNarrativeImpacts = [];
     let cumulativeAvgImpact = 0;
     for (const round of rawResult.rounds) {
         // --- Real governance engine: evaluate each agent's action ---
@@ -159,6 +161,14 @@ async function runGovernedSwarmSimulation(scenario, stakeholders, paths, config,
                 }
             }
         }
+        // --- Narrative injection: information shocks ---
+        if (narrativeEvents && narrativeEvents.length > 0) {
+            const roundEvents = (0, narrativeInjection_1.getEventsForRound)(narrativeEvents, round.round);
+            for (const event of roundEvents) {
+                const impact = (0, narrativeInjection_1.injectNarrative)(round.reactions, event, stakeholders);
+                allNarrativeImpacts.push(impact);
+            }
+        }
         // --- Heuristic governance: invariant/gate enforcement (always applied) ---
         const { reactions: governedReactions, interventions } = applyGovernanceToReactions(round.reactions, worldDef.invariants, worldDef.gates ?? [], round.round, cumulativeAvgImpact);
         // Recompute emergent dynamics with governed reactions
@@ -184,6 +194,7 @@ async function runGovernedSwarmSimulation(scenario, stakeholders, paths, config,
         },
         allInterventions,
         guardVerdicts: allGuardVerdicts,
+        narrativeImpacts: allNarrativeImpacts,
     };
 }
 function detectGovernedDynamics(reactions, interventions) {
@@ -323,7 +334,7 @@ function buildComparisonNarrative(baseline, governed, worldThesis) {
  *   3. Compare metrics
  *   4. Generate narrative
  */
-async function runGovernedComparison(request, worldLite, paths) {
+async function runGovernedComparison(request, worldLite, paths, narrativeEvents) {
     const stakeholders = (request.stakeholders ?? []).map((s) => typeof s === "string" ? { id: s, disposition: "unknown" } : s);
     const swarmConfig = request.swarm ?? {
         enabled: true,
@@ -336,7 +347,7 @@ async function runGovernedComparison(request, worldLite, paths) {
     const baselineSwarm = await (0, swarmSimulation_1.runSwarmSimulation)(request.scenario, stakeholders, paths, swarmConfig);
     const baselineMetrics = computeMetrics(baselineSwarm);
     // Step 2: Governed — same scenario, world rules applied (real engine + heuristics)
-    const { swarm: governedSwarm, guardVerdicts } = await runGovernedSwarmSimulation(request.scenario, stakeholders, paths, swarmConfig, worldLite, nvWorld, request);
+    const { swarm: governedSwarm, guardVerdicts, narrativeImpacts: collectedNarrativeImpacts } = await runGovernedSwarmSimulation(request.scenario, stakeholders, paths, swarmConfig, worldLite, nvWorld, request, narrativeEvents);
     const governedMetrics = computeMetrics(governedSwarm);
     // Step 3: Build world simulation (deterministic state evolution via real engine)
     let worldSimulation;
@@ -417,6 +428,7 @@ async function runGovernedComparison(request, worldLite, paths) {
             narrative,
         },
         governanceStats,
+        narrativeImpacts: collectedNarrativeImpacts.length > 0 ? collectedNarrativeImpacts : undefined,
     };
 }
 // ============================================
@@ -478,6 +490,20 @@ exports.TRADING_DEMO = {
             { id: "GATE-002", label: "Contagion Warning", condition: "contagion_spread == systemic", severity: "critical" },
             { id: "GATE-003", label: "Leverage Warning", condition: "leverage_ratio > 8", severity: "warning" },
         ],
+        ai_roles: [
+            {
+                id: "ai_translator",
+                type: "ai",
+                permissions: ["translate_input"],
+                constraints: ["must_output_valid_schema", "no_invention_of_events", "confidence_must_be_provided"],
+            },
+            {
+                id: "ai_analyst",
+                type: "ai",
+                permissions: ["generate_report", "summarize_trace"],
+                constraints: ["must_reference_trace", "must_include_blocked_actions", "must_include_metrics", "no_unverifiable_claims"],
+            },
+        ],
     },
     paths: [
         {

package/dist/engine/index.js

@@ -21,7 +21,7 @@
  * Mirotir helps you decide WHAT TO DO → the brain
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseReasonRequestBody = exports.handleRunPreset = exports.handleGetPreset = exports.handleListPresets = exports.handleHealthCheck = exports.handleCreateCapsule = exports.handleReasonFromCapsule = exports.handleReasonRequest = exports.TRADING_DEMO = exports.runGovernedComparison = exports.analyzeMiroFishSimulation = exports.DEFAULT_MIROFISH_CONFIG = exports.buildMiroFishRequest = exports.miroFishResultToSwarmResult = exports.stakeholdersToMiroFishAgents = exports.runUnifiedSimulation = exports.getMiroFishClient = exports.configureMiroFish = exports.MiroFishError = exports.MiroFishClient = exports.runSwarmSimulation = exports.initNeuroverseModule = exports.validationToEnforcedConstraints = exports.simulationToGovernanceSignals = exports.verdictToConstitutionalChecks = exports.validateScenarioWorld = exports.runWorldSimulation = exports.evaluateScenarioGuard = exports.buildWorldFromScenario = exports.runFullGovernanceChecks = exports.runGovernanceChecks = exports.processReasonRequest = exports.SCENARIO_TEMPLATES = exports.getPresetCapsule = exports.extractCapsuleFromUrl = exports.buildShareableUrl = exports.decodeCapsule = exports.encodeCapsule = exports.capsuleToReasonRequest = exports.createCapsule = exports.runGoalReasoning = void 0;
+exports.extractTrace = exports.generateGovernedReport = exports.evaluateAIAction = exports.listAIProviders = exports.getAIProvider = exports.registerAIProvider = exports.generateDeterministicReport = exports.DeterministicProvider = exports.AI_ROLES = exports.parseReasonRequestBody = exports.handleRunPreset = exports.handleGetPreset = exports.handleListPresets = exports.handleHealthCheck = exports.handleCreateCapsule = exports.handleReasonFromCapsule = exports.handleReasonRequest = exports.TRADING_DEMO = exports.runGovernedComparison = exports.analyzeMiroFishSimulation = exports.DEFAULT_MIROFISH_CONFIG = exports.buildMiroFishRequest = exports.miroFishResultToSwarmResult = exports.stakeholdersToMiroFishAgents = exports.runUnifiedSimulation = exports.getMiroFishClient = exports.configureMiroFish = exports.MiroFishError = exports.MiroFishClient = exports.runSwarmSimulation = exports.initNeuroverseModule = exports.validationToEnforcedConstraints = exports.simulationToGovernanceSignals = exports.verdictToConstitutionalChecks = exports.validateScenarioWorld = exports.runWorldSimulation = exports.evaluateScenarioGuard = exports.buildWorldFromScenario = exports.runFullGovernanceChecks = exports.runGovernanceChecks = exports.processReasonRequest = exports.SCENARIO_TEMPLATES = exports.getPresetCapsule = exports.extractCapsuleFromUrl = exports.buildShareableUrl = exports.decodeCapsule = exports.encodeCapsule = exports.capsuleToReasonRequest = exports.createCapsule = exports.runGoalReasoning = void 0;
 // Goal-Directed Strategy Engine
 var goalEngine_1 = require("./goalEngine");
 Object.defineProperty(exports, "runGoalReasoning", { enumerable: true, get: function () { return goalEngine_1.runGoalReasoning; } });
@@ -80,3 +80,18 @@ Object.defineProperty(exports, "handleListPresets", { enumerable: true, get: fun
 Object.defineProperty(exports, "handleGetPreset", { enumerable: true, get: function () { return api_1.handleGetPreset; } });
 Object.defineProperty(exports, "handleRunPreset", { enumerable: true, get: function () { return api_1.handleRunPreset; } });
 Object.defineProperty(exports, "parseReasonRequestBody", { enumerable: true, get: function () { return api_1.parseReasonRequestBody; } });
+var aiProvider_1 = require("./aiProvider");
+Object.defineProperty(exports, "AI_ROLES", { enumerable: true, get: function () { return aiProvider_1.AI_ROLES; } });
+Object.defineProperty(exports, "DeterministicProvider", { enumerable: true, get: function () { return aiProvider_1.DeterministicProvider; } });
+Object.defineProperty(exports, "generateDeterministicReport", { enumerable: true, get: function () { return aiProvider_1.generateDeterministicReport; } });
+Object.defineProperty(exports, "registerAIProvider", { enumerable: true, get: function () { return aiProvider_1.registerAIProvider; } });
+Object.defineProperty(exports, "getAIProvider", { enumerable: true, get: function () { return aiProvider_1.getAIProvider; } });
+Object.defineProperty(exports, "listAIProviders", { enumerable: true, get: function () { return aiProvider_1.listAIProviders; } });
+Object.defineProperty(exports, "evaluateAIAction", { enumerable: true, get: function () { return aiProvider_1.evaluateAIAction; } });
+var reportEngine_1 = require("./reportEngine");
+Object.defineProperty(exports, "generateGovernedReport", { enumerable: true, get: function () { return reportEngine_1.generateGovernedReport; } });
+Object.defineProperty(exports, "extractTrace", { enumerable: true, get: function () { return reportEngine_1.extractTrace; } });
+// Live Simulation Adapters — plug ANY running simulator into governance + trace
+// NOTE: liveAdapter.ts uses Node.js APIs (child_process, events) and is NOT
+// exported here to avoid Vite browser bundle errors. Import directly from
+// "./liveAdapter" in CLI/server code only.

package/dist/engine/liveAdapter.js

@@ -0,0 +1,342 @@
+"use strict";
+/**
+ * Live Simulation Adapter
+ *
+ * Connects ANY running simulator into the NV-SIM governance + trace pipeline.
+ * Instead of running our own swarm simulation, we ingest live events from an
+ * external simulator process, normalize them, and feed them through governance.
+ *
+ * Architecture:
+ *   External Simulator (running process / stream)
+ *       ↓ stdout / WebSocket / SSE
+ *   LiveSimulationAdapter (parse + normalize)
+ *       ↓ LiveSimulationRound
+ *   Governance Engine (evaluate guards)
+ *       ↓ verdicts
+ *   Trace UI (causality visualization)
+ *
+ * Supported adapter types:
+ *   - ProcessAdapter: spawn a child process, parse stdout
+ *   - StreamAdapter: connect to WebSocket/SSE endpoint (future)
+ *
+ * Every adapter emits the same LiveSimulationRound events, regardless of source.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADAPTER_REGISTRY = void 0;
+exports.createProcessAdapter = createProcessAdapter;
+exports.parseMiroFishLine = parseMiroFishLine;
+exports.parseGenericJsonLine = parseGenericJsonLine;
+exports.createAdapter = createAdapter;
+const child_process_1 = require("child_process");
+const events_1 = require("events");
+function createParserState() {
+    return {
+        currentRound: 0,
+        pendingActions: [],
+        pendingEvents: [],
+        pendingDynamics: [],
+        buffer: {},
+    };
+}
+/**
+ * Process adapter — spawns a child process and parses its stdout.
+ *
+ * Usage:
+ *   const adapter = createProcessAdapter({
+ *     type: "process",
+ *     label: "MiroFish (Live)",
+ *     command: "node",
+ *     args: ["mirofish.js"],
+ *     parser: parseMiroFishLine,
+ *   });
+ *   adapter.on("round", (round) => { ... });
+ *   await adapter.start();
+ */
+function createProcessAdapter(config) {
+    const emitter = new events_1.EventEmitter();
+    let proc = null;
+    let _status = "idle";
+    const state = createParserState();
+    function setStatus(s) {
+        _status = s;
+        emitter.emit("status", s);
+    }
+    Object.defineProperties(emitter, {
+        status: { get: () => _status },
+        source: { get: () => config.type },
+        label: { get: () => config.label },
+    });
+    emitter.start = async function start() {
+        setStatus("connecting");
+        proc = (0, child_process_1.spawn)(config.command, config.args, {
+            cwd: config.cwd,
+            env: { ...process.env, ...config.env },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let lineBuffer = "";
+        proc.stdout?.on("data", (chunk) => {
+            lineBuffer += chunk.toString();
+            const lines = lineBuffer.split("\n");
+            // Keep incomplete last line in buffer
+            lineBuffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const round = config.parser(trimmed, state);
+                    if (round) {
+                        emitter.emit("round", round);
+                    }
+                }
+                catch (err) {
+                    // Parser error — log but don't crash
+                    emitter.emit("error", new Error(`Parser error: ${err}`));
+                }
+            }
+            if (_status === "connecting") {
+                setStatus("streaming");
+            }
+        });
+        proc.stderr?.on("data", (chunk) => {
+            // stderr is informational — don't treat as error
+            const msg = chunk.toString().trim();
+            if (msg) {
+                emitter.emit("log", msg);
+            }
+        });
+        proc.on("close", (code) => {
+            // Flush any remaining buffer
+            if (lineBuffer.trim()) {
+                try {
+                    const round = config.parser(lineBuffer.trim(), state);
+                    if (round)
+                        emitter.emit("round", round);
+                }
+                catch { /* ignore */ }
+            }
+            if (code === 0) {
+                setStatus("completed");
+                emitter.emit("complete");
+            }
+            else {
+                setStatus("error");
+                emitter.emit("error", new Error(`Process exited with code ${code}`));
+            }
+            proc = null;
+        });
+        proc.on("error", (err) => {
+            setStatus("error");
+            emitter.emit("error", err);
+            proc = null;
+        });
+    };
+    emitter.stop = async function stop() {
+        if (proc) {
+            proc.kill("SIGTERM");
+            // Give it 3s to exit gracefully, then force
+            setTimeout(() => {
+                if (proc)
+                    proc.kill("SIGKILL");
+            }, 3000);
+        }
+        setStatus("idle");
+    };
+    return emitter;
+}
+// ============================================
+// MIROFISH STDOUT PARSER
+// ============================================
+/**
+ * Parses MiroFish stdout line-by-line.
+ *
+ * Expected MiroFish output formats:
+ *
+ * JSON-per-line (preferred):
+ *   {"step":1,"agent_actions":[{"agent_id":"a1","action":"buy","sentiment":0.5,"confidence":0.8}]}
+ *
+ * Key-value (fallback):
+ *   [step 1] agent=swarm_1 action=panic_sell sentiment=-0.7 confidence=0.6
+ *   [step 1] event=market_crash severity=major
+ *   [step 1] emergent=herd_behavior
+ *   [step 2] ...
+ *
+ * We emit a LiveSimulationRound when we detect a new step number
+ * (meaning the previous step is complete).
+ */
+function parseMiroFishLine(line, state) {
+    // Try JSON first
+    if (line.startsWith("{")) {
+        try {
+            const data = JSON.parse(line);
+            if (data.step != null && Array.isArray(data.agent_actions)) {
+                // Parse adaptation data if present
+                let adaptation;
+                if (data.adaptation) {
+                    const a = data.adaptation;
+                    adaptation = {
+                        count: a.count ?? 0,
+                        rate: a.rate ?? 0,
+                        deltas: (a.deltas ?? []).map((d) => ({
+                            agent: d.agent ?? "unknown",
+                            intended: d.intended ?? "",
+                            actual: d.actual ?? "",
+                            decision: d.decision ?? "BLOCK",
+                            rule: d.rule,
+                            reason: d.reason,
+                            shift: d.shift ?? "unknown",
+                        })),
+                        intendedDistribution: a.intended_distribution ?? {},
+                        actualDistribution: a.actual_distribution ?? {},
+                        clusterPatterns: (a.cluster_patterns ?? []).map((c) => ({
+                            type: c.type ?? "unknown",
+                            strength: c.strength ?? 0,
+                            agents: c.agents ?? 0,
+                        })),
+                        narrative: a.narrative ?? "",
+                    };
+                }
+                // Complete step as JSON — emit immediately
+                return {
+                    round: data.step,
+                    source: "mirofish",
+                    agentActions: data.agent_actions.map((a) => ({
+                        agent: a.agent_id ?? a.agent ?? "unknown",
+                        action: a.action ?? "",
+                        impact: a.sentiment ?? a.impact ?? 0,
+                        confidence: a.confidence ?? 0.5,
+                        ...(a.verdict ? { verdict: { status: a.verdict.status, rule: a.verdict.rule, reason: a.verdict.reason } } : {}),
+                    })),
+                    systemEvents: (data.system_events ?? []).map((e) => typeof e === "string"
+                        ? { id: e, label: e }
+                        : { id: e.id ?? e.event ?? "unknown", label: e.label ?? e.event ?? e.id ?? "", severity: e.severity }),
+                    emergentDynamics: data.emergent_patterns ?? data.emergent ?? [],
+                    adaptation,
+                };
+            }
+        }
+        catch { /* not JSON, fall through to key-value parsing */ }
+    }
+    // Key-value format: [step N] key=value ...
+    const stepMatch = line.match(/\[step\s+(\d+)\]/i);
+    if (!stepMatch)
+        return null;
+    const stepNum = parseInt(stepMatch[1], 10);
+    let result = null;
+    // If new step, flush previous
+    if (stepNum > state.currentRound && state.currentRound > 0) {
+        result = {
+            round: state.currentRound,
+            source: "mirofish",
+            agentActions: [...state.pendingActions],
+            systemEvents: state.pendingEvents.length > 0 ? [...state.pendingEvents] : undefined,
+            emergentDynamics: state.pendingDynamics.length > 0 ? [...state.pendingDynamics] : undefined,
+        };
+        state.pendingActions = [];
+        state.pendingEvents = [];
+        state.pendingDynamics = [];
+    }
+    state.currentRound = stepNum;
+    const rest = line.slice(stepMatch.index + stepMatch[0].length).trim();
+    // Parse agent action
+    const agentMatch = rest.match(/agent=(\S+)\s+action=(\S+)(?:\s+sentiment=([-\d.]+))?(?:\s+confidence=([-\d.]+))?/);
+    if (agentMatch) {
+        state.pendingActions.push({
+            agent: agentMatch[1],
+            action: agentMatch[2],
+            impact: agentMatch[3] ? parseFloat(agentMatch[3]) : 0,
+            confidence: agentMatch[4] ? parseFloat(agentMatch[4]) : 0.5,
+        });
+        return result;
+    }
+    // Parse system event
+    const eventMatch = rest.match(/event=(\S+)(?:\s+severity=(\S+))?/);
+    if (eventMatch) {
+        state.pendingEvents.push({
+            id: eventMatch[1],
+            label: eventMatch[1].replace(/_/g, " "),
+            severity: eventMatch[2],
+        });
+        return result;
+    }
+    // Parse emergent behavior
+    const emergentMatch = rest.match(/emergent=(.+)/);
+    if (emergentMatch) {
+        state.pendingDynamics.push(emergentMatch[1].trim());
+        return result;
+    }
+    return result;
+}
+// ============================================
+// GENERIC JSON PARSER (works for any JSON-per-line simulator)
+// ============================================
+/**
+ * Generic JSON-per-line parser.
+ * Expects each line to be a JSON object with at minimum:
+ *   { "step": N, "agents": [{ "id": "...", "action": "...", "impact": 0.5 }] }
+ */
+function parseGenericJsonLine(line, _state) {
+    if (!line.startsWith("{"))
+        return null;
+    try {
+        const data = JSON.parse(line);
+        const step = data.step ?? data.tick ?? data.round ?? data.time;
+        if (step == null)
+            return null;
+        const agents = (data.agents ?? data.agent_actions ?? []).map((a) => ({
+            agent: a.id ?? a.agent ?? a.agent_id ?? "unknown",
+            action: a.action ?? a.behavior ?? "",
+            impact: a.impact ?? a.sentiment ?? a.value ?? 0,
+            confidence: a.confidence ?? 0.5,
+        }));
+        return {
+            round: typeof step === "number" ? step : parseInt(step, 10),
+            source: "generic",
+            agentActions: agents,
+            systemEvents: (data.events ?? []).map((e) => typeof e === "string"
+                ? { id: e, label: e }
+                : { id: e.id ?? "unknown", label: e.label ?? e.id ?? "", severity: e.severity }),
+            emergentDynamics: data.dynamics ?? data.emergent ?? [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+exports.ADAPTER_REGISTRY = {
+    mirofish: {
+        id: "mirofish",
+        label: "MiroFish (Live)",
+        description: "Spawn MiroFish swarm simulation and stream agent behavior",
+        createConfig: (opts = {}) => ({
+            type: "process",
+            label: "MiroFish (Live)",
+            command: opts.command ?? "node",
+            args: (opts.args ?? "mirofish.js").split(" "),
+            cwd: opts.cwd,
+            parser: parseMiroFishLine,
+        }),
+    },
+    generic: {
+        id: "generic",
+        label: "Generic JSON Process",
+        description: "Spawn any process that outputs JSON-per-line simulation data",
+        createConfig: (opts = {}) => ({
+            type: "process",
+            label: opts.label ?? "External Simulator",
+            command: opts.command ?? "python",
+            args: (opts.args ?? "sim.py").split(" "),
+            cwd: opts.cwd,
+            parser: parseGenericJsonLine,
+        }),
+    },
+};
+/**
+ * Create an adapter from the registry.
+ */
+function createAdapter(adapterId, options) {
+    const entry = exports.ADAPTER_REGISTRY[adapterId];
+    if (!entry)
+        return null;
+    return createProcessAdapter(entry.createConfig(options));
+}