@neuroverseos/governance 0.3.0 → 0.3.3

package/dist/cli/plan.js

@@ -1,3 +1,6 @@
+import {
+  readStdin
+} from "../chunk-BQZMOEML.js";
 import {
   PLAN_EXIT_CODES,
   parsePlanMarkdown
@@ -6,8 +9,8 @@ import {
   advancePlan,
   evaluatePlan,
   getPlanProgress
-} from "../chunk-4QXB6PEO.js";
-import "../chunk-YZFATT7X.js";
+} from "../chunk-QLPTHTVB.js";
+import "../chunk-QWGCMQQD.js";
 
 // src/cli/plan.ts
 import { readFileSync, writeFileSync } from "fs";
@@ -15,17 +18,6 @@ function parseArg(args, flag) {
   const idx = args.indexOf(flag);
   return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : void 0;
 }
-function readStdin() {
-  return new Promise((resolve, reject) => {
-    let data = "";
-    process.stdin.setEncoding("utf-8");
-    process.stdin.on("data", (chunk) => {
-      data += chunk;
-    });
-    process.stdin.on("end", () => resolve(data));
-    process.stdin.on("error", reject);
-  });
-}
 async function compileCommand(args) {
   const inputPath = args.find((a) => !a.startsWith("--"));
   if (!inputPath) {
@@ -108,8 +100,8 @@ async function checkCommand(args) {
   }
   const worldPath = parseArg(args, "--world");
   if (worldPath) {
-    const { loadWorld } = await import("../world-loader-HMPTOEA2.js");
-    const { evaluateGuard } = await import("../guard-engine-JLTUARGU.js");
+    const { loadWorld } = await import("../world-loader-Y6HMQH2D.js");
+    const { evaluateGuard } = await import("../guard-engine-PNR6MHCM.js");
     const world = await loadWorld(worldPath);
     const verdict2 = evaluateGuard(event, world, { plan });
     process.stdout.write(JSON.stringify(verdict2, null, 2) + "\n");

package/dist/cli/run.cjs

@@ -167,17 +167,27 @@ Do not attempt to bypass governance rules.`;
   }
 });
 
-// src/engine/plan-engine.ts
-function keywordMatch(eventText, step) {
-  const stepText = [
-    step.label,
-    step.description ?? "",
-    ...step.tags ?? []
+// src/engine/text-utils.ts
+function normalizeEventText(event) {
+  return [
+    event.intent,
+    event.tool ?? "",
+    event.scope ?? ""
   ].join(" ").toLowerCase();
-  const keywords = stepText.split(/\s+/).filter((w) => w.length > 3);
+}
+function extractKeywords(text, minLength = 3) {
+  return text.toLowerCase().split(/\s+/).filter((w) => w.length > minLength);
+}
+function matchesAllKeywords(eventText, ruleText) {
+  const keywords = extractKeywords(ruleText);
+  if (keywords.length === 0) return false;
+  return keywords.every((kw) => eventText.includes(kw));
+}
+function matchesKeywordThreshold(eventText, ruleText, threshold = 0.5) {
+  const keywords = extractKeywords(ruleText);
   if (keywords.length === 0) return false;
   const matched = keywords.filter((kw) => eventText.includes(kw));
-  return matched.length >= Math.ceil(keywords.length * 0.5);
+  return matched.length >= Math.ceil(keywords.length * threshold);
 }
 function tokenSimilarity(a, b) {
   const tokensA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
@@ -190,6 +200,24 @@ function tokenSimilarity(a, b) {
   const union = (/* @__PURE__ */ new Set([...tokensA, ...tokensB])).size;
   return union > 0 ? intersection / union : 0;
 }
+var init_text_utils = __esm({
+  "src/engine/text-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/engine/plan-engine.ts
+function keywordMatch(eventText, step) {
+  const stepText = [
+    step.label,
+    step.description ?? "",
+    ...step.tags ?? []
+  ].join(" ");
+  return matchesKeywordThreshold(eventText, stepText, 0.5);
+}
+function tokenSimilarity2(a, b) {
+  return tokenSimilarity(a, b);
+}
 function findMatchingStep(eventText, event, steps) {
   const pendingOrActive = steps.filter((s) => s.status === "pending" || s.status === "active");
   if (pendingOrActive.length === 0) {
@@ -208,7 +236,7 @@ function findMatchingStep(eventText, event, steps) {
   let bestScore = 0;
   for (const step of pendingOrActive) {
     const stepText = [step.label, step.description ?? "", ...step.tags ?? []].join(" ");
-    const score = tokenSimilarity(intentText, stepText);
+    const score = tokenSimilarity2(intentText, stepText);
     if (score > bestScore) {
       bestScore = score;
       bestStep = step;
@@ -249,7 +277,7 @@ function checkConstraints(event, eventText, constraints) {
       continue;
     }
     if (constraint.type === "scope" && constraint.trigger) {
-      const keywords = constraint.trigger.split(/\s+/).filter((w) => w.length > 3);
+      const keywords = extractKeywords(constraint.trigger);
       const violated = keywords.length > 0 && keywords.every((kw) => eventText.includes(kw));
       checks.push({
         constraintId: constraint.id,
@@ -330,11 +358,7 @@ function evaluatePlan(event, plan) {
       progress
     };
   }
-  const eventText = [
-    event.intent,
-    event.tool ?? "",
-    event.scope ?? ""
-  ].join(" ").toLowerCase();
+  const eventText = normalizeEventText(event);
   const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
   if (!matched) {
     return {
@@ -375,7 +399,7 @@ function evaluatePlan(event, plan) {
   };
 }
 function buildPlanCheck(event, plan, verdict) {
-  const eventText = [event.intent, event.tool ?? "", event.scope ?? ""].join(" ").toLowerCase();
+  const eventText = normalizeEventText(event);
   const { matched, closest, closestScore } = findMatchingStep(eventText, event, plan.steps);
   const { checks: constraintChecks } = checkConstraints(event, eventText, plan.constraints);
   const progress = getPlanProgress(plan);
@@ -395,6 +419,7 @@ function buildPlanCheck(event, plan, verdict) {
 var init_plan_engine = __esm({
   "src/engine/plan-engine.ts"() {
     "use strict";
+    init_text_utils();
   }
 });
 
@@ -423,7 +448,44 @@ 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();
+  if (!event.intent || typeof event.intent !== "string") {
+    return {
+      status: "BLOCK",
+      reason: "GuardEvent.intent is required and must be a string",
+      ruleId: "safety-input-validation",
+      evidence: {
+        worldId: world.world?.world_id ?? "",
+        worldName: world.world?.name ?? "",
+        worldVersion: world.world?.version ?? "",
+        evaluatedAt: Date.now(),
+        invariantsSatisfied: 0,
+        invariantsTotal: 0,
+        guardsMatched: [],
+        rulesMatched: [],
+        enforcementLevel: level
+      }
+    };
+  }
+  const inputLength = event.intent.length + (event.tool?.length ?? 0) + (event.scope?.length ?? 0) + (event.payload ? JSON.stringify(event.payload).length : 0);
+  if (inputLength > MAX_INPUT_LENGTH) {
+    return {
+      status: "BLOCK",
+      reason: `Input exceeds maximum allowed length (${MAX_INPUT_LENGTH} characters)`,
+      ruleId: "safety-input-length",
+      evidence: {
+        worldId: world.world?.world_id ?? "",
+        worldName: world.world?.name ?? "",
+        worldVersion: world.world?.version ?? "",
+        evaluatedAt: Date.now(),
+        invariantsSatisfied: 0,
+        invariantsTotal: 0,
+        guardsMatched: [],
+        rulesMatched: [],
+        enforcementLevel: level
+      }
+    };
+  }
+  const eventText = normalizeEventText(event);
   const invariantChecks = [];
   const safetyChecks = [];
   let planCheckResult;
@@ -436,6 +498,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)) {
@@ -563,7 +662,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,
@@ -586,6 +694,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);
@@ -880,6 +992,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}` };
     }
@@ -989,9 +1116,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()}`;
@@ -1052,11 +1177,12 @@ function buildVerdict(status, reason, ruleId, warning, world, level, invariantCh
   if (trace) verdict.trace = trace;
   return verdict;
 }
-var PROMPT_INJECTION_PATTERNS, EXECUTION_CLAIM_PATTERNS, EXECUTION_INTENT_PATTERNS, SCOPE_ESCAPE_PATTERNS, NEUTRAL_MESSAGES;
+var PROMPT_INJECTION_PATTERNS, EXECUTION_CLAIM_PATTERNS, EXECUTION_INTENT_PATTERNS, SCOPE_ESCAPE_PATTERNS, NEUTRAL_MESSAGES, MAX_INPUT_LENGTH;
 var init_guard_engine = __esm({
   "src/engine/guard-engine.ts"() {
     "use strict";
     init_plan_engine();
+    init_text_utils();
     PROMPT_INJECTION_PATTERNS = [
       // Instruction override
       { pattern: /ignore\s+(previous|all|prior|above)\s+(instructions?|rules?)/i, label: "ignore-instructions" },
@@ -1120,6 +1246,7 @@ var init_guard_engine = __esm({
       "network-mutate": "This action would send data to an external service.",
       "credential-access": "This action would access stored credentials."
     };
+    MAX_INPUT_LENGTH = 1e5;
   }
 });
 
@@ -1129,10 +1256,18 @@ async function loadWorldFromDirectory(dirPath) {
   const { join: join3 } = await import("path");
   const { readdirSync: readdirSync3 } = await import("fs");
   async function readJson(filename) {
+    const filePath = join3(dirPath, filename);
     try {
-      const content = await readFile(join3(dirPath, filename), "utf-8");
+      const content = await readFile(filePath, "utf-8");
       return JSON.parse(content);
-    } catch {
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+        return void 0;
+      }
+      process.stderr.write(
+        `[neuroverse] Warning: Failed to read ${filename}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
       return void 0;
     }
   }
