@neuroverseos/governance 0.3.0 → 0.3.3

package/dist/{build-P42YFKQV.js → build-QKOBBC23.js}

@@ -2,17 +2,19 @@ import {
   DeriveInputError,
   DeriveProviderError,
   deriveWorld
-} from "./chunk-NF5POFCI.js";
+} from "./chunk-6S5CFQXY.js";
 import {
   DERIVE_EXIT_CODES
 } from "./chunk-Q6O7ZLO2.js";
 import "./chunk-OT6PXH54.js";
+import "./chunk-7P3S7MAY.js";
 import {
-  emitWorldDefinition,
   parseWorldMarkdown
-} from "./chunk-XPDMYECO.js";
-import "./chunk-7P3S7MAY.js";
-import "./chunk-YZFATT7X.js";
+} from "./chunk-EMQDLDAF.js";
+import {
+  emitWorldDefinition
+} from "./chunk-PVTQQS3Y.js";
+import "./chunk-QWGCMQQD.js";
 
 // src/cli/build.ts
 var FINDING_LABELS = {

package/dist/{chunk-COT5XS4V.js → chunk-3WQLXYTP.js}

@@ -1,23 +1,21 @@
 import {
-  evaluateGuard
-} from "./chunk-4JRYGIO7.js";
+  GovernanceBlockedError,
+  buildEngineOptions,
+  extractScope,
+  trackPlanProgress
+} from "./chunk-5U2MQO5P.js";
 import {
-  advancePlan,
-  evaluatePlan,
-  getPlanProgress
-} from "./chunk-4QXB6PEO.js";
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
 import {
   loadWorld
-} from "./chunk-JZPQGIKR.js";
+} from "./chunk-CTZHONLA.js";
 
 // src/adapters/langchain.ts
