@neuroverseos/governance 0.3.0 → 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
+};

package/dist/{chunk-XPDMYECO.js → chunk-EMQDLDAF.js}

@@ -453,190 +453,6 @@ function parseWorldMarkdown(markdown) {
   };
 }
 
-// src/engine/bootstrap-emitter.ts
-var GATE_DEFAULTS = {
-  THRIVING: { color: "#0f6b3a", icon: "\u2726" },
-  STABLE: { color: "#1856b8", icon: "\u25CF" },
-  COMPRESSED: { color: "#a16207", icon: "\u25B2" },
-  CRITICAL: { color: "#b91c1c", icon: "\u26A0" },
-  MODEL_COLLAPSES: { color: "#7f1d1d", icon: "\u2715" }
-};
-function emitWorldDefinition(parsed) {
-  const issues = [];
-  const fm = parsed.frontmatter;
-  const defaultProfile = fm.default_profile ?? parsed.assumptions[0]?.id ?? "baseline";
-  const altProfile = fm.alternative_profile ?? parsed.assumptions[1]?.id ?? "alternative";
-  const world = {
-    world_id: fm.world_id,
-    name: fm.name,
-    thesis: parsed.thesis,
-    version: fm.version ?? "1.0.0",
-    runtime_mode: fm.runtime_mode ?? "SIMULATION",
-    default_assumption_profile: defaultProfile,
-    default_alternative_profile: altProfile,
-    modules: parsed.rules.map((r) => r.id),
-    players: {
-      thinking_space: true,
-      experience_space: true,
-      action_space: true
-    }
-  };
-  const invariants = parsed.invariants.map((inv) => ({
-    id: inv.id,
-    label: inv.label,
-    enforcement: inv.enforcement === "prompt" ? "prompt" : "structural",
-    mutable: false
-  }));
-  const profiles = {};
-  const parameterDefinitions = {};
-  for (let i = 0; i < parsed.assumptions.length; i++) {
-    const profile = parsed.assumptions[i];
-    const params = {};
-    for (const [key, val] of Object.entries(profile.parameters)) {
-      params[key] = String(val);
-      if (!parameterDefinitions[key]) {
-        parameterDefinitions[key] = {
-          type: typeof val === "boolean" ? "boolean" : typeof val === "number" ? "number" : "enum",
-          label: key.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
-          description: `Parameter: ${key}`
-        };
-      }
-    }
-    profiles[profile.id] = {
-      name: profile.name,
-      description: profile.description,
-      is_default_baseline: i === 0 || profile.id === defaultProfile,
-      is_default_alternative: i === 1 || profile.id === altProfile,
-      parameters: params
-    };
-  }
-  const assumptions = { profiles, parameter_definitions: parameterDefinitions };
-  const variables = {};
-  for (const v of parsed.stateVariables) {
-    const stateVar = {
-      type: v.type,
-      default: v.default,
-      mutable: true,
-      label: v.label,
-      description: v.description
-    };
-    if (v.type === "number") {
-      if (v.min !== void 0) stateVar.min = v.min;
-      if (v.max !== void 0) stateVar.max = v.max;
-      if (v.step !== void 0) stateVar.step = v.step;
-    }
-    if (v.type === "enum" && v.options) {
-      stateVar.options = v.options;
-    }
-    variables[v.id] = stateVar;
-  }
-  const stateSchema = { variables, presets: {} };
-  const rules = parsed.rules.map((r) => {
-    const triggers = r.triggers.map((t) => ({
-      field: t.field,
-      operator: t.operator,
-      value: t.value,
-      source: t.source
-    }));
-    const effects = r.effects.map((e) => ({
-      target: e.target,
-      operation: e.operation,
-      value: e.value
-    }));
-    let collapse_check;
-    if (r.collapse_check) {
-      collapse_check = {
-        field: r.collapse_check.field,
-        operator: r.collapse_check.operator,
-        value: r.collapse_check.value,
-        result: "MODEL_COLLAPSES"
-      };
-    }
-    const causal_translation = r.causal_translation ?? {
-      trigger_text: "",
-      rule_text: "",
-      shift_text: "",
-      effect_text: ""
-    };
-    const rule = {
-      id: r.id,
-      severity: r.severity,
-      label: r.label,
-      description: r.description ?? r.label,
-      order: r.order,
-      triggers,
-      effects: effects.length > 0 ? effects : void 0,
-      collapse_check,
-      causal_translation
-    };
-    return rule;
-  });
-  const viabilityClassification = parsed.gates.map((g) => {
-    const defaults = GATE_DEFAULTS[g.status] ?? { color: "#5c5a52", icon: "\u25CF" };
-    return {
-      status: g.status,
-      field: g.field,
-      operator: g.operator,
-      value: g.value,
-      color: defaults.color,
-      icon: defaults.icon
-    };
-  });
-  const gates = {
-    viability_classification: viabilityClassification,
-    structural_override: {
-      description: "Rules with severity=structural and triggered collapse_check force MODEL_COLLAPSES regardless of final margin.",
-      enforcement: "mandatory"
-    },
-    sustainability_threshold: 0.1,
-    collapse_visual: {
-      background: "#1c1917",
-      text: "#fef2f2",
-      border: "#b91c1c",
-      label: "Structural Failure"
-    }
-  };
-  const computedOutcomes = parsed.outcomes.map((o) => {
-    const outcome = {
-      id: o.id,
-      type: o.type,
-      label: o.label,
-      show_in_comparison: true
-    };
-    if (o.range) outcome.range = o.range;
-    if (o.display) outcome.display_as = o.display;
-    if (o.primary) outcome.primary = o.primary;
-    if (o.assignment) outcome.assignment = o.assignment;
-    return outcome;
-  });
-  const outcomes = {
-    computed_outcomes: computedOutcomes,
-    comparison_layout: {
-      primary_card: computedOutcomes.find((o) => o.primary)?.id ?? computedOutcomes[0]?.id ?? "",
-      status_badge: "viability_status",
-      structural_indicators: rules.filter((r) => r.severity === "structural").map((r) => r.id)
-    }
-  };
-  const metadata = {
-    format_version: "1.0.0",
-    created_at: (/* @__PURE__ */ new Date()).toISOString(),
-    last_modified: (/* @__PURE__ */ new Date()).toISOString(),
-    authoring_method: "manual-authoring"
-  };
-  const worldDefinition = {
-    world,
-    invariants,
-    assumptions,
-    stateSchema,
-    rules,
-    gates,
-    outcomes,
-    metadata
-  };
-  return { world: worldDefinition, issues };
-}
-
 export {
-  parseWorldMarkdown,
-  emitWorldDefinition
+  parseWorldMarkdown
 };

