@neuroverseos/governance 0.2.3 → 0.3.1

package/dist/chunk-JCKSW2PZ.js

@@ -1,304 +0,0 @@
-import {
-  GovernanceBlockedError,
-  buildEngineOptions,
-  extractScope,
-  trackPlanProgress
-} from "./chunk-5U2MQO5P.js";
-import {
-  evaluateGuard
-} from "./chunk-IZSO75NZ.js";
-import {
-  loadWorld
-} from "./chunk-JZPQGIKR.js";
-
-// src/engine/tool-classifier.ts
-var TOOL_CATEGORY_MAP = {
-  // File operations
-  read_file: "file_read",
-  read: "file_read",
-  glob: "file_read",
-  grep: "file_read",
-  list_files: "file_read",
-  write_file: "file_write",
-  write: "file_write",
-  create_file: "file_write",
-  edit_file: "file_write",
-  edit: "file_write",
-  patch: "file_write",
-  delete_file: "file_delete",
-  remove_file: "file_delete",
-  // Shell
-  shell: "shell",
-  bash: "shell",
-  execute: "shell",
-  run_command: "shell",
-  terminal: "shell",
-  // Git
-  git: "git",
-  git_commit: "git",
-  git_push: "git",
-  git_checkout: "git",
-  // Network
-  http: "network",
-  fetch: "network",
-  curl: "network",
-  web_search: "network",
-  // Sub-agents
-  sub_agent: "sub_agent",
-  spawn_agent: "sub_agent",
-  delegate: "sub_agent",
-  // Context management
-  summarize: "context",
-  compress_context: "context"
-};
-function classifyTool(toolName) {
-  const normalized = toolName.toLowerCase().replace(/[-\s]/g, "_");
-  return TOOL_CATEGORY_MAP[normalized] ?? "unknown";
-}
-var DANGEROUS_SHELL_PATTERNS = [
-  { pattern: /rm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+|.*-rf\s+|.*--force)/, label: "force-delete" },
-  { pattern: /rm\s+-[a-zA-Z]*r/, label: "recursive-delete" },
-  { pattern: />\s*\/dev\/sd/, label: "disk-overwrite" },
-  { pattern: /mkfs\./, label: "format-disk" },
-  { pattern: /dd\s+if=/, label: "disk-dump" },
-  { pattern: /chmod\s+(-R\s+)?777/, label: "world-writable" },
-  { pattern: /curl\s+.*\|\s*(bash|sh|zsh)/, label: "pipe-to-shell" },
-  { pattern: /wget\s+.*\|\s*(bash|sh|zsh)/, label: "pipe-to-shell" },
-  { pattern: /:(){ :\|:& };:/, label: "fork-bomb" },
-  { pattern: />\s*\/etc\//, label: "system-config-overwrite" },
-  { pattern: /shutdown|reboot|halt|poweroff/, label: "system-shutdown" },
-  { pattern: /kill\s+-9\s+1\b/, label: "kill-init" }
-];
-var DANGEROUS_GIT_PATTERNS = [
-  { pattern: /push\s+.*--force/, label: "force-push" },
-  { pattern: /push\s+.*-f\b/, label: "force-push" },
-  { pattern: /push\s+(origin\s+)?main\b/, label: "push-main" },
-  { pattern: /push\s+(origin\s+)?master\b/, label: "push-master" },
-  { pattern: /reset\s+--hard/, label: "hard-reset" },
-  { pattern: /clean\s+-fd/, label: "clean-force" },
-  { pattern: /branch\s+-D/, label: "force-delete-branch" }
-];
-function isDangerousCommand(command) {
-  const matched = DANGEROUS_SHELL_PATTERNS.filter((p) => p.pattern.test(command)).map((p) => p.label);
-  return { dangerous: matched.length > 0, labels: matched };
-}
-function isDangerousGitCommand(command) {
-  const matched = DANGEROUS_GIT_PATTERNS.filter((p) => p.pattern.test(command)).map((p) => p.label);
-  return { dangerous: matched.length > 0, labels: matched };
-}
-function assessRiskLevel(category) {
-  if (category === "file_read" || category === "context") return "low";
-  if (category === "file_write" || category === "sub_agent") return "medium";
-  if (category === "shell" || category === "file_delete" || category === "git" || category === "network") return "high";
-  return void 0;
-}
-function categoryToActionCategory(category) {
-  if (category === "file_read" || category === "context") return "read";
-  if (category === "file_write") return "write";
-  if (category === "file_delete") return "delete";
-  if (category === "shell") return "shell";
-  if (category === "network") return "network";
-  return "other";
-}
-
-// src/adapters/deep-agents.ts
-var GovernanceBlockedError2 = class extends GovernanceBlockedError {
-  toolCall;
-  category;
-  constructor(verdict, toolCall, category) {
-    super(verdict);
-    this.toolCall = toolCall;
-    this.category = category;
-  }
-};
-function defaultMapToolCall(toolCall) {
-  const category = classifyTool(toolCall.tool);
-  const args = toolCall.args;
-  const scope = extractScope(args);
-  let intent = toolCall.tool;
-  if (category === "shell" && typeof args.command === "string") {
-    intent = `shell: ${args.command}`;
-  } else if (category === "git" && typeof args.command === "string") {
-    intent = `git ${args.command}`;
-  } else if (category === "file_write" && scope) {
-    intent = `write ${scope}`;
-  } else if (category === "file_delete" && scope) {
-    intent = `delete ${scope}`;
-  }
-  const riskLevel = assessRiskLevel(category);
-  let irreversible = false;
-  if (category === "shell" && typeof args.command === "string") {
-    irreversible = DANGEROUS_SHELL_PATTERNS.some((p) => p.pattern.test(args.command));
-  } else if (category === "git" && typeof args.command === "string") {
-    irreversible = DANGEROUS_GIT_PATTERNS.some((p) => p.pattern.test(args.command));
-  } else if (category === "file_delete") {
-    irreversible = true;
-  }
-  return {
-    intent,
-    tool: toolCall.tool,
-    scope,
-    args,
-    direction: "input",
-    actionCategory: categoryToActionCategory(category),
-    riskLevel,
-    irreversible
-  };
-}
-var DeepAgentsGuard = class {
-  name = "neuroverse-deep-agents-guard";
-  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;
-  }
-  /**
-   * Evaluate a tool call against governance rules.
-   * Returns the result without side effects.
-   */
-  evaluate(toolCall) {
-    const event = this.mapToolCall(toolCall);
-    this.engineOptions.plan = this.activePlan;
-    const verdict = evaluateGuard(event, this.world, this.engineOptions);
-    const category = classifyTool(toolCall.tool);
-    const result = {
-      allowed: verdict.status === "ALLOW",
-      verdict,
-      toolCall,
-      category
-    };
-    this.options.onEvaluate?.(result);
-    if (verdict.status === "ALLOW" && this.activePlan) {
-      this.trackPlanProgressInternal(event);
-    }
-    return result;
-  }
-  /**
-   * Evaluate and enforce governance on a tool call.
-   *
-   * @throws GovernanceBlockedError if BLOCKED
-   * @throws GovernanceBlockedError if PAUSED and onPause returns false
-   * @returns DeepAgentsGuardResult on ALLOW
-   */
-  async enforce(toolCall) {
-    const result = this.evaluate(toolCall);
-    if (result.verdict.status === "BLOCK") {
-      this.options.onBlock?.(result);
-      throw new GovernanceBlockedError2(result.verdict, toolCall, result.category);
-    }
-    if (result.verdict.status === "PAUSE") {
-      const approved = await this.options.onPause?.(result);
-      if (!approved) {
-        throw new GovernanceBlockedError2(result.verdict, toolCall, result.category);
-      }
-    }
-    return result;
-  }
-  /**
-   * Evaluate and execute a tool call with governance enforcement.
-   *
-   * If ALLOW: runs the executor and returns its result.
-   * If BLOCK: returns a governance-blocked message.
-   * If PAUSE: calls onPause; blocks if not approved.
-   *
-   * @param toolCall - The Deep Agents tool call to evaluate
-   * @param executor - The actual tool execution function
-   * @returns The tool execution result or a blocked message
-   */
-  async execute(toolCall, executor) {
-    const guardResult = this.evaluate(toolCall);
-    if (guardResult.verdict.status === "BLOCK") {
-      this.options.onBlock?.(guardResult);
-      return {
-        blocked: true,
-        verdict: guardResult.verdict,
-        reason: guardResult.verdict.reason ?? "Action blocked by governance policy."
-      };
-    }
-    if (guardResult.verdict.status === "PAUSE") {
-      const approved = await this.options.onPause?.(guardResult);
-      if (!approved) {
-        return {
-          blocked: true,
-          verdict: guardResult.verdict,
-          reason: guardResult.verdict.reason ?? "Action requires approval."
-        };
-      }
-    }
-    const result = await executor(toolCall);
-    return { result, verdict: guardResult.verdict };
-  }
-  /**
-   * Returns a middleware function compatible with Deep Agents' tool pipeline.
-   *
-   * The middleware intercepts tool calls before execution:
-   *   agent.use(guard.middleware());
-   */
-  middleware() {
-    return async (toolCall, next) => {
-      await this.enforce(toolCall);
-      return next();
-    };
-  }
-  /**
-   * Returns a callback-handler-style object for LangChain integration.
-   * Compatible with Deep Agents' callback system.
-   */
-  callbacks() {
-    return {
-      handleToolStart: async (tool, input) => {
-        let parsedInput;
-        try {
-          parsedInput = typeof input === "string" ? JSON.parse(input) : input;
-        } catch {
-          parsedInput = { raw: input };
-        }
-        await this.enforce({ tool: tool.name, args: parsedInput });
-      }
-    };
-  }
-  /**
-   * Check if a shell command contains dangerous patterns.
-   * Useful for pre-screening before full governance evaluation.
-   */
-  static isDangerousCommand(command) {
-    return isDangerousCommand(command);
-  }
-  /**
-   * Check if a git command contains dangerous patterns.
-   */
-  static isDangerousGitCommand(command) {
-    return isDangerousGitCommand(command);
-  }
-  /**
-   * Classify a tool name into a category.
-   */
-  static classifyTool(toolName) {
-    return classifyTool(toolName);
-  }
-  // ─── Private ──────────────────────────────────────────────────────────────
-  trackPlanProgressInternal(event) {
-    trackPlanProgress(event, this, this.options);
-  }
-};
-async function createDeepAgentsGuard(worldPath, options) {
-  const world = await loadWorld(worldPath);
-  return new DeepAgentsGuard(world, options);
-}
-function createDeepAgentsGuardFromWorld(world, options) {
-  return new DeepAgentsGuard(world, options);
-}
-
-export {
-  GovernanceBlockedError2 as GovernanceBlockedError,
-  DeepAgentsGuard,
-  createDeepAgentsGuard,
-  createDeepAgentsGuardFromWorld
-};

