@neuroverseos/governance 0.3.1 → 0.3.3

package/dist/chunk-BNKJPUPQ.js

@@ -0,0 +1,113 @@
+import {
+  GovernanceBlockedError,
+  buildEngineOptions,
+  extractScope,
+  trackPlanProgress
+} from "./chunk-5U2MQO5P.js";
+import {
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
+import {
+  loadWorld
+} from "./chunk-CTZHONLA.js";
+
+// src/adapters/openclaw.ts
+var GovernanceBlockedError2 = class extends GovernanceBlockedError {
+  action;
+  constructor(verdict, action) {
+    super(verdict);
+    this.action = action;
+  }
+};
+function defaultMapAction(action, direction) {
+  return {
+    intent: action.type,
+    tool: action.tool ?? action.type,
+    args: action.input,
+    direction,
+    scope: action.input ? extractScope(action.input) : void 0
+  };
+}
+var NeuroVersePlugin = class {
+  name = "neuroverse-governance";
+  world;
+  options;
+  engineOptions;
+  mapAction;
+  activePlan;
+  constructor(world, options = {}) {
+    this.world = world;
+    this.options = options;
+    this.activePlan = options.plan;
+    this.engineOptions = buildEngineOptions(options, this.activePlan);
+    this.mapAction = options.mapAction ?? defaultMapAction;
+  }
+  /**
+   * Evaluate an action before execution.
+   *
+   * @throws GovernanceBlockedError if BLOCKED
+   * @returns HookResult with verdict details
+   */
+  beforeAction(action) {
+    const event = this.mapAction(action, "input");
+    this.engineOptions.plan = this.activePlan;
+    const verdict = evaluateGuard(event, this.world, this.engineOptions);
+    const result = {
+      allowed: verdict.status === "ALLOW",
+      verdict,
+      action
+    };
+    this.options.onEvaluate?.(result);
+    if (verdict.status === "BLOCK") {
+      throw new GovernanceBlockedError2(verdict, action);
+    }
+    if (verdict.status === "ALLOW") {
+      trackPlanProgress(event, this, this.options);
+    }
+    return result;
+  }
+  /**
+   * Evaluate an action's output (post-execution governance).
+   * Only runs if evaluateOutputs is enabled.
+   *
+   * @returns HookResult or null if output evaluation is disabled
+   */
+  afterAction(action, _output) {
+    if (!this.options.evaluateOutputs) return null;
+    const event = this.mapAction(action, "output");
+    const verdict = evaluateGuard(event, this.world, this.engineOptions);
+    const result = {
+      allowed: verdict.status === "ALLOW",
+      verdict,
+      action
+    };
+    this.options.onEvaluate?.(result);
+    if (verdict.status === "BLOCK") {
+      throw new GovernanceBlockedError2(verdict, action);
+    }
+    return result;
+  }
+  /**
+   * Get the plugin hooks object for agent.use().
+   */
+  hooks() {
+    return {
+      beforeAction: (action) => this.beforeAction(action),
+      afterAction: (action, output) => this.afterAction(action, output)
+    };
+  }
+};
+async function createNeuroVersePlugin(worldPath, options) {
+  const world = await loadWorld(worldPath);
+  return new NeuroVersePlugin(world, options);
+}
+function createNeuroVersePluginFromWorld(world, options) {
+  return new NeuroVersePlugin(world, options);
+}
+
+export {
+  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-CTZHONLA.js

@@ -0,0 +1,135 @@
+// src/loader/world-loader.ts
+async function loadWorldFromDirectory(dirPath) {
+  const { readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const { readdirSync } = await import("fs");
+  async function readJson(filename) {
+    const filePath = join(dirPath, filename);
+    try {
+      const content = await readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } 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;
+    }
+  }
+  const worldJson = await readJson("world.json");
+  if (!worldJson) {
+    throw new Error(`Cannot read world.json in ${dirPath}`);
+  }
+  const invariantsJson = await readJson("invariants.json");
+  const assumptionsJson = await readJson("assumptions.json");
+  const stateSchemaJson = await readJson("state-schema.json");
+  const gatesJson = await readJson("gates.json");
+  const outcomesJson = await readJson("outcomes.json");
+  const guardsJson = await readJson("guards.json");
+  const rolesJson = await readJson("roles.json");
+  const kernelJson = await readJson("kernel.json");
+  const metadataJson = await readJson("metadata.json");
+  const rules = [];
+  try {
+    const rulesDir = join(dirPath, "rules");
+    const ruleFiles = readdirSync(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    for (const file of ruleFiles) {
+      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)}
+`
+      );
+    }
+  }
+  return {
+    world: worldJson,
+    invariants: invariantsJson?.invariants ?? [],
+    assumptions: assumptionsJson ?? { profiles: {}, parameter_definitions: {} },
+    stateSchema: stateSchemaJson ?? { variables: {}, presets: {} },
+    rules,
+    gates: gatesJson ?? {
+      viability_classification: [],
+      structural_override: { description: "", enforcement: "mandatory" },
+      sustainability_threshold: 0,
+      collapse_visual: { background: "", text: "", border: "", label: "" }
+    },
+    outcomes: outcomesJson ?? {
+      computed_outcomes: [],
+      comparison_layout: { primary_card: "", status_badge: "", structural_indicators: [] }
+    },
+    guards: guardsJson,
+    roles: rolesJson,
+    kernel: kernelJson,
+    metadata: metadataJson ?? {
+      format_version: "1.0.0",
+      created_at: "",
+      last_modified: "",
+      authoring_method: "manual-authoring"
+    }
+  };
+}
+async function loadWorld(worldPath) {
+  const { stat } = await import("fs/promises");
+  const info = await stat(worldPath);
+  if (info.isDirectory()) {
+    return loadWorldFromDirectory(worldPath);
+  }
+  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(
+    `Bundled world "${name}" not found. Searched:
+` + candidates.map((c) => `  ${c}`).join("\n")
+  );
+}
+
+export {
+  loadWorldFromDirectory,
+  loadWorld,
+  DEFAULT_BUNDLED_WORLD,
+  loadBundledWorld
+};