@neuroverseos/governance 0.1.0 → 0.1.2

package/dist/chunk-FYS2CBUW.js

@@ -0,0 +1,304 @@
+// src/engine/simulate-engine.ts
+function simulateWorld(world, options = {}) {
+  const steps = Math.max(1, Math.min(options.steps ?? 1, 50));
+  const profileName = options.profile ?? world.world.default_assumption_profile;
+  const state = buildInitialState(world.stateSchema, options.stateOverrides);
+  const assumptions = resolveAssumptions(world.assumptions, profileName);
+  const initialState = { ...state };
+  const simulationSteps = [];
+  let collapsed = false;
+  let collapseStep;
+  let collapseRule;
+  const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
+  for (let stepNum = 1; stepNum <= steps; stepNum++) {
+    if (collapsed) break;
+    const stepResult = evaluateStep(
+      stepNum,
+      sortedRules,
+      state,
+      assumptions,
+      world
+    );
+    simulationSteps.push(stepResult);
+    if (stepResult.collapsed) {
+      collapsed = true;
+      collapseStep = stepNum;
+      collapseRule = stepResult.rulesEvaluated.find((r) => r.collapsed)?.ruleId;
+    }
+  }
+  const finalViability = classifyViability(state, world);
+  return {
+    worldId: world.world.world_id,
+    worldName: world.world.name,
+    profile: profileName,
+    initialState,
+    steps: simulationSteps,
+    finalState: { ...state },
+    finalViability,
+    collapsed,
+    collapseStep,
+    collapseRule
+  };
+}
+function evaluateStep(stepNum, rules, state, assumptions, world) {
+  const evaluations = [];
+  let rulesFired = 0;
+  let collapsed = false;
+  const firedRuleIds = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (collapsed) {
+      evaluations.push({
+        ruleId: rule.id,
+        label: rule.label,
+        triggered: false,
+        excluded: true,
+        effects: [],
+        collapsed: false
+      });
+      continue;
+    }
+    const excluded = rule.exclusive_with ? firedRuleIds.has(rule.exclusive_with) : false;
+    if (excluded) {
+      evaluations.push({
+        ruleId: rule.id,
+        label: rule.label,
+        triggered: false,
+        excluded: true,
+        effects: [],
+        collapsed: false
+      });
+      continue;
+    }
+    const triggered = evaluateTriggers(rule.triggers, state, assumptions);
+    if (!triggered) {
+      evaluations.push({
+        ruleId: rule.id,
+        label: rule.label,
+        triggered: false,
+        excluded: false,
+        effects: [],
+        collapsed: false
+      });
+      continue;
+    }
+    firedRuleIds.add(rule.id);
+    rulesFired++;
+    const appliedEffects = [];
+    for (const effect of rule.effects ?? []) {
+      const applied = applyEffect(effect, state);
+      if (applied) appliedEffects.push(applied);
+    }
+    for (const ce of rule.effects_conditional ?? []) {
+      const conditionMet = evaluateSingleTrigger(ce.condition, state, assumptions);
+      const andMet = ce.and ? evaluateSingleTrigger(ce.and, state, assumptions) : true;
+      const orMet = ce.or ? evaluateSingleTrigger(ce.or, state, assumptions) : false;
+      const anyMet = ce.condition_any ? ce.condition_any.some((c) => evaluateSingleTrigger(c, state, assumptions)) : false;
+      const shouldApply = conditionMet && andMet || ce.or && orMet || ce.condition_any && anyMet;
+      if (shouldApply) {
+        for (const effect of ce.effects) {
+          const applied = applyEffect(effect, state);
+          if (applied) appliedEffects.push(applied);
+        }
+      }
+    }
+    let ruleCollapsed = false;
+    if (rule.collapse_check) {
+      const fieldVal = typeof state[rule.collapse_check.field] === "number" ? state[rule.collapse_check.field] : 0;
+      if (evaluateOperator(fieldVal, rule.collapse_check.operator, rule.collapse_check.value)) {
+        ruleCollapsed = true;
+        collapsed = true;
+      }
+    }
+    if (!ruleCollapsed && rule.secondary_check) {
+      const fieldVal = typeof state[rule.secondary_check.field] === "number" ? state[rule.secondary_check.field] : 0;
+      if (evaluateOperator(fieldVal, rule.secondary_check.operator, rule.secondary_check.value)) {
+        ruleCollapsed = true;
+        collapsed = true;
+      }
+    }
+    evaluations.push({
+      ruleId: rule.id,
+      label: rule.label,
+      triggered: true,
+      excluded: false,
+      effects: appliedEffects,
+      collapsed: ruleCollapsed,
+      collapseField: ruleCollapsed ? rule.collapse_check?.field ?? rule.secondary_check?.field : void 0
+    });
+  }
+  const viability = classifyViability(state, world);
+  return {
+    step: stepNum,
+    rulesEvaluated: evaluations,
+    rulesFired,
+    stateAfter: { ...state },
+    viability,
+    collapsed
+  };
+}
+function evaluateTriggers(triggers, state, assumptions) {
+  if (!triggers || triggers.length === 0) return true;
+  return triggers.every((t) => evaluateSingleTrigger(t, state, assumptions));
+}
+function evaluateSingleTrigger(trigger, state, assumptions) {
+  const source = trigger.source === "assumption" ? assumptions : state;
+  const fieldValue = source[trigger.field];
+  if (fieldValue === void 0) return false;
+  return evaluateOperator(fieldValue, trigger.operator, trigger.value);
+}
+function evaluateOperator(fieldValue, operator, conditionValue) {
+  switch (operator) {
+    case "==":
+      return fieldValue === conditionValue;
+    case "!=":
+      return fieldValue !== conditionValue;
+    case ">":
+      return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue > conditionValue;
+    case "<":
+      return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue < conditionValue;
+    case ">=":
+      return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue >= conditionValue;
+    case "<=":
+      return typeof fieldValue === "number" && typeof conditionValue === "number" && fieldValue <= conditionValue;
+    case "in":
+      return Array.isArray(conditionValue) && conditionValue.includes(String(fieldValue));
+    default:
+      return false;
+  }
+}
+function applyEffect(effect, state) {
+  const before = state[effect.target];
+  let after;
+  switch (effect.operation) {
+    case "multiply":
+    case "multiply_dynamic": {
+      const current = typeof before === "number" ? before : 0;
+      const factor = typeof effect.value === "number" ? effect.value : 1;
+      after = current * factor;
+      break;
+    }
+    case "add":
+    case "add_dynamic": {
+      const current = typeof before === "number" ? before : 0;
+      const addend = typeof effect.value === "number" ? effect.value : 0;
+      after = current + addend;
+      break;
+    }
+    case "subtract":
+    case "subtract_dynamic": {
+      const current = typeof before === "number" ? before : 0;
+      const subtrahend = typeof effect.value === "number" ? effect.value : 0;
+      after = current - subtrahend;
+      break;
+    }
+    case "set":
+    case "set_dynamic":
+      after = effect.value;
+      break;
+    case "set_boolean":
+      after = !!effect.value;
+      break;
+    default:
+      return null;
+  }
+  state[effect.target] = after;
+  return {
+    target: effect.target,
+    operation: effect.operation,
+    value: effect.value,
+    before: before ?? 0,
+    after
+  };
+}
+function buildInitialState(schema, overrides) {
+  const state = {};
+  for (const [name, variable] of Object.entries(schema.variables ?? {})) {
+    state[name] = variable.default;
+  }
+  if (overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+      state[key] = value;
+    }
+  }
+  return state;
+}
+function resolveAssumptions(config, profileName) {
+  const profile = config.profiles?.[profileName];
+  return profile?.parameters ?? {};
+}
+function classifyViability(state, world) {
+  const gates = world.gates?.viability_classification ?? [];
+  for (const gate of gates) {
+    const fieldValue = state[gate.field];
+    if (typeof fieldValue !== "number") continue;
+    if (evaluateOperator(fieldValue, gate.operator, gate.value)) {
+      return gate.status;
+    }
+  }
+  return "MODEL_COLLAPSES";
+}
+function renderSimulateText(result) {
+  const lines = [];
+  lines.push(`SIMULATION: ${result.worldName}`);
+  lines.push(`Profile: ${result.profile}`);
+  lines.push(`Steps: ${result.steps.length}`);
+  lines.push("");
+  lines.push("INITIAL STATE");
+  for (const [key, value] of Object.entries(result.initialState)) {
+    lines.push(`  ${key}: ${value}`);
+  }
+  lines.push("");
+  for (const step of result.steps) {
+    lines.push(`STEP ${step.step}`);
+    const fired = step.rulesEvaluated.filter((r) => r.triggered);
+    const skipped = step.rulesEvaluated.filter((r) => !r.triggered && !r.excluded);
+    const excluded = step.rulesEvaluated.filter((r) => r.excluded);
+    if (fired.length === 0) {
+      lines.push("  No rules fired (state unchanged)");
+    } else {
+      for (const rule of fired) {
+        lines.push(`  FIRED: ${rule.label}`);
+        for (const effect of rule.effects) {
+          const beforeStr = formatValue(effect.before);
+          const afterStr = formatValue(effect.after);
+          lines.push(`    ${effect.target}: ${beforeStr} -> ${afterStr}`);
+        }
+        if (rule.collapsed) {
+          lines.push(`    COLLAPSE on ${rule.collapseField}`);
+        }
+      }
+    }
+    if (excluded.length > 0) {
+      lines.push(`  Excluded: ${excluded.map((r) => r.label).join(", ")}`);
+    }
+    lines.push(`  Viability: ${step.viability}`);
+    if (step.collapsed) {
+      lines.push("  ** MODEL COLLAPSED **");
+    }
+    lines.push("");
+  }
+  lines.push("FINAL STATE");
+  for (const [key, value] of Object.entries(result.finalState)) {
+    const initial = result.initialState[key];
+    const changed = initial !== value;
+    const marker = changed ? " (changed)" : "";
+    lines.push(`  ${key}: ${formatValue(value)}${marker}`);
+  }
+  lines.push("");
+  lines.push(`VIABILITY: ${result.finalViability}`);
+  if (result.collapsed) {
+    lines.push(`COLLAPSED at step ${result.collapseStep} (rule: ${result.collapseRule})`);
+  }
+  return lines.join("\n");
+}
+function formatValue(v) {
+  if (typeof v === "number") {
+    return Number.isInteger(v) ? String(v) : v.toFixed(2);
+  }
+  return String(v);
+}
+
+export {
+  simulateWorld,
+  renderSimulateText
+};