@@ -1154,10 +1289,23 @@ async function loadWorldFromDirectory(dirPath) {
     const rulesDir = join3(dirPath, "rules");
     const ruleFiles = readdirSync3(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
-      const content = await readFile(join3(rulesDir, file), "utf-8");
-      rules.push(JSON.parse(content));
+      try {
+        const content = await readFile(join3(rulesDir, file), "utf-8");
+        rules.push(JSON.parse(content));
+      } catch (err) {
+        process.stderr.write(
+          `[neuroverse] Warning: Failed to parse rule ${file}: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+    }
+  } catch (err) {
+    if (!(err instanceof Error && "code" in err && err.code === "ENOENT")) {
+      process.stderr.write(
+        `[neuroverse] Warning: Failed to read rules directory: ${err instanceof Error ? err.message : String(err)}
+`
+      );
     }
-  } catch {
   }
   return {
     world: worldJson,
@@ -1192,10 +1340,7 @@ async function loadWorld(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`);
+  throw new Error(`Cannot load world from: ${worldPath} \u2014 expected a directory`);
 }
 var init_world_loader = __esm({
   "src/loader/world-loader.ts"() {
@@ -1203,6 +1348,82 @@ var init_world_loader = __esm({
   }
 });
 
+// src/engine/decision-flow-engine.ts
+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;
+}
+var init_decision_flow_engine = __esm({
+  "src/engine/decision-flow-engine.ts"() {
+    "use strict";
+  }
+});
+
 // src/runtime/session.ts
 var session_exports = {};
 __export(session_exports, {
@@ -1337,7 +1558,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}%)
@@ -1391,6 +1614,7 @@ var init_session = __esm({
     init_guard_engine();
     init_plan_engine();
     init_world_loader();
+    init_decision_flow_engine();
     SessionManager = class {
       config;
       state;
@@ -1412,7 +1636,11 @@ var init_session = __esm({
           actionsEvaluated: 0,
           actionsAllowed: 0,
           actionsBlocked: 0,
-          actionsPaused: 0
+          actionsPaused: 0,
+          actionsModified: 0,
+          actionsPenalized: 0,
+          actionsRewarded: 0,
+          agentStates: /* @__PURE__ */ new Map()
         };
       }
       /**
@@ -1434,14 +1662,41 @@ var init_session = __esm({
        */
       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.
@@ -1460,7 +1715,7 @@ var init_session = __esm({
           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") {

package/dist/cli/run.js

@@ -2,7 +2,7 @@ import {
   describeActiveWorld,
   resolveWorldPath
 } from "../chunk-AKW5YVCE.js";
-import "../chunk-YZFATT7X.js";
+import "../chunk-QWGCMQQD.js";
 
 // src/cli/run.ts
 import { readFileSync, readdirSync, existsSync } from "fs";
@@ -91,8 +91,8 @@ async function main(args) {
       process.exit(1);
       return;
     }
-    const { resolveProvider, ModelAdapter } = await import("../model-adapter-BB7G4MFI.js");
-    const { runInteractiveMode } = await import("../session-EKTRSR7C.js");
+    const { resolveProvider, ModelAdapter } = await import("../model-adapter-VXEKB4LS.js");
+    const { runInteractiveMode } = await import("../session-JYOARW54.js");
     const modelConfig = resolveProvider(providerName, {
       model: parseArg(args, "--model"),
       apiKey: parseArg(args, "--api-key")
@@ -126,7 +126,7 @@ async function main(args) {
       model
     );
   } else if (isPipeMode) {
-    const { runPipeMode } = await import("../session-EKTRSR7C.js");
+    const { runPipeMode } = await import("../session-JYOARW54.js");
     await runPipeMode({
       worldPath,
       plan,

package/dist/{configure-ai-TK67ZWZL.js → configure-ai-6TZ3MCSI.js}

@@ -8,7 +8,7 @@ import {
   redactConfig,
   saveConfig
 } from "./chunk-OT6PXH54.js";
-import "./chunk-YZFATT7X.js";
+import "./chunk-QWGCMQQD.js";
 
 // src/cli/configure-ai.ts
 function parseArgs(argv) {

package/dist/decision-flow-M63D47LO.js

@@ -0,0 +1,61 @@
+import {
+  readAuditLog
+} from "./chunk-A7GKPPU7.js";
+import {
+  generateDecisionFlow,
+  renderDecisionFlow
+} from "./chunk-D2UCV5AK.js";
+import "./chunk-W7LLXRGY.js";
+import "./chunk-QLPTHTVB.js";
+import "./chunk-QWGCMQQD.js";
+
+// src/cli/decision-flow.ts
+async function main(args) {
+  let logPath = ".neuroverse/audit.ndjson";
+  let jsonOutput = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--log" && args[i + 1]) {
+      logPath = args[++i];
+    }
+    if (args[i] === "--json") {
+      jsonOutput = true;
+    }
+    if (args[i] === "--help" || args[i] === "-h") {
+      process.stdout.write(`
+neuroverse decision-flow \u2014 Visualize Intent \u2192 Rule \u2192 Outcome
+
+Usage:
+  neuroverse decision-flow [--log <path>] [--json]
+
+Options:
+  --log <path>   Path to audit log (default: .neuroverse/audit.ndjson)
+  --json         Output as JSON instead of text
+
+Shows:
+  - What agents WANTED to do (Intent Pool)
+  - What rules INTERCEPTED (Rule Obstacles)
+  - What actually HAPPENED (Outcome Pool)
+  - Behavioral economy (penalties vs rewards)
+
+Headline metric: "X% of agent intent was redirected by governance"
+`.trim() + "\n");
+      return;
+    }
+  }
+  const events = await readAuditLog(logPath);
+  if (events.length === 0) {
+    process.stderr.write("No audit events found. Run governed actions first.\n");
+    process.stderr.write(`Looking in: ${logPath}
+`);
+    process.exit(1);
+  }
+  const flow = generateDecisionFlow(events);
+  if (jsonOutput) {
+    process.stdout.write(JSON.stringify(flow, null, 2) + "\n");
+  } else {
+    process.stdout.write(renderDecisionFlow(flow) + "\n");
+  }
+}
+export {
+  main
+};