package/dist/{chunk-GR6DGCZ2.js → chunk-F66BVUYB.js}

@@ -1,9 +1,9 @@
-import {
-  simulateWorld
-} from "./chunk-FYS2CBUW.js";
 import {
   validateWorld
 } from "./chunk-7P3S7MAY.js";
+import {
+  simulateWorld
+} from "./chunk-ZWI3NIXK.js";
 
 // src/engine/improve-engine.ts
 function improveWorld(world) {

package/dist/{chunk-2NICNKOM.js → chunk-G7DJ6VOD.js}

@@ -1,9 +1,9 @@
 import {
   evaluateGuard
-} from "./chunk-4JRYGIO7.js";
+} from "./chunk-W7LLXRGY.js";
 import {
   loadWorld
-} from "./chunk-JZPQGIKR.js";
+} from "./chunk-CTZHONLA.js";
 
 // src/adapters/express.ts
 function methodToCategory(method) {
@@ -46,8 +46,9 @@ function defaultOnBlock(verdict, _req, res, statusCode) {
     ruleId: verdict.ruleId,
     status: verdict.status
   };
-  if (res.status && res.json) {
-    res.status(statusCode).json(body);
+  if (typeof res.status === "function" && typeof res.json === "function") {
+    const r = res.status(statusCode);
+    r.json(body);
   } else if (res.send) {
     res.statusCode = statusCode;
     res.send(JSON.stringify(body));

package/dist/{chunk-4A7LISES.js → chunk-IS4WUH6Y.js}

@@ -1,14 +1,20 @@
+import {
+  applyConsequence,
+  applyReward,
+  createAgentState,
+  tickAgentStates
+} from "./chunk-D2UCV5AK.js";
 import {
   evaluateGuard
-} from "./chunk-4JRYGIO7.js";
+} from "./chunk-W7LLXRGY.js";
 import {
   advancePlan,
   evaluatePlan,
   getPlanProgress
-} from "./chunk-4QXB6PEO.js";
+} from "./chunk-QLPTHTVB.js";
 import {
   loadWorld
-} from "./chunk-JZPQGIKR.js";
+} from "./chunk-CTZHONLA.js";
 
 // src/runtime/session.ts
 async function defaultToolExecutor(name, args) {
@@ -35,7 +41,11 @@ var SessionManager = class {
       actionsEvaluated: 0,
       actionsAllowed: 0,
       actionsBlocked: 0,
-      actionsPaused: 0
+      actionsPaused: 0,
+      actionsModified: 0,
+      actionsPenalized: 0,
+      actionsRewarded: 0,
+      agentStates: /* @__PURE__ */ new Map()
     };
   }
   /**
@@ -57,14 +67,41 @@ var SessionManager = class {
    */
   evaluate(event) {
     this.engineOptions.plan = this.state.plan;
+    this.engineOptions.agentStates = this.state.agentStates;
     const verdict = evaluateGuard(event, this.state.world, this.engineOptions);
     this.state.actionsEvaluated++;
     if (verdict.status === "ALLOW") this.state.actionsAllowed++;
     if (verdict.status === "BLOCK") this.state.actionsBlocked++;
     if (verdict.status === "PAUSE") this.state.actionsPaused++;
+    if (verdict.status === "MODIFY") this.state.actionsModified++;
+    if (verdict.status === "PENALIZE") this.state.actionsPenalized++;
+    if (verdict.status === "REWARD") this.state.actionsRewarded++;
+    if (event.roleId) {
+      let agentState = this.state.agentStates.get(event.roleId) ?? createAgentState(event.roleId);
+      if (verdict.status === "PENALIZE" && verdict.consequence) {
+        agentState = applyConsequence(agentState, verdict.consequence, verdict.ruleId ?? "unknown");
+      }
+      if (verdict.status === "REWARD" && verdict.reward) {
+        agentState = applyReward(agentState, verdict.reward, verdict.ruleId ?? "unknown");
+      }
+      this.state.agentStates.set(event.roleId, agentState);
+    }
     this.config.onVerdict?.(verdict, event);
     return verdict;
   }