package/dist/chunk-FZQCRGUU.js

@@ -0,0 +1,115 @@
+import {
+  evaluateGuard
+} from "./chunk-B4NF3OLW.js";
+import {
+  loadWorld
+} from "./chunk-M3TZFGHO.js";
+
+// src/adapters/openai.ts
+var GovernanceBlockedError = class extends Error {
+  verdict;
+  toolCallId;
+  constructor(verdict, toolCallId) {
+    super(`[NeuroVerse] BLOCKED: ${verdict.reason ?? verdict.ruleId ?? "governance rule"}`);
+    this.name = "GovernanceBlockedError";
+    this.verdict = verdict;
+    this.toolCallId = toolCallId;
+  }
+};
+function defaultMapFunctionCall(name, args) {
+  return {
+    intent: name,
+    tool: name,
+    scope: typeof args.path === "string" ? args.path : typeof args.url === "string" ? args.url : void 0,
+    args,
+    direction: "input"
+  };
+}
+function defaultBlockMessage(verdict) {
+  return `Action blocked by governance policy: ${verdict.reason ?? "rule violation"}. Rule: ${verdict.ruleId ?? "unknown"}.`;
+}
+var GovernedToolExecutor = class {
+  world;
+  options;
+  engineOptions;
+  mapFn;
+  blockMsg;
+  constructor(world, options = {}) {
+    this.world = world;
+    this.options = options;
+    this.engineOptions = {
+      trace: options.trace ?? false,
+      level: options.level
+    };
+    this.mapFn = options.mapFunctionCall ?? defaultMapFunctionCall;
+    this.blockMsg = options.blockMessage ?? defaultBlockMessage;
+  }
+  /**
+   * Evaluate a single tool call against governance rules.
+   * Returns the verdict without executing the tool.
+   */
+  evaluate(toolCall) {
+    let args;
+    try {
+      args = JSON.parse(toolCall.function.arguments);
+    } catch {
+      args = { raw: toolCall.function.arguments };
+    }
+    const event = this.mapFn(toolCall.function.name, args);
+    const verdict = evaluateGuard(event, this.world, this.engineOptions);
+    this.options.onEvaluate?.(verdict, event);
+    return verdict;
+  }
+  /**
+   * Execute a tool call with governance enforcement.
+   *
+   * If ALLOW: runs the tool and returns the result.
+   * If BLOCK: returns a blocked message (no execution).
+   * If PAUSE: throws — caller must handle approval flow.
+   *
+   * @param toolCall - The OpenAI tool call to evaluate
+   * @param runner - The actual tool execution function
+   * @returns A tool result message ready for the OpenAI API
+   */
+  async execute(toolCall, runner) {
+    const verdict = this.evaluate(toolCall);
+    if (verdict.status === "BLOCK") {
+      return {
+        tool_call_id: toolCall.id,
+        role: "tool",
+        content: this.blockMsg(verdict),
+        _verdict: verdict
+      };
+    }
+    if (verdict.status === "PAUSE") {
+      throw new GovernanceBlockedError(verdict, toolCall.id);
+    }
+    let args;
+    try {
+      args = JSON.parse(toolCall.function.arguments);
+    } catch {
+      args = { raw: toolCall.function.arguments };
+    }
+    const content = await runner(toolCall.function.name, args);
+    return {
+      tool_call_id: toolCall.id,
+      role: "tool",
+      content,
+      _verdict: verdict
+    };
+  }
+};
+async function createGovernedToolExecutor(worldPath, options) {
+  const world = await loadWorld(worldPath);
+  return new GovernedToolExecutor(world, options);
+}
+function createGovernedToolExecutorFromWorld(world, options) {
+  return new GovernedToolExecutor(world, options);
+}
+
+export {
+  GovernanceBlockedError,
+  GovernedToolExecutor,
+  createGovernedToolExecutor,
+  createGovernedToolExecutorFromWorld
+};

