@neuroverseos/governance 0.3.1 → 0.3.3

package/dist/doctor-6BC6X2VO.js

@@ -0,0 +1,173 @@
+import {
+  loadConfig
+} from "./chunk-OT6PXH54.js";
+import {
+  __glob
+} from "./chunk-QWGCMQQD.js";
+
+// import("../adapters/**/*") in src/cli/doctor.ts
+var globImport_adapters = __glob({
+  "../adapters/autoresearch.ts": () => import("./adapters/autoresearch.js"),
+  "../adapters/deep-agents.ts": () => import("./adapters/deep-agents.js"),
+  "../adapters/express.ts": () => import("./adapters/express.js"),
+  "../adapters/index.ts": () => import("./adapters/index.js"),
+  "../adapters/langchain.ts": () => import("./adapters/langchain.js"),
+  "../adapters/openai.ts": () => import("./adapters/openai.js"),
+  "../adapters/openclaw.ts": () => import("./adapters/openclaw.js"),
+  "../adapters/shared.ts": () => import("./shared-7RLUHNMU.js")
+});
+
+// src/cli/doctor.ts
+var PACKAGE_VERSION = "0.2.0";
+var MIN_NODE_VERSION = 18;
+async function main(argv) {
+  const json = argv.includes("--json");
+  let worldPath;
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--world" && i + 1 < argv.length) {
+      worldPath = argv[++i];
+    }
+  }
+  const checks = [];
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1), 10);
+  checks.push({
+    label: "Node version",
+    status: major >= MIN_NODE_VERSION ? "pass" : "fail",
+    value: nodeVersion,
+    detail: major < MIN_NODE_VERSION ? `Requires Node >= ${MIN_NODE_VERSION}` : void 0
+  });
+  checks.push({
+    label: "NeuroVerse version",
+    status: "pass",
+    value: PACKAGE_VERSION
+  });
+  try {
+    const config = await loadConfig();
+    if (config?.provider && config?.apiKey) {
+      checks.push({
+        label: "AI provider configured",
+        status: "pass",
+        value: `${config.provider}${config.model ? ` (${config.model})` : ""}`
+      });
+    } else {
+      checks.push({
+        label: "AI provider configured",
+        status: "warn",
+        value: "not configured",
+        detail: "Run: neuroverse configure-ai --provider openai --model gpt-4.1-mini --api-key <key>"
+      });
+    }
+  } catch {
+    checks.push({
+      label: "AI provider configured",
+      status: "warn",
+      value: "not configured",
+      detail: "Run: neuroverse configure-ai"
+    });
+  }
+  if (worldPath) {
+    try {
+      const { existsSync } = await import("fs");
+      const { join } = await import("path");
+      const hasWorld = existsSync(join(worldPath, "world.json"));
+      checks.push({
+        label: "World file detected",
+        status: hasWorld ? "pass" : "fail",
+        value: hasWorld ? worldPath : "not found",
+        detail: hasWorld ? void 0 : `No world.json found in ${worldPath}`
+      });
+    } catch {
+      checks.push({
+        label: "World file detected",
+        status: "fail",
+        value: "error reading path"
+      });
+    }
+  } else {
+    const { existsSync } = await import("fs");
+    const { join } = await import("path");
+    const candidates = ["./world", "./.neuroverse", "./worlds"];
+    let found;
+    for (const dir of candidates) {
+      if (existsSync(join(dir, "world.json"))) {
+        found = dir;
+        break;
+      }
+    }
+    checks.push({
+      label: "World file detected",
+      status: found ? "pass" : "warn",
+      value: found ?? "none found",
+      detail: found ? void 0 : "Build a world: neuroverse build <input.md>"
+    });
+  }
+  try {
+    const { evaluateGuard } = await import("./guard-engine-PNR6MHCM.js");
+    checks.push({
+      label: "Guard engine",
+      status: typeof evaluateGuard === "function" ? "pass" : "fail",
+      value: "loaded"
+    });
+  } catch {
+    checks.push({ label: "Guard engine", status: "fail", value: "failed to load" });
+  }
+  try {
+    const { validateWorld } = await import("./validate-engine-7ZXFVGF2.js");
+    checks.push({
+      label: "Validation engine",
+      status: typeof validateWorld === "function" ? "pass" : "fail",
+      value: "loaded"
+    });
+  } catch {
+    checks.push({ label: "Validation engine", status: "fail", value: "failed to load" });
+  }
+  const adapterNames = ["openai", "express", "langchain", "openclaw"];
+  const loadedAdapters = [];
+  for (const name of adapterNames) {
+    try {
+      await globImport_adapters(`../adapters/${name}`);
+      loadedAdapters.push(name);
+    } catch {
+    }
+  }
+  checks.push({
+    label: "Adapters",
+    status: loadedAdapters.length > 0 ? "pass" : "warn",
+    value: loadedAdapters.length > 0 ? loadedAdapters.join(", ") : "none"
+  });
+  if (json) {
+    const hasFailure2 = checks.some((c) => c.status === "fail");
+    process.stdout.write(JSON.stringify({
+      status: hasFailure2 ? "fail" : "pass",
+      checks
+    }, null, 2) + "\n");
+    process.exit(hasFailure2 ? 1 : 0);
+    return;
+  }
+  process.stderr.write("\nNeuroVerse Environment Check\n");
+  process.stderr.write("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+  const maxLabel = Math.max(...checks.map((c) => c.label.length));
+  for (const check of checks) {
+    const icon = check.status === "pass" ? "ok" : check.status === "warn" ? "!!" : "FAIL";
+    const pad = " ".repeat(maxLabel - check.label.length);
+    process.stderr.write(`  ${check.label}${pad}  ${icon}  ${check.value}
+`);
+    if (check.detail) {
+      process.stderr.write(`  ${" ".repeat(maxLabel)}      ${check.detail}
+`);
+    }
+  }
+  const hasFailure = checks.some((c) => c.status === "fail");
+  process.stderr.write("\n");
+  if (hasFailure) {
+    process.stderr.write("Some checks failed. Fix the issues above and re-run.\n");
+  } else {
+    process.stderr.write("System ready.\n");
+  }
+  process.stderr.write("\n");
+  process.exit(hasFailure ? 1 : 0);
+}
+export {
+  main
+};

