@neuroverseos/nv-sim 0.1.9 → 0.1.10

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/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-CdghpsS8.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B43_0HyO.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",

package/dist/lib/swarmParser.js

@@ -54,7 +54,7 @@ function seededRandom(seed) {
  * Parse simulation output into a SwarmResult.
  *
  * Uses the universal simulation adapter to normalize input from
- * MiroFish, NetLogo, Mesa, AnyLogic/CSV, generic JSON, or freeform text,
+ * Agent Swarm, NetLogo, Mesa, AnyLogic/CSV, generic JSON, or freeform text,
  * then generates structured reasoning overlay from the normalized data.
  *
  * Returns both the SwarmResult (for UI) and the detected format.

package/dist/runtime/govern.js

@@ -79,22 +79,78 @@ function createGovernor(config) {
         blocked: 0,
         modified: 0,
         paused: 0,
+        rewarded: 0,
+        penalized: 0,
         rulesFired: 0,
     };
+    // Per-agent behavior states for incentive tracking
+    const agentStates = new Map();
+    function getOrCreateAgentState(agentId) {
+        if (!agentStates.has(agentId)) {
+            agentStates.set(agentId, {
+                agentId,
+                cooldownRemaining: 0,
+                influence: 1.0,
+                rewardMultiplier: 1.0,
+                totalPenalties: 0,
+                totalRewards: 0,
+            });
+        }
+        return agentStates.get(agentId);
+    }
     function evaluate(action, worldState) {
         stats.totalEvaluations++;
+        const agentState = getOrCreateAgentState(action.agentId);
+        // ── Cooldown check: frozen agents are auto-penalized ──
+        if (agentState.cooldownRemaining > 0) {
+            agentState.cooldownRemaining--;
+            stats.penalized++;
+            return {
+                status: "PENALIZE",
+                action: null,
+                reason: `Agent frozen: ${agentState.cooldownRemaining + 1} round(s) remaining on cooldown`,
+                rulesFired: [],
+                confidence: 1,
+                timestamp: Date.now(),
+                consequence: { type: "cooldown", rounds: agentState.cooldownRemaining + 1, description: "Agent still in cooldown period" },
+            };
+        }
         const rulesFired = [];
         let currentMagnitude = action.magnitude;
         let wasModified = false;
+        let penalizeRule = null;
+        let rewardRule = null;
         // --- Evaluate action against each invariant ---
         for (const inv of world.invariants) {
             if (!inv.enforceable) {
-                // Advisory: log but don't block
+                // Check for reward patterns — advisory rules that match positively
+                if (matchesRewardPattern(inv.description, action)) {
+                    rewardRule = { inv, reward: { type: "boost_influence", magnitude: 0.1, description: inv.description } };
+                    rulesFired.push({
+                        id: inv.id,
+                        description: inv.description,
+                        effect: "rewarded",
+                        impactReduction: 0,
+                    });
+                }
+                else {
+                    rulesFired.push({
+                        id: inv.id,
+                        description: inv.description,
+                        effect: "monitored",
+                        impactReduction: 0,
+                    });
+                }
+                continue;
+            }
+            // Check for penalize patterns before standard evaluation
+            if (matchesPenalizePattern(inv.description, action)) {
+                penalizeRule = { inv, consequence: { type: "freeze", rounds: 1, magnitude: 0.5, description: inv.description } };
                 rulesFired.push({
                     id: inv.id,
                     description: inv.description,
-                    effect: "monitored",
-                    impactReduction: 0,
+                    effect: "penalized",
+                    impactReduction: 1,
                 });
                 continue;
             }
@@ -114,6 +170,58 @@ function createGovernor(config) {
                 wasModified = true;
             }
         }
+        // ── PENALIZE verdict ──
+        if (penalizeRule) {
+            stats.penalized++;
+            stats.rulesFired++;
+            const consequence = penalizeRule.consequence;
+            agentState.totalPenalties++;
+            agentState.cooldownRemaining = consequence.rounds ?? 1;
+            agentState.influence = Math.max(0, agentState.influence - (consequence.magnitude ?? 0.2));
+            const verdict = {
+                status: "PENALIZE",
+                action: null,
+                reason: buildReason("penalized", action, rulesFired),
+                rulesFired,
+                confidence: computeConfidence(rulesFired, 1),
+                timestamp: Date.now(),
+                consequence,
+            };
+            if (audit) {
+                audit.logVerdict({
+                    agent: action.agentId, action: action.description, actionType: action.type,
+                    verdict: "BLOCK", reason: verdict.reason, confidence: verdict.confidence,
+                    rulesFired: rulesFired.map((r) => ({ id: r.id, description: r.description, effect: r.effect, impactReduction: r.impactReduction })),
+                });
+            }
+            return verdict;
+        }
+        // ── REWARD verdict (only when no rules blocked/modified the action) ──
+        if (rewardRule && !wasModified) {
+            stats.rewarded++;
+            stats.rulesFired++;
+            const reward = rewardRule.reward;
+            agentState.totalRewards++;
+            agentState.influence = Math.min(2.0, agentState.influence + (reward.magnitude ?? 0.1));
+            agentState.rewardMultiplier = Math.min(3.0, agentState.rewardMultiplier + 0.05);
+            const verdict = {
+                status: "REWARD",
+                action: action,
+                reason: buildReason("rewarded", action, rulesFired),
+                rulesFired,
+                confidence: computeConfidence(rulesFired, 0),
+                timestamp: Date.now(),
+                reward,
+            };
+            if (audit) {
+                audit.logVerdict({
+                    agent: action.agentId, action: action.description, actionType: action.type,
+                    verdict: "ALLOW", reason: verdict.reason, confidence: verdict.confidence,
+                    rulesFired: rulesFired.map((r) => ({ id: r.id, description: r.description, effect: r.effect, impactReduction: r.impactReduction })),
+                });
+            }
+            return verdict;
+        }
         // --- Determine final verdict ---
         stats.rulesFired += rulesFired.filter((r) => r.effect !== "monitored").length;
         const totalReduction = 1 - (currentMagnitude / Math.max(action.magnitude, 0.001));
@@ -121,28 +229,24 @@ function createGovernor(config) {
         let reason;
         let outputAction;
         if (totalReduction > 0.85) {
-            // Action is essentially killed
             status = "BLOCK";
             reason = buildReason("blocked", action, rulesFired);
             outputAction = null;
             stats.blocked++;
         }
         else if (totalReduction > 0.5) {
-            // Action is significantly reduced — pause for review
             status = "PAUSE";
             reason = buildReason("paused", action, rulesFired);
             outputAction = { ...action, magnitude: Number(currentMagnitude.toFixed(3)) };
             stats.paused++;
         }
         else if (wasModified && totalReduction > 0.05) {
-            // Action was modified but still largely allowed
             status = "MODIFY";
             reason = buildReason("modified", action, rulesFired);
             outputAction = { ...action, magnitude: Number(currentMagnitude.toFixed(3)) };
             stats.modified++;
         }
         else {
-            // Clean pass
             status = "ALLOW";
             reason = rulesFired.length > 0
                 ? `Allowed — ${rulesFired.filter((r) => r.effect === "monitored").length} advisory rule(s) noted`
@@ -185,10 +289,22 @@ function createGovernor(config) {
         health = (0, policyEngine_1.validatePolicy)(parsed);
         world = (0, policyEngine_1.policyToWorld)(parsed);
     }
+    /** Decrement cooldowns for all tracked agents — call once per round */
+    function tickCooldowns() {
+        for (const [, state] of agentStates) {
+            state.cooldownRemaining = Math.max(0, state.cooldownRemaining - 1);
+        }
+    }
+    /** Get all agent behavior states */
+    function getAgentStates() {
+        return agentStates;
+    }
     return {
         evaluate,
         evaluateBatch,
         updatePolicy,
+        tickCooldowns,
+        getAgentStates,
         get policy() {
             return {
                 ruleCount: parsed.summary.total,
@@ -384,7 +500,44 @@ function buildReason(type, action, rulesFired) {
             return `Paused by "${primary.description}"${others} — action "${action.description}" requires review`;
         case "modified":
             return `Modified by "${primary.description}"${others} — magnitude reduced from ${action.magnitude.toFixed(2)} to stay within policy limits`;
+        case "penalized":
+            return `Penalized by "${primary.description}"${others} — agent "${action.agentId}" frozen for violating governance`;
+        case "rewarded":
+            return `Rewarded by "${primary.description}"${others} — agent "${action.agentId}" demonstrated compliant behavior`;
+    }
+}
+// ============================================
+// INCENTIVE PATTERN MATCHING
+// ============================================
+/**
+ * Detects penalize patterns in rule descriptions.
+ * Rules that say "penalize", "freeze", "suspend", "cooldown" for matching actions.
+ */
+function matchesPenalizePattern(ruleDesc, action) {
+    const desc = ruleDesc.toLowerCase();
+    const actionDesc = action.description.toLowerCase();
+    const actionType = action.type.toLowerCase();
+    // Must have penalize/freeze/suspend keyword
+    if (!matchesPattern(desc, ["penalize", "freeze", "suspend", "cooldown", "punish", "sanction"])) {
+        return false;
+    }
+    // Extract what should be penalized
+    const actionTerms = extractActionTerms(desc, ["penalize", "freeze", "suspend", "cooldown", "punish", "sanction"]);
+    return actionTerms.some((term) => actionDesc.includes(term) || actionType.includes(term));
+}
+/**
+ * Detects reward patterns in rule descriptions.
+ * Rules that say "reward", "boost", "incentivize", "encourage" for matching actions.
+ */
+function matchesRewardPattern(ruleDesc, action) {
+    const desc = ruleDesc.toLowerCase();
+    const actionDesc = action.description.toLowerCase();
+    const actionType = action.type.toLowerCase();
+    if (!matchesPattern(desc, ["reward", "boost", "incentivize", "encourage", "promote", "prioritize"])) {
+        return false;
     }
+    const actionTerms = extractActionTerms(desc, ["reward", "boost", "incentivize", "encourage", "promote", "prioritize"]);
+    return actionTerms.some((term) => actionDesc.includes(term) || actionType.includes(term));
 }
 function capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);

package/dist/runtime/index.js

@@ -38,7 +38,7 @@
  *   const decision = await radiant.compareOptions(options)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMiroFishWrapper = exports.generateDemoInvestigation = exports.createScienceClawAdapter = exports.interpretScienceState = exports.SCIENCE_INITIAL_STATE = exports.SCIENCE_POLICY_TEXT = exports.SCIENCE_METRICS = exports.PRIME_RADIANT_PRESETS = exports.createPrimeRadiant = exports.DEFAULT_METRICS = exports.runScenarioMatrix = exports.runFullGovernedSimulation = exports.createDynamicsGovernor = exports.governDynamics = exports.EXAMPLE_WORLD_STATES = exports.EXAMPLE_ACTIONS = exports.createGovernor = exports.govern = void 0;
+exports.generateDemoInvestigation = exports.createScienceClawAdapter = exports.interpretScienceState = exports.SCIENCE_INITIAL_STATE = exports.SCIENCE_POLICY_TEXT = exports.SCIENCE_METRICS = exports.PRIME_RADIANT_PRESETS = exports.createPrimeRadiant = exports.DEFAULT_METRICS = exports.runScenarioMatrix = exports.runFullGovernedSimulation = exports.createDynamicsGovernor = exports.governDynamics = exports.EXAMPLE_WORLD_STATES = exports.EXAMPLE_ACTIONS = exports.createGovernor = exports.govern = void 0;
 // Core runtime — Layer A: action governance
 var govern_1 = require("./govern");
 Object.defineProperty(exports, "govern", { enumerable: true, get: function () { return govern_1.govern; } });
@@ -70,6 +70,3 @@ Object.defineProperty(exports, "interpretScienceState", { enumerable: true, get:
 var scienceclaw_1 = require("../adapters/scienceclaw");
 Object.defineProperty(exports, "createScienceClawAdapter", { enumerable: true, get: function () { return scienceclaw_1.createScienceClawAdapter; } });
 Object.defineProperty(exports, "generateDemoInvestigation", { enumerable: true, get: function () { return scienceclaw_1.generateDemoInvestigation; } });
-// MiroFish adapter — governance wrapper for external simulators
-var mirofish_1 = require("../adapters/mirofish");
-Object.defineProperty(exports, "createMiroFishWrapper", { enumerable: true, get: function () { return mirofish_1.createMiroFishWrapper; } });

package/dist/runtime/types.js

@@ -9,3 +9,94 @@
  *   import { type AgentAction, type GovernanceVerdict } from "@neuroverseos/runtime"
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateGovernableEvent = validateGovernableEvent;
+exports.validateGovernableCycle = validateGovernableCycle;
+exports.normalizeActionType = normalizeActionType;
+/**
+ * Maps a raw JSON object to an NVGovernableEvent, or returns the reason it can't.
+ * This is the universal validation gate — used by all adapters.
+ */
+function validateGovernableEvent(raw, source) {
+    const cycle = raw.cycle ?? raw.step ?? raw.round;
+    if (cycle == null)
+        return "missing_cycle";
+    const agentId = raw.agent_id ?? raw.agentId ?? raw.id ?? raw.agent;
+    if (!agentId || typeof agentId !== "string")
+        return "missing_agent";
+    const actionType = raw.type ?? raw.action ?? raw.action_type ?? raw.actionType;
+    if (!actionType || typeof actionType !== "string")
+        return "missing_action_type";
+    return {
+        schema: 1,
+        source,
+        cycle: typeof cycle === "number" ? cycle : parseInt(cycle, 10),
+        agentId: agentId,
+        actionType: normalizeActionType(actionType),
+        description: raw.description ?? `${actionType} action`,
+        confidence: typeof raw.confidence === "number" ? raw.confidence : 0.5,
+        magnitude: typeof raw.magnitude === "number" ? raw.magnitude : 0.5,
+        reproduced: raw.reproduced === true,
+        references: typeof raw.citations === "number" ? raw.citations
+            : typeof raw.references === "number" ? raw.references : 0,
+        metadata: raw.metadata,
+    };
+}
+/**
+ * Validates a cycle-level JSON object containing multiple events.
+ * Returns an NVGovernableCycle or the reason the cycle itself is ungovernable.
+ */
+function validateGovernableCycle(raw, source) {
+    const cycle = raw.cycle ?? raw.step ?? raw.round;
+    if (cycle == null)
+        return "missing_cycle";
+    const rawEvents = raw.artifacts ?? raw.agents ?? raw.agent_actions ?? raw.events;
+    if (!Array.isArray(rawEvents))
+        return "missing_action_type";
+    const events = [];
+    for (const item of rawEvents) {
+        if (typeof item !== "object" || item == null)
+            continue;
+        const withCycle = { ...item, cycle };
+        const result = validateGovernableEvent(withCycle, source);
+        if (typeof result !== "string") {
+            events.push(result);
+        }
+    }
+    return {
+        schema: 1,
+        source,
+        cycle: typeof cycle === "number" ? cycle : parseInt(cycle, 10),
+        events,
+        systemSignals: raw.system_state,
+    };
+}
+/** Normalize free-form action types to the governed vocabulary. */
+function normalizeActionType(raw) {
+    const lower = raw.toLowerCase();
+    const map = {
+        hypothesis: "hypothesis",
+        experiment: "experiment",
+        analysis: "analysis",
+        publication: "publication",
+        publish: "publication",
+        paper: "publication",
+        replication: "replication",
+        replicate: "replication",
+        review: "review",
+        trade: "trade",
+        buy: "trade",
+        sell: "trade",
+        decision: "decision",
+        communicate: "communication",
+        communication: "communication",
+        post: "communication",
+        message: "communication",
+        withdrawal: "withdrawal",
+        withdraw: "withdrawal",
+        vote: "vote",
+        coalition: "coalition",
+        dataset: "analysis",
+        model: "analysis",
+    };
+    return map[lower] ?? "custom";
+}