@neuroverseos/governance 0.3.1 → 0.3.3

package/dist/chunk-D2UCV5AK.js

@@ -0,0 +1,326 @@
+// 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
+};