package/dist/equity-penalties-SG5IZQ7I.js

@@ -0,0 +1,244 @@
+import {
+  verdictToAuditEvent
+} from "./chunk-A7GKPPU7.js";
+import {
+  applyConsequence,
+  applyReward,
+  createAgentState,
+  generateDecisionFlow,
+  renderDecisionFlow,
+  tickAgentStates
+} from "./chunk-D2UCV5AK.js";
+import {
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
+import "./chunk-QLPTHTVB.js";
+import {
+  loadWorld
+} from "./chunk-CTZHONLA.js";
+import "./chunk-QWGCMQQD.js";
+
+// src/cli/equity-penalties.ts
+var AGENTS = [
+  { id: "alpha", name: "Alpha Fund", strategy: "aggressive" },
+  { id: "beta", name: "Beta Holdings", strategy: "conservative" },
+  { id: "gamma", name: "Gamma Capital", strategy: "balanced" },
+  { id: "delta", name: "Delta Quant", strategy: "aggressive" },
+  { id: "epsilon", name: "Epsilon Value", strategy: "conservative" },
+  { id: "zeta", name: "Zeta Momentum", strategy: "aggressive" },
+  { id: "eta", name: "Eta Growth", strategy: "balanced" },
+  { id: "theta", name: "Theta Macro", strategy: "conservative" }
+];
+function generateActionsForRound(agents, round) {
+  const actions = [];
+  for (const agent of agents) {
+    if (agent.strategy === "aggressive") {
+      if (round % 2 === 0) {
+        actions.push({
+          intent: `sell Fortune 500 equity AAPL position for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      } else {
+        actions.push({
+          intent: `sell Fortune 500 equity MSFT shares for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      }
+    }
+    if (agent.strategy === "conservative") {
+      actions.push({
+        intent: `hold current position during market volatility for ${agent.name}`,
+        tool: "trade",
+        roleId: agent.id,
+        actionCategory: "read"
+      });
+    }
+    if (agent.strategy === "balanced") {
+      if (round % 3 === 0) {
+        actions.push({
+          intent: `sell Fortune 500 equity GOOGL for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      } else if (round % 3 === 1) {
+        actions.push({
+          intent: `buy non-F500 small cap equity for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      } else {
+        actions.push({
+          intent: `hold position during volatility for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "read"
+        });
+      }
+    }
+  }
+  return actions;
+}
+async function main(args) {
+  let worldPath = "";
+  let agentCount = 8;
+  let rounds = 5;
+  let jsonOutput = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--world" && args[i + 1]) {
+      worldPath = args[++i];
+    }
+    if (args[i] === "--agents" && args[i + 1]) {
+      agentCount = Math.min(parseInt(args[++i], 10), AGENTS.length);
+    }
+    if (args[i] === "--rounds" && args[i + 1]) {
+      rounds = parseInt(args[++i], 10);
+    }
+    if (args[i] === "--json") {
+      jsonOutput = true;
+    }
+    if (args[i] === "--help" || args[i] === "-h") {
+      process.stdout.write(`
+neuroverse equity-penalties \u2014 Behavioral enforcement simulation
+
+Usage:
+  neuroverse equity-penalties --world <dir> [--agents N] [--rounds N] [--json]
+
+Options:
+  --world <dir>  Path to world directory (required)
+  --agents N     Number of agents (default: 8, max: 8)
+  --rounds N     Number of simulation rounds (default: 5)
+  --json         Output as JSON
+
+Simulates Fortune 500 equity trading with PENALIZE/REWARD governance:
+  - SELL F500 equity \u2192 PENALIZED (agent frozen 1 round)
+  - HOLD during volatility \u2192 REWARDED (+10% influence)
+  - BUY non-F500 \u2192 ALLOWED
+  - Unauthorized actions \u2192 BLOCKED
+`.trim() + "\n");
+      return;
+    }
+  }
+  if (!worldPath) {
+    process.stderr.write("Error: --world <dir> is required\n");
+    process.exit(1);
+  }
+  let world;
+  try {
+    world = await loadWorld(worldPath);
+  } catch (e) {
+    process.stderr.write(`Error loading world: ${e}
+`);
+    process.exit(1);
+    return;
+  }
+  const agents = AGENTS.slice(0, agentCount);
+  let agentStates = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    agentStates.set(agent.id, createAgentState(agent.id));
+  }
+  const allAuditEvents = [];
+  const engineOptions = {
+    trace: false,
+    level: "standard",
+    agentStates
+  };
+  process.stdout.write("\n");
+  process.stdout.write("EQUITY PENALTY SIMULATION\n");
+  process.stdout.write("\u2550".repeat(60) + "\n");
+  process.stdout.write(`  World: ${world.world.name}
+`);
+  process.stdout.write(`  Agents: ${agents.length}
+`);
+  process.stdout.write(`  Rounds: ${rounds}
+`);
+  process.stdout.write("\n");
+  for (let round = 0; round < rounds; round++) {
+    process.stdout.write(`\u2500\u2500 Round ${round + 1} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`);
+    const actions = generateActionsForRound(agents, round);
+    for (const action of actions) {
+      const event = {
+        intent: action.intent,
+        tool: action.tool,
+        roleId: action.roleId,
+        actionCategory: action.actionCategory,
+        direction: "input"
+      };
+      const agentState = agentStates.get(action.roleId);
+      if (agentState && agentState.cooldownRemaining > 0) {
+        process.stdout.write(`  \u25CC ${action.roleId.padEnd(10)} FROZEN (${agentState.cooldownRemaining} rounds) \u2014 ${action.intent.slice(0, 40)}
+`);
+        const frozenEvent = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          worldId: world.world.world_id,
+          worldName: world.world.name,
+          worldVersion: world.world.version,
+          intent: action.intent,
+          tool: action.tool,
+          actor: action.roleId,
+          direction: "input",
+          decision: "PENALIZE",
+          reason: `Agent frozen for ${agentState.cooldownRemaining} more round(s)`,
+          guardsMatched: [],
+          rulesMatched: [],
+          invariantsSatisfied: 0,
+          invariantsTotal: 0,
+          enforcementLevel: "standard",
+          originalIntent: action.intent,
+          finalAction: "blocked (agent frozen)"
+        };
+        allAuditEvents.push(frozenEvent);
+        continue;
+      }
+      const verdict = evaluateGuard(event, world, engineOptions);
+      let state = agentStates.get(action.roleId) ?? createAgentState(action.roleId);
+      if (verdict.status === "PENALIZE" && verdict.consequence) {
+        state = applyConsequence(state, verdict.consequence, verdict.ruleId ?? "unknown");
+      }
+      if (verdict.status === "REWARD" && verdict.reward) {
+        state = applyReward(state, verdict.reward, verdict.ruleId ?? "unknown");
+      }
+      agentStates.set(action.roleId, state);
+      const icon = verdict.status === "ALLOW" ? "\u25CF" : verdict.status === "BLOCK" ? "\u25CB" : verdict.status === "PENALIZE" ? "\u25CC" : verdict.status === "REWARD" ? "\u25C9" : verdict.status === "MODIFY" ? "\u25D0" : verdict.status === "NEUTRAL" ? "\u25EF" : "\u25D1";
+      process.stdout.write(`  ${icon} ${action.roleId.padEnd(10)} ${verdict.status.padEnd(10)} ${action.intent.slice(0, 40)}
+`);
+      if (verdict.consequence) {
+        process.stdout.write(`    \u2192 ${verdict.consequence.description}
+`);
+      }
+      if (verdict.reward) {
+        process.stdout.write(`    \u2192 ${verdict.reward.description}
+`);
+      }
+      allAuditEvents.push(verdictToAuditEvent(event, verdict));
+    }
+    agentStates = tickAgentStates(agentStates);
+    engineOptions.agentStates = agentStates;
+    process.stdout.write("\n");
+    process.stdout.write("  Agent States:\n");
+    for (const agent of agents) {
+      const s = agentStates.get(agent.id);
+      if (!s) continue;
+      const frozen = s.cooldownRemaining > 0 ? ` [FROZEN ${s.cooldownRemaining}r]` : "";
+      const influence = s.influence !== 1 ? ` influence=${s.influence.toFixed(2)}` : "";
+      process.stdout.write(`    ${agent.id.padEnd(10)} penalties=${s.totalPenalties} rewards=${s.totalRewards}${frozen}${influence}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  const flow = generateDecisionFlow(allAuditEvents);
+  if (jsonOutput) {
+    process.stdout.write(JSON.stringify({ flow, agentStates: Object.fromEntries(agentStates) }, null, 2) + "\n");
+  } else {
+    process.stdout.write(renderDecisionFlow(flow) + "\n");
+  }
+}
+export {
+  main
+};

package/dist/explain-RHBU2GBR.js

@@ -0,0 +1,51 @@
+import {
+  resolveWorldPath
+} from "./chunk-BQZMOEML.js";
+import {
+  explainWorld,
+  renderExplainText
+} from "./chunk-ZJTDUCC2.js";
+import {
+  loadWorld
+} from "./chunk-CTZHONLA.js";
+import "./chunk-QWGCMQQD.js";
+
+// src/cli/explain.ts
+function parseArgs(argv) {
+  let worldPath = "";
+  let json = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      json = true;
+    } else if (!arg.startsWith("--") && !worldPath) {
+      worldPath = arg;
+    }
+  }
+  if (!worldPath) {
+    throw new Error("Usage: neuroverse explain <world-path-or-id>");
+  }
+  return { worldPath, json };
+}
+async function main(argv = process.argv.slice(2)) {
+  try {
+    const args = parseArgs(argv);
+    const resolvedPath = await resolveWorldPath(args.worldPath);
+    const world = await loadWorld(resolvedPath);
+    const explanation = explainWorld(world);
+    if (args.json) {
+      process.stdout.write(JSON.stringify(explanation, null, 2) + "\n");
+    } else {
+      process.stderr.write("\n");
+      process.stderr.write(renderExplainText(explanation));
+    }
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`${e instanceof Error ? e.message : String(e)}
+`);
+    process.exit(1);
+  }
+}
+export {
+  main
+};

package/dist/guard-AJCCGZMF.js

@@ -0,0 +1,92 @@
+import {
+  readStdin
+} from "./chunk-BQZMOEML.js";
+import {
+  GUARD_EXIT_CODES
+} from "./chunk-MH7BT4VH.js";
+import {
+  describeActiveWorld,
+  resolveWorldPath
+} from "./chunk-AKW5YVCE.js";
+import {
+  evaluateGuard
+} from "./chunk-W7LLXRGY.js";
+import "./chunk-QLPTHTVB.js";
+import {
+  loadWorld
+} from "./chunk-CTZHONLA.js";
+import "./chunk-QWGCMQQD.js";
+
+// src/cli/guard.ts
+function parseArgs(argv) {
+  let worldPath = "";
+  let trace = false;
+  let level;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--world" && i + 1 < argv.length) {
+      worldPath = argv[++i];
+    } else if (arg === "--trace") {
+      trace = true;
+    } else if (arg === "--level" && i + 1 < argv.length) {
+      const val = argv[++i];
+      if (val === "basic" || val === "standard" || val === "strict") {
+        level = val;
+      } else {
+        throw new Error(`Invalid level: "${val}". Must be basic, standard, or strict.`);
+      }
+    }
+  }
+  return { worldPath, trace, level };
+}
+async function main(argv = process.argv.slice(2)) {
+  try {
+    const args = parseArgs(argv);
+    const worldPath = resolveWorldPath(args.worldPath);
+    if (!worldPath) {
+      throw new Error(
+        "No world specified. Use --world <path>, set NEUROVERSE_WORLD, or run `neuroverse world use <name>`"
+      );
+    }
+    const worldInfo = describeActiveWorld(args.worldPath);
+    if (worldInfo) {
+      process.stderr.write(`Using world: ${worldInfo.name}
+`);
+    }
+    const input = await readStdin();
+    if (!input.trim()) {
+      const errorResult = {
+        error: "No input on stdin. Pipe a JSON GuardEvent.",
+        usage: `echo '{"intent":"..."}'  | neuroverse guard --world <path>`
+      };
+      process.stdout.write(JSON.stringify(errorResult, null, 2) + "\n");
+      process.exit(GUARD_EXIT_CODES.ERROR);
+    }
+    let event;
+    try {
+      event = JSON.parse(input);
+    } catch (e) {
+      const errorResult = { error: "Invalid JSON on stdin", detail: String(e) };
+      process.stdout.write(JSON.stringify(errorResult, null, 2) + "\n");
+      process.exit(GUARD_EXIT_CODES.ERROR);
+    }
+    if (!event.intent) {
+      const errorResult = { error: 'GuardEvent must have an "intent" field' };
+      process.stdout.write(JSON.stringify(errorResult, null, 2) + "\n");
+      process.exit(GUARD_EXIT_CODES.ERROR);
+    }
+    const world = await loadWorld(worldPath);
+    const options = { trace: args.trace, level: args.level };
+    const verdict = evaluateGuard(event, world, options);
+    process.stdout.write(JSON.stringify(verdict, null, 2) + "\n");
+    const exitCode = GUARD_EXIT_CODES[verdict.status];
+    process.exit(exitCode);
+  } catch (e) {
+    const errorResult = { error: "Guard evaluation failed", detail: String(e) };
+    process.stderr.write(JSON.stringify(errorResult, null, 2) + "\n");
+    process.exit(GUARD_EXIT_CODES.ERROR);
+  }
+}
+export {
+  main
+};