+  /**
+   * Advance all agent states by one round.
+   * Call this at the end of each simulation round to decrement cooldowns.
+   */
+  tickRound() {
+    this.state.agentStates = tickAgentStates(this.state.agentStates);
+  }
+  /**
+   * Get the behavior state for a specific agent.
+   */
+  getAgentState(agentId) {
+    return this.state.agentStates.get(agentId);
+  }
   /**
    * Evaluate and execute a tool call.
    * Returns the execution result or block reason.
@@ -83,7 +120,7 @@ var SessionManager = class {
       direction: "input"
     };
     const verdict = this.evaluate(event);
-    if (verdict.status === "BLOCK") {
+    if (verdict.status === "BLOCK" || verdict.status === "PENALIZE") {
       return { allowed: false, verdict };
     }
     if (verdict.status === "PAUSE") {
@@ -269,7 +306,9 @@ async function runInteractiveMode(config, model) {
 `);
       process.stdout.write(`  Actions: ${s.actionsEvaluated} evaluated
 `);
-      process.stdout.write(`  Allowed: ${s.actionsAllowed} | Blocked: ${s.actionsBlocked} | Paused: ${s.actionsPaused}
+      process.stdout.write(`  Allowed: ${s.actionsAllowed} | Blocked: ${s.actionsBlocked} | Modified: ${s.actionsModified} | Paused: ${s.actionsPaused}
+`);
+      process.stdout.write(`  Penalized: ${s.actionsPenalized} | Rewarded: ${s.actionsRewarded}
 `);
       if (s.progress && s.plan) {
         process.stdout.write(`  Plan: ${s.plan.plan_id} \u2014 ${s.progress.completed}/${s.progress.total} (${s.progress.percentage}%)

package/dist/{chunk-MWDQ4MJB.js → chunk-MH7BT4VH.js}

@@ -3,7 +3,11 @@ var GUARD_EXIT_CODES = {
   ALLOW: 0,
   BLOCK: 1,
   PAUSE: 2,
-  ERROR: 3
+  ERROR: 3,
+  MODIFY: 4,
+  PENALIZE: 5,
+  REWARD: 6,
+  NEUTRAL: 7
 };
 
 export {