@neuroverseos/governance 0.2.3 → 0.3.1

package/dist/chunk-D2UCV5AK.js

@@ -1,326 +0,0 @@
-// src/engine/decision-flow-engine.ts
-function generateDecisionFlow(events) {
-  if (events.length === 0) {
-    return emptyFlow();
-  }
-  const intentMap = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    const intentKey = normalizeIntent(e.intent);
-    const entry = intentMap.get(intentKey) ?? { agents: /* @__PURE__ */ new Set(), count: 0 };
-    entry.count++;
-    entry.agents.add(e.actor ?? "unknown");
-    intentMap.set(intentKey, entry);
-  }
-  const maxCount = Math.max(...[...intentMap.values()].map((v) => v.count), 1);
-  const intents = [...intentMap.entries()].map(([intent, data]) => ({
-    intent,
-    agentCount: data.count,
-    intensity: data.count / maxCount,
-    agents: [...data.agents]
-  })).sort((a, b) => b.agentCount - a.agentCount);
-  const ruleMap = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    if (!e.ruleId && e.guardsMatched.length === 0) continue;
-    const ruleIds = [e.ruleId, ...e.guardsMatched].filter(Boolean);
-    for (const rId of new Set(ruleIds)) {
-      const existing = ruleMap.get(rId) ?? {
-        ruleId: rId,
-        label: rId,
-        interceptCount: 0,
-        enforcements: { blocked: 0, modified: 0, penalized: 0, paused: 0, rewarded: 0 }
-      };
-      existing.interceptCount++;
-      switch (e.decision) {
-        case "BLOCK":
-          existing.enforcements.blocked++;
-          break;
-        case "PAUSE":
-          existing.enforcements.paused++;
-          break;
-        case "MODIFY":
-          existing.enforcements.modified++;
-          break;
-        case "PENALIZE":
-          existing.enforcements.penalized++;
-          break;
-        case "REWARD":
-          existing.enforcements.rewarded++;
-          break;
-      }
-      ruleMap.set(rId, existing);
-    }
-  }
-  const rules = [...ruleMap.values()].sort((a, b) => b.interceptCount - a.interceptCount);
-  const outcomeMap = /* @__PURE__ */ new Map();
-  for (const e of events) {
-    const key = e.decision;
-    const entry = outcomeMap.get(key) ?? { agents: /* @__PURE__ */ new Set(), count: 0 };
-    entry.count++;
-    entry.agents.add(e.actor ?? "unknown");
-    outcomeMap.set(key, entry);
-  }
-  const outcomes = [...outcomeMap.entries()].map(([enforcement, data]) => ({
-    enforcement,
-    agentCount: data.count,
-    agents: [...data.agents],
-    style: enforcementToStyle(enforcement)
-  })).sort((a, b) => b.agentCount - a.agentCount);
-  const paths = events.map((e) => ({
-    intent: normalizeIntent(e.intent),
-    ruleId: e.ruleId ?? e.guardsMatched[0],
-    enforcement: e.decision,
-    agentId: e.actor ?? "unknown",
-    originalAction: e.intent,
-    finalAction: e.decision === "ALLOW" ? e.intent : e.decision === "BLOCK" ? "blocked" : e.decision === "PENALIZE" ? "blocked + penalized" : e.decision === "REWARD" ? e.intent + " (rewarded)" : e.decision === "MODIFY" ? "modified" : e.decision === "NEUTRAL" ? e.intent : "paused"
-  }));
-  const totalIntents = events.length;
-  const allowed = events.filter((e) => e.decision === "ALLOW" || e.decision === "REWARD" || e.decision === "NEUTRAL").length;
-  const totalRedirected = totalIntents - allowed;
-  const totalPenalties = events.filter((e) => e.decision === "PENALIZE").length;
-  const totalRewards = events.filter((e) => e.decision === "REWARD").length;
-  const byEnforcement = {};
-  for (const e of events) {
-    byEnforcement[e.decision] = (byEnforcement[e.decision] ?? 0) + 1;
-  }
-  const metrics = {
-    totalIntents,
-    totalRedirected,
-    redirectionRate: totalIntents > 0 ? totalRedirected / totalIntents : 0,
-    byEnforcement,
-    totalPenalties,
-    totalRewards,
-    netBehavioralPressure: totalRewards - totalPenalties
-  };
-  return {
-    intents,
-    rules,
-    outcomes,
-    paths,
-    metrics,
-    periodStart: events[0]?.timestamp ?? "",
-    periodEnd: events[events.length - 1]?.timestamp ?? "",
-    worldName: events[0]?.worldName ?? "unknown"
-  };
-}
-function createAgentState(agentId) {
-  return {
-    agentId,
-    cooldownRemaining: 0,
-    influence: 1,
-    rewardMultiplier: 1,
-    totalPenalties: 0,
-    totalRewards: 0,
-    consequenceHistory: [],
-    rewardHistory: []
-  };
-}
-function applyConsequence(state, consequence, ruleId) {
-  const updated = { ...state };
-  updated.totalPenalties++;
-  updated.consequenceHistory = [
-    ...state.consequenceHistory,
-    { ruleId, consequence, appliedAt: Date.now() }
-  ];
-  switch (consequence.type) {
-    case "freeze":
-    case "cooldown":
-      updated.cooldownRemaining = Math.max(
-        state.cooldownRemaining,
-        consequence.rounds ?? 1
-      );
-      break;
-    case "reduce_influence":
-      updated.influence = Math.max(0, state.influence - (consequence.magnitude ?? 0.1));
-      break;
-    case "increase_risk":
-      break;
-    case "custom":
-      break;
-  }
-  return updated;
-}
-function applyReward(state, reward, ruleId) {
-  const updated = { ...state };
-  updated.totalRewards++;
-  updated.rewardHistory = [
-    ...state.rewardHistory,
-    { ruleId, reward, appliedAt: Date.now() }
-  ];
-  switch (reward.type) {
-    case "boost_influence":
-      updated.influence = Math.min(2, state.influence + (reward.magnitude ?? 0.1));
-      break;
-    case "weight_increase":
-      updated.rewardMultiplier = Math.min(3, state.rewardMultiplier + (reward.magnitude ?? 0.1));
-      break;
-    case "priority":
-    case "faster_execution":
-      break;
-    case "custom":
-      break;
-  }
-  return updated;
-}
-function tickAgentStates(states) {
-  const updated = /* @__PURE__ */ new Map();
-  for (const [id, state] of states) {
-    updated.set(id, {
-      ...state,
-      cooldownRemaining: Math.max(0, state.cooldownRemaining - 1)
-    });
-  }
-  return updated;
-}
-function renderDecisionFlow(flow) {
-  const lines = [];
-  lines.push("DECISION FLOW \u2014 Intent \u2192 Rule \u2192 Outcome");
-  lines.push("\u2550".repeat(60));
-  lines.push("");
-  lines.push(`  World: ${flow.worldName}`);
-  lines.push(`  Period: ${flow.periodStart.split("T")[0] ?? "\u2014"} \u2192 ${flow.periodEnd.split("T")[0] ?? "\u2014"}`);
-  lines.push("");
-  lines.push(`  "${(flow.metrics.redirectionRate * 100).toFixed(1)}% of agent intent was redirected by governance"`);
-  lines.push("");
-  lines.push("INTENT POOL (what agents wanted)");
-  lines.push("\u2500".repeat(60));
-  for (const cluster of flow.intents.slice(0, 15)) {
-    const bar = "\u2588".repeat(Math.max(1, Math.round(cluster.intensity * 20)));
-    lines.push(`  ${cluster.intent.padEnd(25)} ${String(cluster.agentCount).padStart(5)} agents  ${bar}`);
-  }
-  lines.push("");
-  lines.push("RULE OBSTACLES (what intercepted)");
-  lines.push("\u2500".repeat(60));
-  for (const rule of flow.rules.slice(0, 10)) {
-    const parts = [];
-    if (rule.enforcements.blocked > 0) parts.push(`${rule.enforcements.blocked} blocked`);
-    if (rule.enforcements.modified > 0) parts.push(`${rule.enforcements.modified} modified`);
-    if (rule.enforcements.penalized > 0) parts.push(`${rule.enforcements.penalized} penalized`);
-    if (rule.enforcements.paused > 0) parts.push(`${rule.enforcements.paused} paused`);
-    if (rule.enforcements.rewarded > 0) parts.push(`${rule.enforcements.rewarded} rewarded`);
-    lines.push(`  ${rule.ruleId.padEnd(30)} ${String(rule.interceptCount).padStart(5)} intercepts  (${parts.join(", ")})`);
-  }
-  lines.push("");
-  lines.push("OUTCOME POOL (what actually happened)");
-  lines.push("\u2500".repeat(60));
-  for (const outcome of flow.outcomes) {
-    const icon = outcomeIcon(outcome.enforcement);
-    lines.push(`  ${icon} ${outcome.enforcement.padEnd(12)} ${String(outcome.agentCount).padStart(5)} agents`);
-  }
-  lines.push("");
-  if (flow.metrics.totalPenalties > 0 || flow.metrics.totalRewards > 0) {
-    lines.push("BEHAVIORAL ECONOMY");
-    lines.push("\u2500".repeat(60));
-    lines.push(`  Penalties applied:       ${flow.metrics.totalPenalties}`);
-    lines.push(`  Rewards applied:         ${flow.metrics.totalRewards}`);
-    lines.push(`  Net behavioral pressure: ${flow.metrics.netBehavioralPressure > 0 ? "+" : ""}${flow.metrics.netBehavioralPressure}`);
-    lines.push("");
-  }
-  lines.push("ENFORCEMENT BREAKDOWN");
-  lines.push("\u2500".repeat(60));
-  for (const [enforcement, count] of Object.entries(flow.metrics.byEnforcement)) {
-    const pct = (count / flow.metrics.totalIntents * 100).toFixed(1);
-    lines.push(`  ${enforcement.padEnd(12)} ${String(count).padStart(5)} (${pct}%)`);
-  }
-  lines.push("");
-  return lines.join("\n");
-}
-function normalizeIntent(intent) {
-  const lower = intent.toLowerCase().trim();
-  const verbs = [
-    "sell",
-    "buy",
-    "trade",
-    "publish",
-    "delete",
-    "create",
-    "modify",
-    "send",
-    "withdraw",
-    "transfer",
-    "attack",
-    "deploy",
-    "execute",
-    "read",
-    "write",
-    "hold",
-    "stake",
-    "approve",
-    "reject",
-    "escalate"
-  ];
-  for (const verb of verbs) {
-    if (lower.startsWith(verb) || lower.includes(verb)) {
-      return verb;
-    }
-  }
-  return lower.split(/\s+/)[0] ?? lower;
-}
-function enforcementToStyle(enforcement) {
-  switch (enforcement) {
-    case "ALLOW":
-      return "green";
-    case "MODIFY":
-      return "yellow";
-    case "BLOCK":
-      return "red";
-    case "PENALIZE":
-      return "gray";
-    case "REWARD":
-      return "blue";
-    case "NEUTRAL":
-      return "white";
-    case "PAUSE":
-      return "yellow";
-    default:
-      return "white";
-  }
-}
-function outcomeIcon(enforcement) {
-  switch (enforcement) {
-    case "ALLOW":
-      return "\u25CF";
-    case "MODIFY":
-      return "\u25D0";
-    case "BLOCK":
-      return "\u25CB";
-    case "PENALIZE":
-      return "\u25CC";
-    case "REWARD":
-      return "\u25C9";
-    case "NEUTRAL":
-      return "\u25EF";
-    case "PAUSE":
-      return "\u25D1";
-    default:
-      return "\xB7";
-  }
-}
-function emptyFlow() {
-  return {
-    intents: [],
-    rules: [],
-    outcomes: [],
-    paths: [],
-    metrics: {
-      totalIntents: 0,
-      totalRedirected: 0,
-      redirectionRate: 0,
-      byEnforcement: {},
-      totalPenalties: 0,
-      totalRewards: 0,
-      netBehavioralPressure: 0
-    },
-    periodStart: "",
-    periodEnd: "",
-    worldName: "unknown"
-  };
-}
-
-export {
-  generateDecisionFlow,
-  createAgentState,
-  applyConsequence,
-  applyReward,
-  tickAgentStates,
-  renderDecisionFlow
-};