-var GovernanceBlockedError = class extends Error {
-  verdict;
+var GovernanceBlockedError2 = class extends GovernanceBlockedError {
   event;
   constructor(verdict, event) {
-    super(`[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
-    this.name = "GovernanceBlockedError";
-    this.verdict = verdict;
+    super(verdict);
     this.event = event;
   }
 };
@@ -25,7 +23,7 @@ function defaultMapToolCall(toolName, toolInput) {
   return {
     intent: toolName,
     tool: toolName,
-    scope: typeof toolInput.path === "string" ? toolInput.path : typeof toolInput.url === "string" ? toolInput.url : void 0,
+    scope: extractScope(toolInput),
     args: toolInput,
     direction: "input"
   };
@@ -41,11 +39,7 @@ var NeuroVerseCallbackHandler = class {
     this.world = world;
     this.options = options;
     this.activePlan = options.plan;
-    this.engineOptions = {
-      trace: options.trace ?? false,
-      level: options.level,
-      plan: this.activePlan
-    };
+    this.engineOptions = buildEngineOptions(options, this.activePlan);
     this.mapToolCall = options.mapToolCall ?? defaultMapToolCall;
   }
   /**
@@ -68,28 +62,16 @@ var NeuroVerseCallbackHandler = class {
     this.options.onEvaluate?.(verdict, event);
     if (verdict.status === "BLOCK") {
       this.options.onBlock?.(verdict, event);
-      throw new GovernanceBlockedError(verdict, event);
+      throw new GovernanceBlockedError2(verdict, event);
     }
     if (verdict.status === "PAUSE") {
       const approved = await this.options.onPause?.(verdict, event);
       if (!approved) {
-        throw new GovernanceBlockedError(verdict, event);
+        throw new GovernanceBlockedError2(verdict, event);
       }
     }
-    if (verdict.status === "ALLOW" && this.activePlan) {
-      const planVerdict = evaluatePlan(event, this.activePlan);
-      if (planVerdict.matchedStep) {
-        const advResult = advancePlan(this.activePlan, planVerdict.matchedStep);
-        if (advResult.success && advResult.plan) {
-          this.activePlan = advResult.plan;
-          this.engineOptions.plan = this.activePlan;
-        }
-        const progress = getPlanProgress(this.activePlan);
-        this.options.onPlanProgress?.(progress);
-        if (progress.completed === progress.total) {
-          this.options.onPlanComplete?.();
-        }
-      }
+    if (verdict.status === "ALLOW") {
+      trackPlanProgress(event, this, this.options);
     }
   }
 };
@@ -102,7 +84,7 @@ function createNeuroVerseCallbackHandlerFromWorld(world, options) {
 }
 
 export {
-  GovernanceBlockedError,
+  GovernanceBlockedError2 as GovernanceBlockedError,
   NeuroVerseCallbackHandler,
   createNeuroVerseCallbackHandler,
   createNeuroVerseCallbackHandlerFromWorld

package/dist/{chunk-ER62HNGF.js → chunk-4FLICVVA.js}

@@ -1,23 +1,22 @@
 import {
-  evaluateGuard
-} from "./chunk-4JRYGIO7.js";
+  GovernanceBlockedError,
+  buildEngineOptions,
+  defaultBlockMessage,
+  extractScope,
+  trackPlanProgress
+} from "./chunk-5U2MQO5P.js";
 import {
-  advancePlan,
-  evaluatePlan,
-  getPlanProgress
-} from "./chunk-4QXB6PEO.js";
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
 import {
   loadWorld
-} from "./chunk-JZPQGIKR.js";
+} from "./chunk-CTZHONLA.js";
 
 // src/adapters/openai.ts
-var GovernanceBlockedError = class extends Error {
-  verdict;
+var GovernanceBlockedError2 = class extends GovernanceBlockedError {
   toolCallId;
   constructor(verdict, toolCallId) {
-    super(`[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
-    this.name = "GovernanceBlockedError";
-    this.verdict = verdict;
+    super(verdict);
     this.toolCallId = toolCallId;
   }
 };
@@ -25,14 +24,11 @@ function defaultMapFunctionCall(name, args) {
   return {
     intent: name,
     tool: name,
-    scope: typeof args.path === "string" ? args.path : typeof args.url === "string" ? args.url : void 0,
+    scope: extractScope(args),
     args,
     direction: "input"
   };
 }
-function defaultBlockMessage(verdict) {
-  return `Action blocked by governance policy: ${verdict.reason ?? "rule violation"}. Rule: ${verdict.ruleId ?? "unknown"}.`;
-}
 var GovernedToolExecutor = class {
   world;
   options;
@@ -44,11 +40,7 @@ var GovernedToolExecutor = class {
     this.world = world;
     this.options = options;
     this.activePlan = options.plan;
-    this.engineOptions = {
-      trace: options.trace ?? false,
-      level: options.level,
-      plan: this.activePlan
-    };
+    this.engineOptions = buildEngineOptions(options, this.activePlan);
     this.mapFn = options.mapFunctionCall ?? defaultMapFunctionCall;
     this.blockMsg = options.blockMessage ?? defaultBlockMessage;
   }
@@ -67,20 +59,8 @@ var GovernedToolExecutor = class {
     this.engineOptions.plan = this.activePlan;
     const verdict = evaluateGuard(event, this.world, this.engineOptions);
     this.options.onEvaluate?.(verdict, event);
-    if (verdict.status === "ALLOW" && this.activePlan) {
-      const planVerdict = evaluatePlan(event, this.activePlan);
-      if (planVerdict.matchedStep) {
-        const advResult = advancePlan(this.activePlan, planVerdict.matchedStep);
-        if (advResult.success && advResult.plan) {
-          this.activePlan = advResult.plan;
-          this.engineOptions.plan = this.activePlan;
-        }
-        const progress = getPlanProgress(this.activePlan);
-        this.options.onPlanProgress?.(progress);
-        if (progress.completed === progress.total) {
-          this.options.onPlanComplete?.();
-        }
-      }
+    if (verdict.status === "ALLOW") {
+      trackPlanProgress(event, this, this.options);
     }
     return verdict;
   }
@@ -106,7 +86,7 @@ var GovernedToolExecutor = class {
       };
     }
     if (verdict.status === "PAUSE") {
-      throw new GovernanceBlockedError(verdict, toolCall.id);
+      throw new GovernanceBlockedError2(verdict, toolCall.id);
     }
     let args;
     try {
@@ -132,7 +112,7 @@ function createGovernedToolExecutorFromWorld(world, options) {
 }
 
 export {
-  GovernanceBlockedError,
+  GovernanceBlockedError2 as GovernanceBlockedError,
   GovernedToolExecutor,
   createGovernedToolExecutor,
   createGovernedToolExecutorFromWorld

package/dist/chunk-5TPFNWRU.js

@@ -0,0 +1,215 @@
+import {
+  validateWorld
+} from "./chunk-7P3S7MAY.js";
+
+// src/engine/add-engine.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "").slice(0, 60);
+}
+async function addGuard(worldDir, input) {
+  const { readFile, writeFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const guardsPath = join(worldDir, "guards.json");
+  let config;
+  try {
+    const raw = await readFile(guardsPath, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+    config = { guards: [], intent_vocabulary: {} };
+  }
+  const id = input.id ?? `guard_${slugify(input.label)}`;
+  if (config.guards.some((g) => g.id === id)) {
+    throw new Error(`Guard with id "${id}" already exists. Use a different label or provide --id.`);
+  }
+  const guard = {
+    id,
+    label: input.label,
+    description: input.description ?? input.label,
+    category: input.category ?? "operational",
+    enforcement: input.enforcement,
+    immutable: false,
+    intent_patterns: input.intentPatterns,
+    ...input.appliesTo && { appliesTo: input.appliesTo },
+    ...input.invariantRef && { invariant_ref: input.invariantRef },
+    ...input.enforcement === "modify" && input.reason && { modify_to: input.reason }
+  };
+  config.guards.push(guard);
+  await writeFile(guardsPath, JSON.stringify(config, null, 2) + "\n");
+  const { loadWorldFromDirectory } = await import("./world-loader-Y6HMQH2D.js");
+  const world = await loadWorldFromDirectory(worldDir);
+  const report = validateWorld(world);
+  return {
+    type: "guard",
+    id,
+    file: guardsPath,
+    valid: report.summary.isHealthy,
+    findings: report.findings,
+    construct: guard
+  };
+}
+async function addRule(worldDir, input) {
+  const { readFile, writeFile, mkdir } = await import("fs/promises");
+  const { join } = await import("path");
+  const { readdirSync } = await import("fs");
+  const rulesDir = join(worldDir, "rules");
+  await mkdir(rulesDir, { recursive: true });
+  let nextNum = 1;
+  try {
+    const existing = readdirSync(rulesDir).filter((f) => f.match(/^rule-\d+\.json$/)).sort();
+    if (existing.length > 0) {
+      const lastFile = existing[existing.length - 1];
+      const match = lastFile.match(/rule-(\d+)\.json/);
+      if (match) nextNum = parseInt(match[1], 10) + 1;
+    }
+  } catch {
+  }
+  const ruleNum = String(nextNum).padStart(3, "0");
+  const id = input.id ?? `rule_${slugify(input.label)}`;
+  const rule = {
+    id,
+    severity: input.severity,
+    label: input.label,
+    description: input.description ?? input.label,
+    order: nextNum,
+    triggers: input.triggers,
+    ...input.effects && { effects: input.effects },
+    ...input.collapseCheck && { collapse_check: input.collapseCheck },
+    causal_translation: input.causalTranslation ?? {
+      trigger_text: `Triggers when: ${input.triggers.map((t) => `${t.field} ${t.operator} ${t.value}`).join(" AND ")}`,
+      rule_text: input.label,
+      shift_text: input.description ?? input.label,
+      effect_text: input.effects ? input.effects.map((e) => `${e.target} ${e.operation} ${e.value}`).join(", ") : "No direct effects"
+    }
+  };
+  const rulePath = join(rulesDir, `rule-${ruleNum}.json`);
+  await writeFile(rulePath, JSON.stringify(rule, null, 2) + "\n");
+  const { loadWorldFromDirectory } = await import("./world-loader-Y6HMQH2D.js");
+  const world = await loadWorldFromDirectory(worldDir);
+  const report = validateWorld(world);
+  return {
+    type: "rule",
+    id,
+    file: rulePath,
+    valid: report.summary.isHealthy,
+    findings: report.findings,
+    construct: rule
+  };
+}
+async function addInvariant(worldDir, input) {
+  const { readFile, writeFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const invariantsPath = join(worldDir, "invariants.json");
+  let config;
+  try {
+    const raw = await readFile(invariantsPath, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+    config = { invariants: [] };
+  }
+  const id = input.id ?? slugify(input.label);
+  if (config.invariants.some((inv) => inv.id === id)) {
+    throw new Error(`Invariant with id "${id}" already exists.`);
+  }
+  const invariant = {
+    id,
+    label: input.label,
+    enforcement: input.enforcement ?? "structural",
+    mutable: false
+  };
+  config.invariants.push(invariant);
+  await writeFile(invariantsPath, JSON.stringify(config, null, 2) + "\n");
+  const { loadWorldFromDirectory } = await import("./world-loader-Y6HMQH2D.js");
+  const world = await loadWorldFromDirectory(worldDir);
+  const report = validateWorld(world);
+  return {
+    type: "invariant",
+    id,
+    file: invariantsPath,
+    valid: report.summary.isHealthy,
+    findings: report.findings,
+    construct: invariant
+  };
+}
+function classifyIntent(text) {
+  const lower = text.toLowerCase().trim();
+  const guardPatterns = [
+    /^block\b/,
+    /^prevent\b/,
+    /^deny\b/,
+    /^reject\b/,
+    /^disallow\b/,
+    /^forbid\b/,
+    /^stop\b/,
+    /^pause\b/,
+    /^warn\s+(when|if|on|before)\b/,
+    /^require\s+approval\b/,
+    /^flag\b/,
+    /^restrict\b/
+  ];
+  const invariantPatterns = [
+    /must\s+(always|never)\b/,
+    /must\s+not\b/,
+    /shall\s+(always|never)\b/,
+    /can\s*not\s+(ever|drop|exceed|go)\b/,
+    /cannot\s+(ever|drop|exceed|go)\b/,
+    /\bmust\s+remain\b/,
+    /\balways\s+be\b/,
+    /\bnever\s+(exceed|drop|go|fall|be)\b/,
+    /\bfloor\b.*\bmust\b/,
+    /\bcap\b.*\bmust\b/,
+    /\bhard\s+limit\b/,
+    /\bguarantee\b/
+  ];
+  const rulePatterns = [
+    /^if\b.*\bthen\b/,
+    /^when\b.*\b(reduce|increase|multiply|set|add|subtract)\b/,
+    /\b(reduce|increase|multiply|degrade|boost)\b.*\bby\b/,
+    /\b(viability|margin|score|trust|budget)\b.*\b(drop|rise|change|shift)/,
+    /\beffect\b/,
+    /\btrigger\b.*\bwhen\b/,
+    /\bcollapse\b.*\bif\b/
+  ];
+  const guardScore = guardPatterns.filter((p) => p.test(lower)).length;
+  const invariantScore = invariantPatterns.filter((p) => p.test(lower)).length;
+  const ruleScore = rulePatterns.filter((p) => p.test(lower)).length;
+  const max = Math.max(guardScore, invariantScore, ruleScore);
+  if (max === 0) return "ambiguous";
+  const scores = [guardScore, invariantScore, ruleScore];
+  const winners = scores.filter((s) => s === max);
+  if (winners.length > 1) return "ambiguous";
+  if (guardScore === max) return "guard";
+  if (invariantScore === max) return "invariant";
+  return "rule";
+}
+function parseGuardDescription(text) {
+  const lower = text.toLowerCase().trim();
+  let enforcement = "block";
+  if (/^pause\b|require\s+approval/i.test(lower)) enforcement = "pause";
+  else if (/^warn\b|^flag\b/i.test(lower)) enforcement = "warn";
+  else if (/^block\b|^prevent\b|^deny\b|^reject\b|^forbid\b|^disallow\b|^stop\b/i.test(lower)) enforcement = "block";
+  const stripped = text.replace(/^(block|prevent|deny|reject|forbid|disallow|stop|pause|warn|flag|restrict)\s+(if\s+|when\s+|on\s+|before\s+)?/i, "").trim();
+  const words = stripped.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  const patterns = [];
+  if (words.length > 0) {
+    patterns.push(`*${words.join("*")}*`);
+    if (words.length > 1) {
+      for (const word of words) {
+        patterns.push(`*${word}*`);
+      }
+    }
+  }
+  return {
+    label: text,
+    enforcement,
+    intentPatterns: patterns.length > 0 ? patterns : ["*"],
+    description: text
+  };
+}
+
+export {
+  addGuard,
+  addRule,
+  addInvariant,
+  classifyIntent,
+  parseGuardDescription
+};

package/dist/chunk-5U2MQO5P.js

@@ -0,0 +1,57 @@
+import {
+  advancePlan,
+  evaluatePlan,
+  getPlanProgress
+} from "./chunk-QLPTHTVB.js";
+
+// src/adapters/shared.ts
+var GovernanceBlockedError = class extends Error {
+  verdict;
+  constructor(verdict, message) {
+    super(message ?? `[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
+    this.name = "GovernanceBlockedError";
+    this.verdict = verdict;
+  }
+};
+function trackPlanProgress(event, state, callbacks) {
+  if (!state.activePlan) return;
+  const planVerdict = evaluatePlan(event, state.activePlan);
+  if (planVerdict.matchedStep) {
+    const advResult = advancePlan(state.activePlan, planVerdict.matchedStep);
+    if (advResult.success && advResult.plan) {
+      state.activePlan = advResult.plan;
+      state.engineOptions.plan = state.activePlan;
+    }
+    const progress = getPlanProgress(state.activePlan);
+    callbacks.onPlanProgress?.(progress);
+    if (progress.completed === progress.total) {
+      callbacks.onPlanComplete?.();
+    }
+  }
+}
+function extractScope(args) {
+  if (typeof args.path === "string") return args.path;
+  if (typeof args.file_path === "string") return args.file_path;
+  if (typeof args.filename === "string") return args.filename;
+  if (typeof args.url === "string") return args.url;
+  if (typeof args.command === "string") return args.command;
+  return void 0;
+}
+function buildEngineOptions(options, plan) {
+  return {
+    trace: options.trace ?? false,
+    level: options.level,
+    plan: plan ?? options.plan
+  };
+}
+function defaultBlockMessage(verdict) {
+  return `Action blocked by governance policy: ${verdict.reason ?? "rule violation"}. Rule: ${verdict.ruleId ?? "unknown"}.`;
+}
+
+export {
+  GovernanceBlockedError,
+  trackPlanProgress,
+  extractScope,
+  buildEngineOptions,
+  defaultBlockMessage
+};

package/dist/{chunk-NF5POFCI.js → chunk-6S5CFQXY.js}

@@ -4,13 +4,15 @@ import {
 import {
   loadConfig
 } from "./chunk-OT6PXH54.js";
-import {
-  emitWorldDefinition,
-  parseWorldMarkdown
-} from "./chunk-XPDMYECO.js";
 import {
   validateWorld
 } from "./chunk-7P3S7MAY.js";
+import {
+  parseWorldMarkdown
+} from "./chunk-EMQDLDAF.js";
+import {
+  emitWorldDefinition
+} from "./chunk-PVTQQS3Y.js";
 
 // src/engine/derive-normalizer.ts
 function findSections(lines) {

package/dist/{chunk-QPASI2BR.js → chunk-A7GKPPU7.js}

@@ -1,6 +1,6 @@
 import {
   evaluateGuard
-} from "./chunk-4JRYGIO7.js";
+} from "./chunk-W7LLXRGY.js";
 
 // src/engine/audit-logger.ts
 var FileAuditLogger = class {
@@ -38,12 +38,22 @@ var FileAuditLogger = class {
 };
 var ConsoleAuditLogger = class {
   log(event) {
-    const icon = event.decision === "ALLOW" ? "\u2713" : event.decision === "BLOCK" ? "\u2717" : "\u23F8";
+    const iconMap = {
+      "ALLOW": "\u25CF",
+      "BLOCK": "\u25CB",
+      "PAUSE": "\u25D1",
+      "MODIFY": "\u25D0",
+      "PENALIZE": "\u25CC",
+      "REWARD": "\u25C9",
+      "NEUTRAL": "\u25EF"
+    };
+    const icon = iconMap[event.decision] ?? "\xB7";
     const ts = event.timestamp.split("T")[1]?.replace("Z", "") ?? event.timestamp;
-    process.stderr.write(
-      `[${ts}] ${icon} ${event.decision.padEnd(5)} ${event.actor ?? "\u2014"} \u2192 ${event.intent}${event.reason ? ` (${event.reason})` : ""}
-`
-    );
+    let line = `[${ts}] ${icon} ${event.decision.padEnd(10)} ${event.actor ?? "\u2014"} \u2192 ${event.intent}`;
+    if (event.reason) line += ` (${event.reason})`;
+    if (event.consequence) line += ` [consequence: ${event.consequence.description}]`;
+    if (event.reward) line += ` [reward: ${event.reward.description}]`;
+    process.stderr.write(line + "\n");
   }
 };
 var CompositeAuditLogger = class {
@@ -66,7 +76,7 @@ var CompositeAuditLogger = class {
   }
 };
 function verdictToAuditEvent(event, verdict) {
-  return {
+  const auditEvent = {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     worldId: verdict.evidence.worldId,
     worldName: verdict.evidence.worldName,
@@ -88,6 +98,17 @@ function verdictToAuditEvent(event, verdict) {
     durationMs: verdict.trace?.durationMs,
     args: event.args
   };
+  if (verdict.consequence) {
+    auditEvent.consequence = verdict.consequence;
+  }
+  if (verdict.reward) {
+    auditEvent.reward = verdict.reward;
+  }
+  if (verdict.intentRecord) {
+    auditEvent.originalIntent = verdict.intentRecord.originalIntent;
+    auditEvent.finalAction = verdict.intentRecord.finalAction;
+  }
+  return auditEvent;
 }
 function createGovernanceEngine(world, options = {}) {
   const { auditLogger, auditArgs, ...engineOptions } = options;
@@ -140,16 +161,22 @@ function summarizeAuditEvents(events) {
   const allowed = events.filter((e) => e.decision === "ALLOW").length;
   const blocked = events.filter((e) => e.decision === "BLOCK").length;
   const paused = events.filter((e) => e.decision === "PAUSE").length;
+  const modified = events.filter((e) => e.decision === "MODIFY").length;
+  const penalized = events.filter((e) => e.decision === "PENALIZE").length;
+  const rewarded = events.filter((e) => e.decision === "REWARD").length;
+  const neutral = events.filter((e) => e.decision === "NEUTRAL").length;
   const actorSet = /* @__PURE__ */ new Set();
   for (const e of events) {
     if (e.actor) actorSet.add(e.actor);
   }
   const intentMap = /* @__PURE__ */ new Map();
   for (const e of events) {
-    const entry = intentMap.get(e.intent) ?? { count: 0, blocked: 0, paused: 0 };
+    const entry = intentMap.get(e.intent) ?? { count: 0, blocked: 0, paused: 0, penalized: 0, rewarded: 0 };
     entry.count++;
     if (e.decision === "BLOCK") entry.blocked++;
     if (e.decision === "PAUSE") entry.paused++;
+    if (e.decision === "PENALIZE") entry.penalized++;
+    if (e.decision === "REWARD") entry.rewarded++;
     intentMap.set(e.intent, entry);
   }
   const topIntents = [...intentMap.entries()].map(([intent, data]) => ({ intent, ...data })).sort((a, b) => b.count - a.count);
@@ -163,16 +190,28 @@ function summarizeAuditEvents(events) {
     }
   }
   const topRules = [...ruleMap.entries()].map(([ruleId, count]) => ({ ruleId, count })).sort((a, b) => b.count - a.count);
+  const redirected = blocked + paused + modified + penalized;
+  const total = events.length;
   return {
-    totalActions: events.length,
+    totalActions: total,
     allowed,
     blocked,
     paused,
+    modified,
+    penalized,
+    rewarded,
+    neutral,
     actors: [...actorSet],
     topIntents,
     topRules,
     firstEvent: events[0]?.timestamp ?? "",
-    lastEvent: events[events.length - 1]?.timestamp ?? ""
+    lastEvent: events[events.length - 1]?.timestamp ?? "",
+    behavioralEconomy: {
+      totalPenalties: penalized,
+      totalRewards: rewarded,
+      netPressure: rewarded - penalized,
+      redirectionRate: total > 0 ? redirected / total : 0
+    }
   };
 }
 

package/dist/{chunk-OGL7QXZS.js → chunk-B6OXJLJ5.js}

@@ -4,15 +4,15 @@ import {
 } from "./chunk-AKW5YVCE.js";
 import {
   evaluateGuard
-} from "./chunk-4JRYGIO7.js";
+} from "./chunk-W7LLXRGY.js";
 import {
   advancePlan,
   evaluatePlan,
   getPlanProgress
-} from "./chunk-4QXB6PEO.js";
+} from "./chunk-QLPTHTVB.js";
 import {
   loadWorld
-} from "./chunk-JZPQGIKR.js";
+} from "./chunk-CTZHONLA.js";
 
 // src/runtime/mcp-server.ts
 import { execSync } from "child_process";
@@ -200,9 +200,17 @@ var McpGovernanceServer = class {
 `);
     }
     let buffer = "";
+    const MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+    const MAX_CONTENT_LENGTH = 10 * 1024 * 1024;
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       buffer += chunk;
+      if (buffer.length > MAX_BUFFER_SIZE) {
+        process.stderr.write(`[neuroverse-mcp] Buffer exceeded ${MAX_BUFFER_SIZE} bytes, dropping.
+`);
+        buffer = "";
+        return;
+      }
       while (buffer.length > 0) {
         const headerEnd = buffer.indexOf("\r\n\r\n");
         if (headerEnd === -1) break;
@@ -217,6 +225,12 @@ var McpGovernanceServer = class {
           continue;
         }
         const contentLength = parseInt(contentLengthMatch[1], 10);
+        if (isNaN(contentLength) || contentLength < 0 || contentLength > MAX_CONTENT_LENGTH) {
+          process.stderr.write(`[neuroverse-mcp] Invalid Content-Length: ${contentLengthMatch[1]}, skipping.
+`);
+          buffer = "";
+          break;
+        }
         const bodyStart = headerEnd + 4;
         const bodyEnd = bodyStart + contentLength;
         if (buffer.length < bodyEnd) break;