@neuroverseos/governance 0.2.2 → 0.2.3

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-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
+};

package/dist/{chunk-RWXVAH6P.js → chunk-EVDJUSZ2.js}

@@ -1,23 +1,21 @@
+import {
+  GovernanceBlockedError,
+  buildEngineOptions,
+  extractScope,
+  trackPlanProgress
+} from "./chunk-5U2MQO5P.js";
 import {
   evaluateGuard
-} from "./chunk-4JRYGIO7.js";
+} from "./chunk-IZSO75NZ.js";
 import {
   loadWorld
 } from "./chunk-JZPQGIKR.js";
-import {
-  advancePlan,
-  evaluatePlan,
-  getPlanProgress
-} from "./chunk-4QXB6PEO.js";
 
 // src/adapters/langchain.ts
-var GovernanceBlockedError = class extends Error {
-  verdict;
+var GovernanceBlockedError2 = class extends GovernanceBlockedError {
   event;
   constructor(verdict, event) {
-    super(`[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
-    this.name = "GovernanceBlockedError";
-    this.verdict = verdict;
+    super(verdict);
     this.event = event;
   }
 };
@@ -25,7 +23,7 @@ function defaultMapToolCall(toolName, toolInput) {
   return {
     intent: toolName,
     tool: toolName,
-    scope: typeof toolInput.path === "string" ? toolInput.path : typeof toolInput.url === "string" ? toolInput.url : void 0,
+    scope: extractScope(toolInput),
     args: toolInput,
     direction: "input"
   };
@@ -41,11 +39,7 @@ var NeuroVerseCallbackHandler = 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.mapToolCall = options.mapToolCall ?? defaultMapToolCall;
   }
   /**
@@ -68,28 +62,16 @@ var NeuroVerseCallbackHandler = class {
     this.options.onEvaluate?.(verdict, event);
     if (verdict.status === "BLOCK") {
       this.options.onBlock?.(verdict, event);
-      throw new GovernanceBlockedError(verdict, event);
+      throw new GovernanceBlockedError2(verdict, event);
     }
     if (verdict.status === "PAUSE") {
       const approved = await this.options.onPause?.(verdict, event);
       if (!approved) {
-        throw new GovernanceBlockedError(verdict, event);
+        throw new GovernanceBlockedError2(verdict, event);
       }
     }
-    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);
     }
   }
 };
@@ -102,7 +84,7 @@ function createNeuroVerseCallbackHandlerFromWorld(world, options) {
 }
 
 export {
-  GovernanceBlockedError,
+  GovernanceBlockedError2 as GovernanceBlockedError,
   NeuroVerseCallbackHandler,
   createNeuroVerseCallbackHandler,
   createNeuroVerseCallbackHandlerFromWorld

package/dist/{chunk-4JRYGIO7.js → chunk-IZSO75NZ.js}

@@ -1,7 +1,9 @@
 import {
   buildPlanCheck,
-  evaluatePlan
-} from "./chunk-4QXB6PEO.js";
+  evaluatePlan,
+  matchesAllKeywords,
+  normalizeEventText
+} from "./chunk-QLPTHTVB.js";
 
 // src/engine/guard-engine.ts
 var PROMPT_INJECTION_PATTERNS = [
@@ -91,7 +93,7 @@ function evaluateGuard(event, world, options = {}) {
   const startTime = performance.now();
   const level = options.level ?? "standard";
   const includeTrace = options.trace ?? false;
-  const eventText = (event.intent + " " + (event.tool ?? "") + " " + (event.scope ?? "")).toLowerCase();
+  const eventText = normalizeEventText(event);
   const invariantChecks = [];
   const safetyChecks = [];
   let planCheckResult;
@@ -104,6 +106,43 @@ function evaluateGuard(event, world, options = {}) {
   const guardsMatched = [];
   const rulesMatched = [];
   checkInvariantCoverage(world, invariantChecks);
+  if (event.roleId && options.agentStates) {
+    const agentState = options.agentStates.get(event.roleId);
+    if (agentState && agentState.cooldownRemaining > 0) {
+      decidingLayer = "safety";
+      decidingId = `penalize-cooldown-${event.roleId}`;
+      const verdict = buildVerdict(
+        "PENALIZE",
+        `Agent "${event.roleId}" is frozen for ${agentState.cooldownRemaining} more round(s) due to prior penalty.`,
+        `penalize-cooldown-${event.roleId}`,
+        void 0,
+        world,
+        level,
+        invariantChecks,
+        guardsMatched,
+        rulesMatched,
+        includeTrace ? buildTrace(
+          invariantChecks,
+          safetyChecks,
+          planCheckResult,
+          roleChecks,
+          guardChecks,
+          kernelRuleChecks,
+          levelChecks,
+          decidingLayer,
+          decidingId,
+          startTime
+        ) : void 0
+      );
+      verdict.intentRecord = {
+        originalIntent: event.intent,
+        finalAction: "blocked (agent frozen)",
+        enforcement: "PENALIZE",
+        consequence: { type: "freeze", rounds: agentState.cooldownRemaining, description: "Agent still in cooldown from prior penalty" }
+      };
+      return verdict;
+    }
+  }
   if (options.sessionAllowlist) {
     const key = eventToAllowlistKey(event);
     if (options.sessionAllowlist.has(key)) {
@@ -231,7 +270,16 @@ function evaluateGuard(event, world, options = {}) {
     if (guardVerdict.status !== "ALLOW") {
       decidingLayer = "guard";
       decidingId = guardVerdict.ruleId;
-      return buildVerdict(
+      const intentRecord = {
+        originalIntent: event.intent,
+        finalAction: guardVerdict.status === "MODIFY" ? guardVerdict.modifiedTo ?? "modified" : guardVerdict.status === "PENALIZE" ? "blocked + penalized" : guardVerdict.status === "REWARD" ? event.intent : guardVerdict.status === "NEUTRAL" ? event.intent : guardVerdict.status === "BLOCK" ? "blocked" : "paused",
+        ruleApplied: guardVerdict.ruleId,
+        enforcement: guardVerdict.status,
+        modifiedTo: guardVerdict.modifiedTo,
+        consequence: guardVerdict.consequence,
+        reward: guardVerdict.reward
+      };
+      const verdict = buildVerdict(
         guardVerdict.status,
         guardVerdict.reason,
         guardVerdict.ruleId,
@@ -254,6 +302,10 @@ function evaluateGuard(event, world, options = {}) {
           startTime
         ) : void 0
       );
+      verdict.intentRecord = intentRecord;
+      if (guardVerdict.consequence) verdict.consequence = guardVerdict.consequence;
+      if (guardVerdict.reward) verdict.reward = guardVerdict.reward;
+      return verdict;
     }
   }
   const kernelVerdict = checkKernelRules(eventText, world, kernelRuleChecks, rulesMatched);
@@ -548,6 +600,21 @@ function checkGuards(event, eventText, world, checks, guardsMatched) {
     if (actionMode === "pause") {
       return { status: "PAUSE", reason, ruleId: `guard-${guard.id}` };
     }
+    if (actionMode === "penalize") {
+      const consequence = guard.consequence ? { ...guard.consequence } : { type: "freeze", rounds: 1, description: `Penalized for violating: ${guard.label}` };
+      return { status: "PENALIZE", reason, ruleId: `guard-${guard.id}`, consequence };
+    }
+    if (actionMode === "reward") {
+      const reward = guard.reward ? { ...guard.reward } : { type: "boost_influence", magnitude: 0.1, description: `Rewarded for: ${guard.label}` };
+      return { status: "REWARD", reason, ruleId: `guard-${guard.id}`, reward };
+    }
+    if (actionMode === "modify") {
+      const modifiedTo = guard.modify_to ?? guard.redirect ?? "hold";
+      return { status: "MODIFY", reason: `${reason} \u2192 Modified to: ${modifiedTo}`, ruleId: `guard-${guard.id}`, modifiedTo };
+    }
+    if (actionMode === "neutral") {
+      return { status: "NEUTRAL", reason, ruleId: `guard-${guard.id}` };
+    }
     if (actionMode === "warn" && !warnResult) {
       warnResult = { status: "ALLOW", warning: reason, ruleId: `guard-${guard.id}` };
     }
@@ -657,9 +724,7 @@ function checkLevelConstraints(event, level, checks) {
   return null;
 }
 function matchesKeywords(eventText, ruleText) {
-  const keywords = ruleText.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
-  if (keywords.length === 0) return false;
-  return keywords.every((kw) => eventText.includes(kw));
+  return matchesAllKeywords(eventText, ruleText);
 }
 function eventToAllowlistKey(event) {
   return `${(event.tool ?? "*").toLowerCase()}::${event.intent.toLowerCase().trim()}`;