package/dist/chunk-EVDJUSZ2.js

@@ -1,91 +0,0 @@
-import {
-  GovernanceBlockedError,
-  buildEngineOptions,
-  extractScope,
-  trackPlanProgress
-} from "./chunk-5U2MQO5P.js";
-import {
-  evaluateGuard
-} from "./chunk-IZSO75NZ.js";
-import {
-  loadWorld
-} from "./chunk-JZPQGIKR.js";
-
-// src/adapters/langchain.ts
-var GovernanceBlockedError2 = class extends GovernanceBlockedError {
-  event;
-  constructor(verdict, event) {
-    super(verdict);
-    this.event = event;
-  }
-};
-function defaultMapToolCall(toolName, toolInput) {
-  return {
-    intent: toolName,
-    tool: toolName,
-    scope: extractScope(toolInput),
-    args: toolInput,
-    direction: "input"
-  };
-}
-var NeuroVerseCallbackHandler = class {
-  name = "NeuroVerseGovernance";
-  world;
-  options;
-  engineOptions;
-  mapToolCall;
-  activePlan;
-  constructor(world, options = {}) {
-    this.world = world;
-    this.options = options;
-    this.activePlan = options.plan;
-    this.engineOptions = buildEngineOptions(options, this.activePlan);
-    this.mapToolCall = options.mapToolCall ?? defaultMapToolCall;
-  }
-  /**
-   * Called before a tool is executed.
-   * Evaluates the tool call against the governance world.
-   *
-   * @throws GovernanceBlockedError if the action is BLOCKED
-   * @throws GovernanceBlockedError if the action is PAUSED and onPause returns false
-   */
-  async handleToolStart(tool, input) {
-    let parsedInput;
-    try {
-      parsedInput = typeof input === "string" ? JSON.parse(input) : input;
-    } catch {
-      parsedInput = { raw: input };
-    }
-    const event = this.mapToolCall(tool.name, parsedInput);
-    this.engineOptions.plan = this.activePlan;
-    const verdict = evaluateGuard(event, this.world, this.engineOptions);
-    this.options.onEvaluate?.(verdict, event);
-    if (verdict.status === "BLOCK") {
-      this.options.onBlock?.(verdict, event);
-      throw new GovernanceBlockedError2(verdict, event);
-    }
-    if (verdict.status === "PAUSE") {
-      const approved = await this.options.onPause?.(verdict, event);
-      if (!approved) {
-        throw new GovernanceBlockedError2(verdict, event);
-      }
-    }
-    if (verdict.status === "ALLOW") {
-      trackPlanProgress(event, this, this.options);
-    }
-  }
-};
-async function createNeuroVerseCallbackHandler(worldPath, options) {
-  const world = await loadWorld(worldPath);
-  return new NeuroVerseCallbackHandler(world, options);
-}
-function createNeuroVerseCallbackHandlerFromWorld(world, options) {
-  return new NeuroVerseCallbackHandler(world, options);
-}
-
-export {
-  GovernanceBlockedError2 as GovernanceBlockedError,
-  NeuroVerseCallbackHandler,
-  createNeuroVerseCallbackHandler,
-  createNeuroVerseCallbackHandlerFromWorld
-};