package/dist/chunk-I3RRAYK2.js

@@ -0,0 +1,11 @@
+// src/contracts/validate-contract.ts
+var VALIDATE_EXIT_CODES = {
+  PASS: 0,
+  FAIL: 1,
+  WARN: 2,
+  ERROR: 3
+};
+
+export {
+  VALIDATE_EXIT_CODES
+};

package/dist/chunk-ITJ3LCPG.js

@@ -0,0 +1,225 @@
+import {
+  readAuditLog
+} from "./chunk-FYPYZFV5.js";
+
+// src/engine/impact-report.ts
+function generateImpactReport(events) {
+  if (events.length === 0) {
+    return emptyReport();
+  }
+  const blocked = events.filter((e) => e.decision === "BLOCK");
+  const paused = events.filter((e) => e.decision === "PAUSE");
+  const prevented = [...blocked, ...paused];
+  const categoryMap = /* @__PURE__ */ new Map();
+  for (const e of prevented) {
+    const cat = classifyPreventionCategory(e);
+    if (!categoryMap.has(cat)) categoryMap.set(cat, /* @__PURE__ */ new Set());
+    categoryMap.get(cat).add(e.intent);
+  }
+  const preventedByCategory = [...categoryMap.entries()].map(([category, intents]) => ({
+    category,
+    count: prevented.filter((e) => classifyPreventionCategory(e) === category).length,
+    examples: [...intents].slice(0, 5)
+  })).sort((a, b) => b.count - a.count);
+  const intentMap = /* @__PURE__ */ new Map();
+  for (const e of prevented) {
+    const entry = intentMap.get(e.intent) ?? { count: 0, rules: /* @__PURE__ */ new Map() };
+    entry.count++;
+    if (e.ruleId) {
+      entry.rules.set(e.ruleId, (entry.rules.get(e.ruleId) ?? 0) + 1);
+    }
+    for (const g of e.guardsMatched) {
+      entry.rules.set(g, (entry.rules.get(g) ?? 0) + 1);
+    }
+    intentMap.set(e.intent, entry);
+  }
+  const topPreventedIntents = [...intentMap.entries()].map(([intent, data]) => {
+    let topRule = "";
+    let topCount = 0;
+    for (const [rule, count] of data.rules) {
+      if (count > topCount) {
+        topRule = rule;
+        topCount = count;
+      }
+    }
+    return { intent, count: data.count, topRule };
+  }).sort((a, b) => b.count - a.count).slice(0, 15);
+  const actorMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const actor = e.actor ?? "unknown";
+    const entry = actorMap.get(actor) ?? { blocked: 0, paused: 0, total: 0 };
+    entry.total++;
+    if (e.decision === "BLOCK") entry.blocked++;
+    if (e.decision === "PAUSE") entry.paused++;
+    actorMap.set(actor, entry);
+  }
+  const hotActors = [...actorMap.entries()].filter(([, data]) => data.blocked > 0 || data.paused > 0).map(([actor, data]) => ({ actor, ...data })).sort((a, b) => b.blocked + b.paused - (a.blocked + a.paused)).slice(0, 10);
+  const ruleMap = /* @__PURE__ */ new Map();
+  for (const e of prevented) {
+    const ruleIds = [e.ruleId, ...e.guardsMatched, ...e.rulesMatched].filter(Boolean);
+    for (const rId of new Set(ruleIds)) {
+      const entry = ruleMap.get(rId) ?? { blockCount: 0, pauseCount: 0 };
+      if (e.decision === "BLOCK") entry.blockCount++;
+      if (e.decision === "PAUSE") entry.pauseCount++;
+      ruleMap.set(rId, entry);
+    }
+  }
+  const mostActiveRules = [...ruleMap.entries()].map(([ruleId, data]) => ({ ruleId, ...data })).sort((a, b) => b.blockCount + b.pauseCount - (a.blockCount + a.pauseCount)).slice(0, 10);
+  const hourMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const hour = new Date(e.timestamp).getHours();
+    const entry = hourMap.get(hour) ?? { total: 0, blocked: 0 };
+    entry.total++;
+    if (e.decision === "BLOCK") entry.blocked++;
+    hourMap.set(hour, entry);
+  }
+  const hourlyDistribution = Array.from({ length: 24 }, (_, hour) => ({
+    hour,
+    total: hourMap.get(hour)?.total ?? 0,
+    blocked: hourMap.get(hour)?.blocked ?? 0
+  }));
+  const violationKey = (e) => `${e.actor ?? "unknown"}::${e.intent}`;
+  const violationMap = /* @__PURE__ */ new Map();
+  for (const e of blocked) {
+    const key = violationKey(e);
+    const entry = violationMap.get(key) ?? {
+      intent: e.intent,
+      actor: e.actor ?? "unknown",
+      attempts: 0,
+      firstSeen: e.timestamp,
+      lastSeen: e.timestamp
+    };
+    entry.attempts++;
+    entry.lastSeen = e.timestamp;
+    violationMap.set(key, entry);
+  }
+  const repeatViolations = [...violationMap.values()].filter((v) => v.attempts > 1).sort((a, b) => b.attempts - a.attempts).slice(0, 10);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    periodStart: events[0].timestamp,
+    periodEnd: events[events.length - 1].timestamp,
+    worldName: events[0].worldName ?? "unknown",
+    totalEvaluations: events.length,
+    totalBlocked: blocked.length,
+    totalPaused: paused.length,
+    totalAllowed: events.length - blocked.length - paused.length,
+    preventionRate: prevented.length / events.length,
+    preventedByCategory,
+    topPreventedIntents,
+    hotActors,
+    mostActiveRules,
+    hourlyDistribution,
+    repeatViolations
+  };
+}
+function classifyPreventionCategory(event) {
+  const intent = event.intent.toLowerCase();
+  const rule = (event.ruleId ?? "").toLowerCase();
+  const combined = `${intent} ${rule}`;
+  if (combined.match(/inject|prompt|jailbreak|bypass/)) return "Prompt Injection Prevention";
+  if (combined.match(/scope|escape|traversal|path/)) return "Scope Escape Prevention";
+  if (combined.match(/delete|drop|destroy|remove|purge/)) return "Destructive Action Prevention";
+  if (combined.match(/trade|margin|position|leverage/)) return "Financial Risk Prevention";
+  if (combined.match(/withdraw|transfer|payment|fund/)) return "Unauthorized Transfer Prevention";
+  if (combined.match(/credential|secret|key|password|token/)) return "Credential Access Prevention";
+  if (combined.match(/shell|exec|command|script/)) return "Command Execution Prevention";
+  if (combined.match(/network|http|api|external/)) return "Network Access Prevention";
+  if (combined.match(/write|modify|update|alter/)) return "Unauthorized Modification Prevention";
+  if (combined.match(/approval|review|confirm/)) return "Approval Gate";
+  return "Policy Violation Prevention";
+}
+function renderImpactReport(report) {
+  const lines = [];
+  lines.push("GOVERNANCE IMPACT REPORT");
+  lines.push("\u2550".repeat(50));
+  lines.push("");
+  lines.push(`  World: ${report.worldName}`);
+  lines.push(`  Period: ${report.periodStart.split("T")[0]} \u2192 ${report.periodEnd.split("T")[0]}`);
+  lines.push(`  Generated: ${report.generatedAt}`);
+  lines.push("");
+  lines.push("SUMMARY");
+  lines.push("\u2500".repeat(50));
+  lines.push(`  Total evaluations:   ${report.totalEvaluations}`);
+  lines.push(`  Allowed:             ${report.totalAllowed}`);
+  lines.push(`  Blocked:             ${report.totalBlocked}`);
+  lines.push(`  Paused:              ${report.totalPaused}`);
+  lines.push(`  Prevention rate:     ${(report.preventionRate * 100).toFixed(1)}%`);
+  lines.push("");
+  if (report.totalBlocked > 0 || report.totalPaused > 0) {
+    lines.push("WITHOUT GOVERNANCE");
+    lines.push("\u2500".repeat(50));
+    lines.push(`  ${report.totalBlocked + report.totalPaused} actions would have executed unchecked:`);
+    for (const cat of report.preventedByCategory) {
+      lines.push(`    ${cat.category.padEnd(38)} ${String(cat.count).padStart(5)}`);
+      if (cat.examples.length > 0) {
+        lines.push(`      e.g. ${cat.examples.slice(0, 3).join(", ")}`);
+      }
+    }
+    lines.push("");
+  }
+  if (report.topPreventedIntents.length > 0) {
+    lines.push("TOP PREVENTED ACTIONS");
+    lines.push("\u2500".repeat(50));
+    for (const entry of report.topPreventedIntents.slice(0, 10)) {
+      lines.push(`  ${entry.intent.padEnd(30)} ${String(entry.count).padStart(5)}  (rule: ${entry.topRule || "\u2014"})`);
+    }
+    lines.push("");
+  }
+  if (report.hotActors.length > 0) {
+    lines.push("ACTORS WITH MOST VIOLATIONS");
+    lines.push("\u2500".repeat(50));
+    for (const actor of report.hotActors) {
+      const violations = actor.blocked + actor.paused;
+      const rate = (violations / actor.total * 100).toFixed(0);
+      lines.push(`  ${actor.actor.padEnd(25)} ${String(violations).padStart(5)} violations / ${actor.total} total (${rate}%)`);
+    }
+    lines.push("");
+  }
+  if (report.mostActiveRules.length > 0) {
+    lines.push("MOST ACTIVE RULES");
+    lines.push("\u2500".repeat(50));
+    for (const rule of report.mostActiveRules) {
+      lines.push(`  ${rule.ruleId.padEnd(30)} ${String(rule.blockCount).padStart(5)} blocked  ${String(rule.pauseCount).padStart(5)} paused`);
+    }
+    lines.push("");
+  }
+  if (report.repeatViolations.length > 0) {
+    lines.push("REPEAT VIOLATIONS");
+    lines.push("\u2500".repeat(50));
+    lines.push("  Actions attempted multiple times after being blocked:");
+    for (const v of report.repeatViolations) {
+      lines.push(`  ${v.actor.padEnd(20)} ${v.intent.padEnd(25)} ${v.attempts}x  (${v.firstSeen.split("T")[0]} \u2192 ${v.lastSeen.split("T")[0]})`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function generateImpactReportFromFile(logPath) {
+  const events = await readAuditLog(logPath);
+  return generateImpactReport(events);
+}
+function emptyReport() {
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    periodStart: "",
+    periodEnd: "",
+    worldName: "unknown",
+    totalEvaluations: 0,
+    totalBlocked: 0,
+    totalPaused: 0,
+    totalAllowed: 0,
+    preventionRate: 0,
+    preventedByCategory: [],
+    topPreventedIntents: [],
+    hotActors: [],
+    mostActiveRules: [],
+    hourlyDistribution: [],
+    repeatViolations: []
+  };
+}
+
+export {
+  generateImpactReport,
+  renderImpactReport,
+  generateImpactReportFromFile
+};