@neuroverseos/nv-sim 0.1.9 → 0.1.11

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuroverseos/nv-sim",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "license": "Apache-2.0",
   "description": "CLI for running governed vs baseline agent simulations to explore how world rules shape emergent system behavior.",
@@ -8,25 +8,41 @@
     "type": "git",
     "url": "https://github.com/NeuroverseOS/neuroverse-simulations"
   },
+  "keywords": [
+    "agent-incentives",
+    "governance",
+    "ai-agents",
+    "simulation",
+    "multi-agent",
+    "neuroverse",
+    "policy-enforcement",
+    "reward-penalize",
+    "agent-behavior",
+    "emergent-systems"
+  ],
   "homepage": "https://github.com/NeuroverseOS/neuroverse-simulations",
   "bugs": {
     "url": "https://github.com/NeuroverseOS/neuroverse-simulations/issues"
   },
   "bin": {
-    "nv-sim": "dist/engine/cli.js"
+    "nv-sim": "dist/engine/cli.js",
+    "nv-scienceclaw-post": "dist/connectors/nv-scienceclaw-post.js"
   },
   "files": [
     "dist",
+    "connectors",
     "variants",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
     "dev": "vite",
-    "build": "vite build && tsc -p tsconfig.cli.json && echo '{\"type\":\"commonjs\"}' > dist/package.json && chmod +x dist/engine/cli.js",
-    "build:cli": "tsc -p tsconfig.cli.json && echo '{\"type\":\"commonjs\"}' > dist/package.json && chmod +x dist/engine/cli.js",
+    "build": "vite build && tsc -p tsconfig.cli.json && echo '{\"type\":\"commonjs\"}' > dist/package.json && chmod +x dist/engine/cli.js && (test -f dist/connectors/nv-scienceclaw-post.js && chmod +x dist/connectors/nv-scienceclaw-post.js || true)",
+    "build:cli": "tsc -p tsconfig.cli.json && echo '{\"type\":\"commonjs\"}' > dist/package.json && chmod +x dist/engine/cli.js && (test -f dist/connectors/nv-scienceclaw-post.js && chmod +x dist/connectors/nv-scienceclaw-post.js || true)",
     "build:dev": "vite build --mode development",
-    "build:all": "vite build && tsc -p tsconfig.cli.json && echo '{\"type\":\"commonjs\"}' > dist/package.json && chmod +x dist/engine/cli.js",
+    "build:all": "vite build && tsc -p tsconfig.cli.json && echo '{\"type\":\"commonjs\"}' > dist/package.json && chmod +x dist/engine/cli.js && (test -f dist/connectors/nv-scienceclaw-post.js && chmod +x dist/connectors/nv-scienceclaw-post.js || true)",
+    "server": "tsx src/server/index.ts",
+    "dev:full": "tsx src/server/index.ts & vite",
     "lint": "eslint .",
     "preview": "vite preview",
     "test": "vitest run",
@@ -38,7 +54,7 @@
   },
   "dependencies": {
     "@hookform/resolvers": "^3.10.0",
-    "@neuroverseos/governance": "^0.3.0",
+    "@neuroverseos/governance": "^0.2.3",
     "@radix-ui/react-accordion": "^1.2.11",
     "@radix-ui/react-alert-dialog": "^1.1.14",
     "@radix-ui/react-aspect-ratio": "^1.1.7",
@@ -109,6 +125,7 @@
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.38.0",
     "vite": "^5.4.19",
+    "tsx": "^4.21.0",
     "vitest": "^3.2.4"
   }
 }