package/dist/chunk-JZPQGIKR.js

@@ -1,79 +0,0 @@
-// src/loader/world-loader.ts
-async function loadWorldFromDirectory(dirPath) {
-  const { readFile } = await import("fs/promises");
-  const { join } = await import("path");
-  const { readdirSync } = await import("fs");
-  async function readJson(filename) {
-    try {
-      const content = await readFile(join(dirPath, filename), "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return void 0;
-    }
-  }
-  const worldJson = await readJson("world.json");
-  if (!worldJson) {
-    throw new Error(`Cannot read world.json in ${dirPath}`);
-  }
-  const invariantsJson = await readJson("invariants.json");
-  const assumptionsJson = await readJson("assumptions.json");
-  const stateSchemaJson = await readJson("state-schema.json");
-  const gatesJson = await readJson("gates.json");
-  const outcomesJson = await readJson("outcomes.json");
-  const guardsJson = await readJson("guards.json");
-  const rolesJson = await readJson("roles.json");
-  const kernelJson = await readJson("kernel.json");
-  const metadataJson = await readJson("metadata.json");
-  const rules = [];
-  try {
-    const rulesDir = join(dirPath, "rules");
-    const ruleFiles = readdirSync(rulesDir).filter((f) => f.endsWith(".json")).sort();
-    for (const file of ruleFiles) {
-      const content = await readFile(join(rulesDir, file), "utf-8");
-      rules.push(JSON.parse(content));
-    }
-  } catch {
-  }
-  return {
-    world: worldJson,
-    invariants: invariantsJson?.invariants ?? [],
-    assumptions: assumptionsJson ?? { profiles: {}, parameter_definitions: {} },
-    stateSchema: stateSchemaJson ?? { variables: {}, presets: {} },
-    rules,
-    gates: gatesJson ?? {
-      viability_classification: [],
-      structural_override: { description: "", enforcement: "mandatory" },
-      sustainability_threshold: 0,
-      collapse_visual: { background: "", text: "", border: "", label: "" }
-    },
-    outcomes: outcomesJson ?? {
-      computed_outcomes: [],
-      comparison_layout: { primary_card: "", status_badge: "", structural_indicators: [] }
-    },
-    guards: guardsJson,
-    roles: rolesJson,
-    kernel: kernelJson,
-    metadata: metadataJson ?? {
-      format_version: "1.0.0",
-      created_at: "",
-      last_modified: "",
-      authoring_method: "manual-authoring"
-    }
-  };
-}
-async function loadWorld(worldPath) {
-  const { stat } = await import("fs/promises");
-  const info = await stat(worldPath);
-  if (info.isDirectory()) {
-    return loadWorldFromDirectory(worldPath);
-  }
-  if (worldPath.endsWith(".nv-world.zip")) {
-    throw new Error(".nv-world.zip loading not yet implemented \u2014 use a world directory");
-  }
-  throw new Error(`Cannot load world from: ${worldPath} \u2014 expected a directory or .nv-world.zip`);
-}
-
-export {
-  loadWorldFromDirectory,
-  loadWorld
-};

package/dist/chunk-KTFTTLTP.js

@@ -1,246 +0,0 @@
-import {
-  readAuditLog
-} from "./chunk-REXY4LUL.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 modified = events.filter((e) => e.decision === "MODIFY");
-  const penalized = events.filter((e) => e.decision === "PENALIZE");
-  const rewarded = events.filter((e) => e.decision === "REWARD");
-  const neutralEvents = events.filter((e) => e.decision === "NEUTRAL");
-  const prevented = [...blocked, ...paused, ...modified, ...penalized];
-  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);
-  const allowedCount = events.filter((e) => e.decision === "ALLOW").length;
-  const redirected = events.length - allowedCount - neutralEvents.length;
-  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: allowedCount,
-    totalModified: modified.length,
-    totalPenalized: penalized.length,
-    totalRewarded: rewarded.length,
-    totalNeutral: neutralEvents.length,
-    preventionRate: events.length > 0 ? prevented.length / events.length : 0,
-    redirectionRate: events.length > 0 ? redirected / events.length : 0,
-    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(`  Modified:            ${report.totalModified}`);
-  lines.push(`  Paused:              ${report.totalPaused}`);
-  lines.push(`  Penalized:           ${report.totalPenalized}`);
-  lines.push(`  Rewarded:            ${report.totalRewarded}`);
-  lines.push(`  Neutral:             ${report.totalNeutral}`);
-  lines.push(`  Prevention rate:     ${(report.preventionRate * 100).toFixed(1)}%`);
-  lines.push(`  Redirection rate:    ${(report.redirectionRate * 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,
-    totalModified: 0,
-    totalPenalized: 0,
-    totalRewarded: 0,
-    totalNeutral: 0,
-    preventionRate: 0,
-    redirectionRate: 0,
-    preventedByCategory: [],
-    topPreventedIntents: [],
-    hotActors: [],
-    mostActiveRules: [],
-    hourlyDistribution: [],
-    repeatViolations: []
-  };
-}
-
-export {
-  generateImpactReport,
-  renderImpactReport,
-  generateImpactReportFromFile
-};

package/dist/chunk-MH7BT4VH.js

@@ -1,15 +0,0 @@
-// src/contracts/guard-contract.ts
-var GUARD_EXIT_CODES = {
-  ALLOW: 0,
-  BLOCK: 1,
-  PAUSE: 2,
-  ERROR: 3,
-  MODIFY: 4,
-  PENALIZE: 5,
-  REWARD: 6,
-  NEUTRAL: 7
-};
-
-export {
-  GUARD_EXIT_CODES
-};