@neuroverseos/governance 0.3.0 → 0.3.3

package/dist/{chunk-2PQU3VAN.js → chunk-BNKJPUPQ.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/openclaw.ts
-var GovernanceBlockedError = class extends Error {
-  verdict;
+var GovernanceBlockedError2 = class extends GovernanceBlockedError {
   action;
   constructor(verdict, action) {
-    super(`[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
-    this.name = "GovernanceBlockedError";
-    this.verdict = verdict;
+    super(verdict);
     this.action = action;
   }
 };
@@ -27,7 +25,7 @@ function defaultMapAction(action, direction) {
     tool: action.tool ?? action.type,
     args: action.input,
     direction,
-    scope: typeof action.input?.path === "string" ? action.input.path : typeof action.input?.url === "string" ? action.input.url : void 0
+    scope: action.input ? extractScope(action.input) : void 0
   };
 }
 var NeuroVersePlugin = class {
@@ -41,11 +39,7 @@ var NeuroVersePlugin = 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.mapAction = options.mapAction ?? defaultMapAction;
   }
   /**
@@ -65,22 +59,10 @@ var NeuroVersePlugin = class {
     };
     this.options.onEvaluate?.(result);
     if (verdict.status === "BLOCK") {
-      throw new GovernanceBlockedError(verdict, action);
+      throw new GovernanceBlockedError2(verdict, action);
     }
-    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 result;
   }
@@ -101,7 +83,7 @@ var NeuroVersePlugin = class {
     };
     this.options.onEvaluate?.(result);
     if (verdict.status === "BLOCK") {
-      throw new GovernanceBlockedError(verdict, action);
+      throw new GovernanceBlockedError2(verdict, action);
     }
     return result;
   }
@@ -124,7 +106,7 @@ function createNeuroVersePluginFromWorld(world, options) {
 }
 
 export {
-  GovernanceBlockedError,
+  GovernanceBlockedError2 as GovernanceBlockedError,
   NeuroVersePlugin,
   createNeuroVersePlugin,
   createNeuroVersePluginFromWorld

package/dist/chunk-BQZMOEML.js

@@ -0,0 +1,43 @@
+// src/cli/cli-utils.ts
+async function resolveWorldPath(input) {
+  const { stat } = await import("fs/promises");
+  try {
+    const info = await stat(input);
+    if (info.isDirectory()) return input;
+  } catch {
+  }
+  const neuroversePath = `.neuroverse/worlds/${input}`;
+  try {
+    const info = await stat(neuroversePath);
+    if (info.isDirectory()) return neuroversePath;
+  } catch {
+  }
+  throw new Error(
+    `World not found: "${input}"
+Tried:
+  ${input}
+  ${neuroversePath}
+
+Build a world first: neuroverse build <input.md>`
+  );
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function parseCliValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  const num = Number(raw);
+  if (!isNaN(num) && raw.trim() !== "") return num;
+  return raw;
+}
+
+export {
+  resolveWorldPath,
+  readStdin,
+  parseCliValue
+};

package/dist/chunk-CNSO6XW5.js

@@ -0,0 +1,207 @@
+// src/engine/behavioral-engine.ts
+var ACTION_CATEGORY_MAP = {
+  // Amplifying
+  share: "amplifying",
+  post: "amplifying",
+  create_post: "amplifying",
+  retweet: "amplifying",
+  quote_tweet: "amplifying",
+  broadcast: "amplifying",
+  publish: "amplifying",
+  // Passive
+  scroll: "passive",
+  idle: "passive",
+  observe: "passive",
+  like: "passive",
+  // Engaging
+  reply: "engaging",
+  comment: "engaging",
+  discuss: "engaging",
+  // Corrective
+  report: "corrective",
+  fact_check: "corrective",
+  flag: "corrective",
+  debunk: "corrective",
+  // Transactional
+  buy: "transactional",
+  sell: "transactional",
+  trade: "transactional",
+  short: "transactional",
+  // Creative
+  generate: "creative",
+  compose: "creative",
+  draft: "creative",
+  write: "creative",
+  // Analytical
+  analyze: "analytical",
+  research: "analytical",
+  investigate: "analytical",
+  review: "analytical"
+};
+var SHIFT_LABELS = {
+  "amplifying\u2192passive": "amplification_suppressed",
+  "amplifying\u2192corrective": "redirected_to_reporting",
+  "amplifying\u2192engaging": "shifted_to_engagement",
+  "amplifying\u2192analytical": "redirected_to_analysis",
+  "transactional\u2192passive": "trading_halted",
+  "transactional\u2192analytical": "redirected_to_analysis",
+  "creative\u2192passive": "creation_blocked",
+  "creative\u2192analytical": "redirected_to_research",
+  "engaging\u2192passive": "engagement_dampened",
+  "passive\u2192passive": "unchanged"
+};
+function categorizeAction(action) {
+  return ACTION_CATEGORY_MAP[action] ?? "unknown";
+}
+function classifyAdaptation(intendedAction, executedAction) {
+  if (intendedAction === executedAction) return "unchanged";
+  const intendedCat = categorizeAction(intendedAction);
+  const executedCat = categorizeAction(executedAction);
+  if (intendedCat === executedCat) return "unchanged";
+  const key = `${intendedCat}\u2192${executedCat}`;
+  return SHIFT_LABELS[key] ?? `${intendedAction}_to_${executedAction}`;
+}
+function adaptationFromVerdict(agentId, intendedAction, executedAction, verdict) {
+  return {
+    agentId,
+    intendedAction,
+    executedAction,
+    shiftType: classifyAdaptation(intendedAction, executedAction),
+    verdict: verdict.status,
+    ruleId: verdict.ruleId,
+    reason: verdict.reason
+  };
+}
+function detectBehavioralPatterns(adaptations, totalAgents) {
+  const patterns = [];
+  if (adaptations.length === 0) return patterns;
+  const n = Math.max(totalAgents, 1);
+  const shiftCounts = {};
+  for (const a of adaptations) {
+    shiftCounts[a.shiftType] = (shiftCounts[a.shiftType] ?? 0) + 1;
+  }
+  const verdictCounts = {};
+  for (const a of adaptations) {
+    verdictCounts[a.verdict] = (verdictCounts[a.verdict] ?? 0) + 1;
+  }
+  const suppressed = shiftCounts["amplification_suppressed"] ?? 0;
+  const dampened = shiftCounts["engagement_dampened"] ?? 0;
+  const silenced = suppressed + dampened;
+  if (silenced >= 3) {
+    patterns.push({
+      type: "coordinated_silence",
+      description: `${silenced} agents blocked from amplifying \u2014 network went quiet`,
+      strength: round(silenced / n),
+      agentsAffected: silenced
+    });
+  }
+  if (suppressed >= 2) {
+    patterns.push({
+      type: "misinfo_suppression",
+      description: `${suppressed} amplification attempts blocked before reaching the feed`,
+      strength: round(suppressed / n),
+      agentsAffected: suppressed
+    });
+  }
+  const redirected = (shiftCounts["redirected_to_reporting"] ?? 0) + (shiftCounts["redirected_to_analysis"] ?? 0);
+  if (redirected >= 1) {
+    patterns.push({
+      type: "constructive_redirect",
+      description: `${redirected} agents redirected from amplification to reporting or analysis`,
+      strength: round(redirected / n),
+      agentsAffected: redirected
+    });
+  }
+  const tradingHalted = shiftCounts["trading_halted"] ?? 0;
+  if (tradingHalted >= 2) {
+    patterns.push({
+      type: "trading_halt",
+      description: `${tradingHalted} trading agents stopped \u2014 positions frozen`,
+      strength: round(tradingHalted / n),
+      agentsAffected: tradingHalted
+    });
+  }
+  const adaptRate = adaptations.length / n;
+  if (adaptRate > 0.3) {
+    patterns.push({
+      type: "high_governance_impact",
+      description: `${adaptations.length}/${n} agents (${Math.round(adaptRate * 100)}%) had their behavior shaped by governance`,
+      strength: round(adaptRate),
+      agentsAffected: adaptations.length
+    });
+  }
+  const penalized = verdictCounts["PENALIZE"] ?? 0;
+  if (penalized >= 3) {
+    patterns.push({
+      type: "penalty_wave",
+      description: `${penalized} agents penalized \u2014 behavioral costs applied`,
+      strength: round(penalized / n),
+      agentsAffected: penalized
+    });
+  }
+  const rewarded = verdictCounts["REWARD"] ?? 0;
+  if (rewarded >= 3) {
+    patterns.push({
+      type: "reward_cascade",
+      description: `${rewarded} agents rewarded \u2014 constructive behavior amplified`,
+      strength: round(rewarded / n),
+      agentsAffected: rewarded
+    });
+  }
+  return patterns;
+}
+function generateAdaptationNarrative(patterns, context) {
+  if (patterns.length === 0) return "";
+  const parts = [];
+  const patternTypes = new Set(patterns.map((p) => p.type));
+  if (patternTypes.has("misinfo_suppression")) {
+    const p = patterns.find((p2) => p2.type === "misinfo_suppression");
+    parts.push(`Blocked ${p.agentsAffected} misinformation amplification attempts`);
+  }
+  if (patternTypes.has("coordinated_silence")) {
+    const p = patterns.find((p2) => p2.type === "coordinated_silence");
+    parts.push(`${p.agentsAffected} agents went silent instead of amplifying`);
+  }
+  if (patternTypes.has("constructive_redirect")) {
+    const p = patterns.find((p2) => p2.type === "constructive_redirect");
+    parts.push(`${p.agentsAffected} shifted from sharing to fact-checking`);
+  }
+  if (patternTypes.has("trading_halt")) {
+    const p = patterns.find((p2) => p2.type === "trading_halt");
+    parts.push(`${p.agentsAffected} trading agents halted`);
+  }
+  if (patternTypes.has("penalty_wave")) {
+    const p = patterns.find((p2) => p2.type === "penalty_wave");
+    parts.push(`${p.agentsAffected} agents received behavioral penalties`);
+  }
+  if (patternTypes.has("reward_cascade")) {
+    const p = patterns.find((p2) => p2.type === "reward_cascade");
+    parts.push(`${p.agentsAffected} agents rewarded for constructive behavior`);
+  }
+  if (patternTypes.has("high_governance_impact")) {
+    const p = patterns.find((p2) => p2.type === "high_governance_impact");
+    parts.push(`${Math.round(p.strength * 100)}% of agents had behavior shaped by governance`);
+  }
+  if (context) {
+    const contextParts = [];
+    if (context.mood) contextParts.push(`mood: ${context.mood}`);
+    if (context.misinfoLevel !== void 0) {
+      contextParts.push(`misinfo level: ${Math.round(context.misinfoLevel * 100)}%`);
+    }
+    if (contextParts.length > 0) {
+      parts.push(`Network ${contextParts.join(", ")}`);
+    }
+  }
+  return parts.join(". ") + (parts.length > 0 ? "." : "");
+}
+function round(n, decimals = 3) {
+  const factor = Math.pow(10, decimals);
+  return Math.round(n * factor) / factor;
+}
+
+export {
+  classifyAdaptation,
+  adaptationFromVerdict,
+  detectBehavioralPatterns,
+  generateAdaptationNarrative
+};

package/dist/{chunk-JZPQGIKR.js → chunk-CTZHONLA.js}

@@ -4,10 +4,18 @@ async function loadWorldFromDirectory(dirPath) {
   const { join } = await import("path");
   const { readdirSync } = await import("fs");
   async function readJson(filename) {
+    const filePath = join(dirPath, filename);
     try {
-      const content = await readFile(join(dirPath, filename), "utf-8");
+      const content = await readFile(filePath, "utf-8");
       return JSON.parse(content);
-    } catch {
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+        return void 0;
+      }
+      process.stderr.write(
+        `[neuroverse] Warning: Failed to read ${filename}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
       return void 0;
     }
   }
@@ -29,10 +37,23 @@ async function loadWorldFromDirectory(dirPath) {
     const rulesDir = join(dirPath, "rules");
     const ruleFiles = readdirSync(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
-      const content = await readFile(join(rulesDir, file), "utf-8");
-      rules.push(JSON.parse(content));
+      try {
+        const content = await readFile(join(rulesDir, file), "utf-8");
+        rules.push(JSON.parse(content));
+      } catch (err) {
+        process.stderr.write(
+          `[neuroverse] Warning: Failed to parse rule ${file}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+  } catch (err) {
+    if (!(err instanceof Error && "code" in err && err.code === "ENOENT")) {
+      process.stderr.write(
+        `[neuroverse] Warning: Failed to read rules directory: ${err instanceof Error ? err.message : String(err)}
+`
+      );
     }
-  } catch {
   }
   return {
     world: worldJson,
@@ -67,13 +88,48 @@ async function loadWorld(worldPath) {
   if (info.isDirectory()) {
     return loadWorldFromDirectory(worldPath);
   }
-  if (worldPath.endsWith(".nv-world.zip")) {
-    throw new Error(".nv-world.zip loading not yet implemented \u2014 use a world directory");
+  throw new Error(`Cannot load world from: ${worldPath} \u2014 expected a directory`);
+}
+var DEFAULT_BUNDLED_WORLD = "coding-agent";
+async function loadBundledWorld(name = DEFAULT_BUNDLED_WORLD) {
+  const { readFile } = await import("fs/promises");
+  const { join, dirname } = await import("path");
+  const { existsSync } = await import("fs");
+  const { fileURLToPath } = await import("url");
+  const { parseWorldMarkdown } = await import("./bootstrap-parser-EEF36XDU.js");
+  const { emitWorldDefinition } = await import("./bootstrap-emitter-Q7UIJZ2O.js");
+  const filename = `${name}.nv-world.md`;
+  let packageRoot;
+  try {
+    const thisFile = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
+    packageRoot = join(thisFile, "..", "..");
+  } catch {
+    packageRoot = process.cwd();
+  }
+  const candidates = [
+    join(packageRoot, "dist", "worlds", filename),
+    join(packageRoot, "src", "worlds", filename)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      const markdown = await readFile(candidate, "utf-8");
+      const parsed = parseWorldMarkdown(markdown);
+      if (!parsed.world) {
+        throw new Error(`Failed to parse bundled world: ${candidate}`);
+      }
+      const { world } = emitWorldDefinition(parsed.world);
+      return world;
+    }
   }
-  throw new Error(`Cannot load world from: ${worldPath} \u2014 expected a directory or .nv-world.zip`);
+  throw new Error(
+    `Bundled world "${name}" not found. Searched:
+` + candidates.map((c) => `  ${c}`).join("\n")
+  );
 }
 
 export {
   loadWorldFromDirectory,
-  loadWorld
+  loadWorld,
+  DEFAULT_BUNDLED_WORLD,
+  loadBundledWorld
 };