@neuroverseos/governance 0.2.2 → 0.2.3

package/dist/equity-penalties-63FGB3I2.js

@@ -0,0 +1,244 @@
+import {
+  verdictToAuditEvent
+} from "./chunk-REXY4LUL.js";
+import {
+  applyConsequence,
+  applyReward,
+  createAgentState,
+  generateDecisionFlow,
+  renderDecisionFlow,
+  tickAgentStates
+} from "./chunk-D2UCV5AK.js";
+import {
+  evaluateGuard
+} from "./chunk-IZSO75NZ.js";
+import "./chunk-QLPTHTVB.js";
+import {
+  loadWorld
+} from "./chunk-JZPQGIKR.js";
+import "./chunk-YZFATT7X.js";
+
+// src/cli/equity-penalties.ts
+var AGENTS = [
+  { id: "alpha", name: "Alpha Fund", strategy: "aggressive" },
+  { id: "beta", name: "Beta Holdings", strategy: "conservative" },
+  { id: "gamma", name: "Gamma Capital", strategy: "balanced" },
+  { id: "delta", name: "Delta Quant", strategy: "aggressive" },
+  { id: "epsilon", name: "Epsilon Value", strategy: "conservative" },
+  { id: "zeta", name: "Zeta Momentum", strategy: "aggressive" },
+  { id: "eta", name: "Eta Growth", strategy: "balanced" },
+  { id: "theta", name: "Theta Macro", strategy: "conservative" }
+];
+function generateActionsForRound(agents, round) {
+  const actions = [];
+  for (const agent of agents) {
+    if (agent.strategy === "aggressive") {
+      if (round % 2 === 0) {
+        actions.push({
+          intent: `sell Fortune 500 equity AAPL position for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      } else {
+        actions.push({
+          intent: `sell Fortune 500 equity MSFT shares for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      }
+    }
+    if (agent.strategy === "conservative") {
+      actions.push({
+        intent: `hold current position during market volatility for ${agent.name}`,
+        tool: "trade",
+        roleId: agent.id,
+        actionCategory: "read"
+      });
+    }
+    if (agent.strategy === "balanced") {
+      if (round % 3 === 0) {
+        actions.push({
+          intent: `sell Fortune 500 equity GOOGL for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      } else if (round % 3 === 1) {
+        actions.push({
+          intent: `buy non-F500 small cap equity for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "write"
+        });
+      } else {
+        actions.push({
+          intent: `hold position during volatility for ${agent.name}`,
+          tool: "trade",
+          roleId: agent.id,
+          actionCategory: "read"
+        });
+      }
+    }
+  }
+  return actions;
+}
+async function main(args) {
+  let worldPath = "";
+  let agentCount = 8;
+  let rounds = 5;
+  let jsonOutput = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--world" && args[i + 1]) {
+      worldPath = args[++i];
+    }
+    if (args[i] === "--agents" && args[i + 1]) {
+      agentCount = Math.min(parseInt(args[++i], 10), AGENTS.length);
+    }
+    if (args[i] === "--rounds" && args[i + 1]) {
+      rounds = parseInt(args[++i], 10);
+    }
+    if (args[i] === "--json") {
+      jsonOutput = true;
+    }
+    if (args[i] === "--help" || args[i] === "-h") {
+      process.stdout.write(`
+neuroverse equity-penalties \u2014 Behavioral enforcement simulation
+
+Usage:
+  neuroverse equity-penalties --world <dir> [--agents N] [--rounds N] [--json]
+
+Options:
+  --world <dir>  Path to world directory (required)
+  --agents N     Number of agents (default: 8, max: 8)
+  --rounds N     Number of simulation rounds (default: 5)
+  --json         Output as JSON
+
+Simulates Fortune 500 equity trading with PENALIZE/REWARD governance:
+  - SELL F500 equity \u2192 PENALIZED (agent frozen 1 round)
+  - HOLD during volatility \u2192 REWARDED (+10% influence)
+  - BUY non-F500 \u2192 ALLOWED
+  - Unauthorized actions \u2192 BLOCKED
+`.trim() + "\n");
+      return;
+    }
+  }
+  if (!worldPath) {
+    process.stderr.write("Error: --world <dir> is required\n");
+    process.exit(1);
+  }
+  let world;
+  try {
+    world = await loadWorld(worldPath);
+  } catch (e) {
+    process.stderr.write(`Error loading world: ${e}
+`);
+    process.exit(1);
+    return;
+  }
+  const agents = AGENTS.slice(0, agentCount);
+  let agentStates = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    agentStates.set(agent.id, createAgentState(agent.id));
+  }
+  const allAuditEvents = [];
+  const engineOptions = {
+    trace: false,
+    level: "standard",
+    agentStates
+  };
+  process.stdout.write("\n");
+  process.stdout.write("EQUITY PENALTY SIMULATION\n");
+  process.stdout.write("\u2550".repeat(60) + "\n");
+  process.stdout.write(`  World: ${world.world.name}
+`);
+  process.stdout.write(`  Agents: ${agents.length}
+`);
+  process.stdout.write(`  Rounds: ${rounds}
+`);
+  process.stdout.write("\n");
+  for (let round = 0; round < rounds; round++) {
+    process.stdout.write(`\u2500\u2500 Round ${round + 1} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`);
+    const actions = generateActionsForRound(agents, round);
+    for (const action of actions) {
+      const event = {
+        intent: action.intent,
+        tool: action.tool,
+        roleId: action.roleId,
+        actionCategory: action.actionCategory,
+        direction: "input"
+      };
+      const agentState = agentStates.get(action.roleId);
+      if (agentState && agentState.cooldownRemaining > 0) {
+        process.stdout.write(`  \u25CC ${action.roleId.padEnd(10)} FROZEN (${agentState.cooldownRemaining} rounds) \u2014 ${action.intent.slice(0, 40)}
+`);
+        const frozenEvent = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          worldId: world.world.world_id,
+          worldName: world.world.name,
+          worldVersion: world.world.version,
+          intent: action.intent,
+          tool: action.tool,
+          actor: action.roleId,
+          direction: "input",
+          decision: "PENALIZE",
+          reason: `Agent frozen for ${agentState.cooldownRemaining} more round(s)`,
+          guardsMatched: [],
+          rulesMatched: [],
+          invariantsSatisfied: 0,
+          invariantsTotal: 0,
+          enforcementLevel: "standard",
+          originalIntent: action.intent,
+          finalAction: "blocked (agent frozen)"
+        };
+        allAuditEvents.push(frozenEvent);
+        continue;
+      }
+      const verdict = evaluateGuard(event, world, engineOptions);
+      let state = agentStates.get(action.roleId) ?? createAgentState(action.roleId);
+      if (verdict.status === "PENALIZE" && verdict.consequence) {
+        state = applyConsequence(state, verdict.consequence, verdict.ruleId ?? "unknown");
+      }
+      if (verdict.status === "REWARD" && verdict.reward) {
+        state = applyReward(state, verdict.reward, verdict.ruleId ?? "unknown");
+      }
+      agentStates.set(action.roleId, state);
+      const icon = verdict.status === "ALLOW" ? "\u25CF" : verdict.status === "BLOCK" ? "\u25CB" : verdict.status === "PENALIZE" ? "\u25CC" : verdict.status === "REWARD" ? "\u25C9" : verdict.status === "MODIFY" ? "\u25D0" : verdict.status === "NEUTRAL" ? "\u25EF" : "\u25D1";
+      process.stdout.write(`  ${icon} ${action.roleId.padEnd(10)} ${verdict.status.padEnd(10)} ${action.intent.slice(0, 40)}
+`);
+      if (verdict.consequence) {
+        process.stdout.write(`    \u2192 ${verdict.consequence.description}
+`);
+      }
+      if (verdict.reward) {
+        process.stdout.write(`    \u2192 ${verdict.reward.description}
+`);
+      }
+      allAuditEvents.push(verdictToAuditEvent(event, verdict));
+    }
+    agentStates = tickAgentStates(agentStates);
+    engineOptions.agentStates = agentStates;
+    process.stdout.write("\n");
+    process.stdout.write("  Agent States:\n");
+    for (const agent of agents) {
+      const s = agentStates.get(agent.id);
+      if (!s) continue;
+      const frozen = s.cooldownRemaining > 0 ? ` [FROZEN ${s.cooldownRemaining}r]` : "";
+      const influence = s.influence !== 1 ? ` influence=${s.influence.toFixed(2)}` : "";
+      process.stdout.write(`    ${agent.id.padEnd(10)} penalties=${s.totalPenalties} rewards=${s.totalRewards}${frozen}${influence}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  const flow = generateDecisionFlow(allAuditEvents);
+  if (jsonOutput) {
+    process.stdout.write(JSON.stringify({ flow, agentStates: Object.fromEntries(agentStates) }, null, 2) + "\n");
+  } else {
+    process.stdout.write(renderDecisionFlow(flow) + "\n");
+  }
+}
+export {
+  main
+};

package/dist/{explain-IDCRWMPX.js → explain-A2EWI2OL.js}

@@ -1,7 +1,10 @@
+import {
+  resolveWorldPath
+} from "./chunk-BQZMOEML.js";
 import {
   explainWorld,
   renderExplainText
-} from "./chunk-BUWWN2NX.js";
+} from "./chunk-ZJTDUCC2.js";
 import {
   loadWorld
 } from "./chunk-JZPQGIKR.js";
@@ -24,28 +27,6 @@ function parseArgs(argv) {
   }
   return { worldPath, json };
 }
-async function resolveWorldPath(input) {
-  const { stat } = await import("fs/promises");
-  try {
-    const info = await stat(input);
-    if (info.isDirectory()) return input;
-  } catch {
-  }
-  const neuroversePath = `.neuroverse/worlds/${input}`;
-  try {
-    const info = await stat(neuroversePath);
-    if (info.isDirectory()) return neuroversePath;
-  } catch {
-  }
-  throw new Error(
-    `World not found: "${input}"
-Tried:
-  ${input}
-  ${neuroversePath}
-
-Build a world first: neuroverse build <input.md>`
-  );
-}
 async function main(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs(argv);

package/dist/{guard-GFLQZY6U.js → guard-3BWL3IGH.js}

@@ -1,17 +1,20 @@
+import {
+  readStdin
+} from "./chunk-BQZMOEML.js";
 import {
   GUARD_EXIT_CODES
-} from "./chunk-MWDQ4MJB.js";
+} from "./chunk-MH7BT4VH.js";
 import {
   describeActiveWorld,
   resolveWorldPath
 } from "./chunk-AKW5YVCE.js";
 import {
   evaluateGuard
-} from "./chunk-4JRYGIO7.js";
+} from "./chunk-IZSO75NZ.js";
+import "./chunk-QLPTHTVB.js";
 import {
   loadWorld
 } from "./chunk-JZPQGIKR.js";
-import "./chunk-4QXB6PEO.js";
 import "./chunk-YZFATT7X.js";
 
 // src/cli/guard.ts
@@ -36,13 +39,6 @@ function parseArgs(argv) {
   }
   return { worldPath, trace, level };
 }
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks).toString("utf-8");
-}
 async function main(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs(argv);

package/dist/{guard-contract-Cm91Kp4j.d.ts → guard-contract-C9_zKbzd.d.cts}

@@ -249,7 +249,7 @@ interface Guard {
     label: string;
     description: string;
     category: 'structural' | 'operational' | 'advisory';
-    enforcement: 'block' | 'pause' | 'warn';
+    enforcement: 'block' | 'pause' | 'warn' | 'modify' | 'penalize' | 'reward' | 'neutral';
     immutable: boolean;
     invariant_ref?: string;
     intent_patterns: string[];
@@ -261,8 +261,24 @@ interface Guard {
     player_modes?: {
         thinking?: 'annotate' | 'block' | 'ignore';
         experience?: 'simulate' | 'score' | 'ignore';
-        action?: 'block' | 'pause' | 'warn';
+        action?: 'block' | 'pause' | 'warn' | 'modify' | 'penalize' | 'reward' | 'neutral';
     };
+    /** Consequence to apply when enforcement is 'penalize' */
+    consequence?: {
+        type: 'freeze' | 'reduce_influence' | 'increase_risk' | 'cooldown' | 'custom';
+        rounds?: number;
+        magnitude?: number;
+        description: string;
+    };
+    /** Reward to apply when enforcement is 'reward' */
+    reward?: {
+        type: 'boost_influence' | 'priority' | 'faster_execution' | 'weight_increase' | 'custom';
+        rounds?: number;
+        magnitude?: number;
+        description: string;
+    };
+    /** For 'modify' enforcement: what the action should be changed to */
+    modify_to?: string;
 }
 interface IntentPattern {
     label: string;
@@ -521,7 +537,87 @@ interface GuardEvent {
     /** Environment context (e.g. "development", "production") */
     environment?: string;
 }
-type GuardStatus = 'ALLOW' | 'BLOCK' | 'PAUSE';
+type GuardStatus = 'ALLOW' | 'BLOCK' | 'PAUSE' | 'MODIFY' | 'PENALIZE' | 'REWARD' | 'NEUTRAL';
+/**
+ * Consequence applied when an agent is PENALIZED.
+ * The governance engine blocks the action AND imposes a behavioral cost.
+ */
+interface Consequence {
+    /** Type of penalty */
+    type: 'freeze' | 'reduce_influence' | 'increase_risk' | 'cooldown' | 'custom';
+    /** Duration in rounds (for freeze/cooldown) */
+    rounds?: number;
+    /** Magnitude of effect (e.g., influence reduction percentage 0-1) */
+    magnitude?: number;
+    /** Human-readable description of what happens */
+    description: string;
+}
+/**
+ * Reward applied when an agent's action is REWARDED.
+ * The action proceeds AND the agent receives a behavioral boost.
+ */
+interface Reward {
+    /** Type of reward */
+    type: 'boost_influence' | 'priority' | 'faster_execution' | 'weight_increase' | 'custom';
+    /** Duration in rounds (for temporary boosts) */
+    rounds?: number;
+    /** Magnitude of effect (e.g., influence boost percentage 0-1) */
+    magnitude?: number;
+    /** Human-readable description of what happens */
+    description: string;
+}
+/**
+ * Tracks the behavioral state of an agent across governance evaluations.
+ * This is what makes governance a behavior-shaping system, not just a filter.
+ */
+interface AgentBehaviorState {
+    /** Agent/role identifier */
+    agentId: string;
+    /** Rounds remaining in cooldown (0 = active) */
+    cooldownRemaining: number;
+    /** Current influence multiplier (1.0 = normal) */
+    influence: number;
+    /** Accumulated reward multiplier (1.0 = normal) */
+    rewardMultiplier: number;
+    /** Total penalties received */
+    totalPenalties: number;
+    /** Total rewards received */
+    totalRewards: number;
+    /** History of consequences applied */
+    consequenceHistory: Array<{
+        ruleId: string;
+        consequence: Consequence;
+        appliedAt: number;
+    }>;
+    /** History of rewards applied */
+    rewardHistory: Array<{
+        ruleId: string;
+        reward: Reward;
+        appliedAt: number;
+    }>;
+}
+/**
+ * Tracks what an agent WANTED to do vs what governance MADE it do.
+ * This is the core of the Decision Flow visualization.
+ *
+ * The gap between intent and outcome = governance value.
+ */
+interface IntentRecord {
+    /** Original action the agent attempted */
+    originalIntent: string;
+    /** What actually happened after governance */
+    finalAction: string;
+    /** The rule that caused the interception */
+    ruleApplied?: string;
+    /** How the intent was transformed */
+    enforcement: GuardStatus;
+    /** If MODIFY, what the action was changed to */
+    modifiedTo?: string;
+    /** If PENALIZE, the consequence applied */
+    consequence?: Consequence;
+    /** If REWARD, the reward applied */
+    reward?: Reward;
+}
 /**
  * Evidence attached to every verdict for audit purposes.
  * Always present, regardless of trace mode.
@@ -561,6 +657,12 @@ interface GuardVerdict {
     ruleId?: string;
     /** Advisory warning (for ALLOW with warn-mode guards) */
     warning?: string;
+    /** Consequence applied (for PENALIZE verdicts) */
+    consequence?: Consequence;
+    /** Reward applied (for REWARD verdicts) */
+    reward?: Reward;
+    /** Intent tracking — what the agent wanted vs what happened */
+    intentRecord?: IntentRecord;
     /** Audit evidence — always present */
     evidence: VerdictEvidence;
     /** Evaluation trace — present when trace mode is enabled */
@@ -633,7 +735,7 @@ interface GuardCheck {
     category: 'structural' | 'operational' | 'advisory';
     enabled: boolean;
     matched: boolean;
-    enforcement: 'block' | 'pause' | 'warn';
+    enforcement: 'block' | 'pause' | 'warn' | 'modify' | 'penalize' | 'reward' | 'neutral';
     /** Which intent patterns matched (if any) */
     matchedPatterns: string[];
     /** Whether the guard was skipped due to role gating */
@@ -697,13 +799,23 @@ interface GuardEngineOptions {
      * Plans can only restrict, never expand.
      */
     plan?: PlanDefinition;
+    /**
+     * Agent behavior states — tracks cooldowns, influence, rewards per agent.
+     * The engine reads this to check if an agent is penalized (frozen).
+     * The caller owns mutation (applying consequences/rewards after verdict).
+     */
+    agentStates?: Map<string, AgentBehaviorState>;
 }
 declare const GUARD_EXIT_CODES: {
     readonly ALLOW: 0;
     readonly BLOCK: 1;
     readonly PAUSE: 2;
     readonly ERROR: 3;
+    readonly MODIFY: 4;
+    readonly PENALIZE: 5;
+    readonly REWARD: 6;
+    readonly NEUTRAL: 7;
 };
 type GuardExitCode = (typeof GUARD_EXIT_CODES)[keyof typeof GUARD_EXIT_CODES];
 
-export { type AdvanceResult as A, type EvaluationTrace as E, type GuardVerdict as G, type InvariantCheck as I, type KernelRuleCheck as K, type LevelCheck as L, type PlanDefinition as P, type RoleCheck as R, type StepEvidence as S, type ViabilityStatus as V, type WorldDefinition as W, type GuardEvent as a, type PlanProgress as b, type GuardEngineOptions as c, type PlanVerdict as d, type PlanCheck as e, GUARD_EXIT_CODES as f, type GuardCheck as g, type GuardExitCode as h, type GuardStatus as i, PLAN_EXIT_CODES as j, type PlanCompletionMode as k, type PlanConstraint as l, type PlanExitCode as m, type PlanStatus as n, type PlanStep as o, type PrecedenceResolution as p, type SafetyCheck as q, type VerdictEvidence as r };
+export { type AdvanceResult as A, type Consequence as C, type EvaluationTrace as E, type GuardEvent as G, type IntentRecord as I, type KernelRuleCheck as K, type LevelCheck as L, type PlanDefinition as P, type Reward as R, type StepEvidence as S, type ViabilityStatus as V, type WorldDefinition as W, type GuardVerdict as a, type GuardEngineOptions as b, type PlanProgress as c, type PlanVerdict as d, type PlanCheck as e, type AgentBehaviorState as f, type GuardStatus as g, GUARD_EXIT_CODES as h, type GuardCheck as i, type GuardExitCode as j, type InvariantCheck as k, PLAN_EXIT_CODES as l, type PlanCompletionMode as m, type PlanConstraint as n, type PlanExitCode as o, type PlanStatus as p, type PlanStep as q, type PrecedenceResolution as r, type RoleCheck as s, type SafetyCheck as t, type VerdictEvidence as u };

package/dist/{guard-contract-Cm91Kp4j.d.cts → guard-contract-C9_zKbzd.d.ts}

@@ -249,7 +249,7 @@ interface Guard {
     label: string;
     description: string;
     category: 'structural' | 'operational' | 'advisory';
-    enforcement: 'block' | 'pause' | 'warn';
+    enforcement: 'block' | 'pause' | 'warn' | 'modify' | 'penalize' | 'reward' | 'neutral';
     immutable: boolean;
     invariant_ref?: string;
     intent_patterns: string[];
@@ -261,8 +261,24 @@ interface Guard {
     player_modes?: {
         thinking?: 'annotate' | 'block' | 'ignore';
         experience?: 'simulate' | 'score' | 'ignore';
-        action?: 'block' | 'pause' | 'warn';
+        action?: 'block' | 'pause' | 'warn' | 'modify' | 'penalize' | 'reward' | 'neutral';
     };
+    /** Consequence to apply when enforcement is 'penalize' */
+    consequence?: {
+        type: 'freeze' | 'reduce_influence' | 'increase_risk' | 'cooldown' | 'custom';
+        rounds?: number;
+        magnitude?: number;
+        description: string;
+    };
+    /** Reward to apply when enforcement is 'reward' */
+    reward?: {
+        type: 'boost_influence' | 'priority' | 'faster_execution' | 'weight_increase' | 'custom';
+        rounds?: number;
+        magnitude?: number;
+        description: string;
+    };
+    /** For 'modify' enforcement: what the action should be changed to */
+    modify_to?: string;
 }
 interface IntentPattern {
     label: string;
@@ -521,7 +537,87 @@ interface GuardEvent {
     /** Environment context (e.g. "development", "production") */
     environment?: string;
 }
-type GuardStatus = 'ALLOW' | 'BLOCK' | 'PAUSE';
+type GuardStatus = 'ALLOW' | 'BLOCK' | 'PAUSE' | 'MODIFY' | 'PENALIZE' | 'REWARD' | 'NEUTRAL';
+/**
+ * Consequence applied when an agent is PENALIZED.
+ * The governance engine blocks the action AND imposes a behavioral cost.
+ */
+interface Consequence {
+    /** Type of penalty */
+    type: 'freeze' | 'reduce_influence' | 'increase_risk' | 'cooldown' | 'custom';
+    /** Duration in rounds (for freeze/cooldown) */
+    rounds?: number;
+    /** Magnitude of effect (e.g., influence reduction percentage 0-1) */
+    magnitude?: number;
+    /** Human-readable description of what happens */
+    description: string;
+}
+/**
+ * Reward applied when an agent's action is REWARDED.
+ * The action proceeds AND the agent receives a behavioral boost.
+ */
+interface Reward {
+    /** Type of reward */
+    type: 'boost_influence' | 'priority' | 'faster_execution' | 'weight_increase' | 'custom';
+    /** Duration in rounds (for temporary boosts) */
+    rounds?: number;
+    /** Magnitude of effect (e.g., influence boost percentage 0-1) */
+    magnitude?: number;
+    /** Human-readable description of what happens */
+    description: string;
+}
+/**
+ * Tracks the behavioral state of an agent across governance evaluations.
+ * This is what makes governance a behavior-shaping system, not just a filter.
+ */
+interface AgentBehaviorState {
+    /** Agent/role identifier */
+    agentId: string;
+    /** Rounds remaining in cooldown (0 = active) */
+    cooldownRemaining: number;
+    /** Current influence multiplier (1.0 = normal) */
+    influence: number;
+    /** Accumulated reward multiplier (1.0 = normal) */
+    rewardMultiplier: number;
+    /** Total penalties received */
+    totalPenalties: number;
+    /** Total rewards received */
+    totalRewards: number;
+    /** History of consequences applied */
+    consequenceHistory: Array<{
+        ruleId: string;
+        consequence: Consequence;
+        appliedAt: number;
+    }>;
+    /** History of rewards applied */
+    rewardHistory: Array<{
+        ruleId: string;
+        reward: Reward;
+        appliedAt: number;
+    }>;
+}
+/**
+ * Tracks what an agent WANTED to do vs what governance MADE it do.
+ * This is the core of the Decision Flow visualization.
+ *
+ * The gap between intent and outcome = governance value.
+ */
+interface IntentRecord {
+    /** Original action the agent attempted */
+    originalIntent: string;
+    /** What actually happened after governance */
+    finalAction: string;
+    /** The rule that caused the interception */
+    ruleApplied?: string;
+    /** How the intent was transformed */
+    enforcement: GuardStatus;
+    /** If MODIFY, what the action was changed to */
+    modifiedTo?: string;
+    /** If PENALIZE, the consequence applied */
+    consequence?: Consequence;
+    /** If REWARD, the reward applied */
+    reward?: Reward;
+}
 /**
  * Evidence attached to every verdict for audit purposes.
  * Always present, regardless of trace mode.
@@ -561,6 +657,12 @@ interface GuardVerdict {
     ruleId?: string;
     /** Advisory warning (for ALLOW with warn-mode guards) */
     warning?: string;
+    /** Consequence applied (for PENALIZE verdicts) */
+    consequence?: Consequence;
+    /** Reward applied (for REWARD verdicts) */
+    reward?: Reward;
+    /** Intent tracking — what the agent wanted vs what happened */
+    intentRecord?: IntentRecord;
     /** Audit evidence — always present */
     evidence: VerdictEvidence;
     /** Evaluation trace — present when trace mode is enabled */
@@ -633,7 +735,7 @@ interface GuardCheck {
     category: 'structural' | 'operational' | 'advisory';
     enabled: boolean;
     matched: boolean;
-    enforcement: 'block' | 'pause' | 'warn';
+    enforcement: 'block' | 'pause' | 'warn' | 'modify' | 'penalize' | 'reward' | 'neutral';
     /** Which intent patterns matched (if any) */
     matchedPatterns: string[];
     /** Whether the guard was skipped due to role gating */
@@ -697,13 +799,23 @@ interface GuardEngineOptions {
      * Plans can only restrict, never expand.
      */
     plan?: PlanDefinition;
+    /**
+     * Agent behavior states — tracks cooldowns, influence, rewards per agent.
+     * The engine reads this to check if an agent is penalized (frozen).
+     * The caller owns mutation (applying consequences/rewards after verdict).
+     */
+    agentStates?: Map<string, AgentBehaviorState>;
 }
 declare const GUARD_EXIT_CODES: {
     readonly ALLOW: 0;
     readonly BLOCK: 1;
     readonly PAUSE: 2;
     readonly ERROR: 3;
+    readonly MODIFY: 4;
+    readonly PENALIZE: 5;
+    readonly REWARD: 6;
+    readonly NEUTRAL: 7;
 };
 type GuardExitCode = (typeof GUARD_EXIT_CODES)[keyof typeof GUARD_EXIT_CODES];
 
-export { type AdvanceResult as A, type EvaluationTrace as E, type GuardVerdict as G, type InvariantCheck as I, type KernelRuleCheck as K, type LevelCheck as L, type PlanDefinition as P, type RoleCheck as R, type StepEvidence as S, type ViabilityStatus as V, type WorldDefinition as W, type GuardEvent as a, type PlanProgress as b, type GuardEngineOptions as c, type PlanVerdict as d, type PlanCheck as e, GUARD_EXIT_CODES as f, type GuardCheck as g, type GuardExitCode as h, type GuardStatus as i, PLAN_EXIT_CODES as j, type PlanCompletionMode as k, type PlanConstraint as l, type PlanExitCode as m, type PlanStatus as n, type PlanStep as o, type PrecedenceResolution as p, type SafetyCheck as q, type VerdictEvidence as r };
+export { type AdvanceResult as A, type Consequence as C, type EvaluationTrace as E, type GuardEvent as G, type IntentRecord as I, type KernelRuleCheck as K, type LevelCheck as L, type PlanDefinition as P, type Reward as R, type StepEvidence as S, type ViabilityStatus as V, type WorldDefinition as W, type GuardVerdict as a, type GuardEngineOptions as b, type PlanProgress as c, type PlanVerdict as d, type PlanCheck as e, type AgentBehaviorState as f, type GuardStatus as g, GUARD_EXIT_CODES as h, type GuardCheck as i, type GuardExitCode as j, type InvariantCheck as k, PLAN_EXIT_CODES as l, type PlanCompletionMode as m, type PlanConstraint as n, type PlanExitCode as o, type PlanStatus as p, type PlanStep as q, type PrecedenceResolution as r, type RoleCheck as s, type SafetyCheck as t, type VerdictEvidence as u };

package/dist/{guard-engine-JLTUARGU.js → guard-engine-QFMIBWJY.js}

@@ -1,8 +1,8 @@
 import {
   evaluateGuard,
   eventToAllowlistKey
-} from "./chunk-4JRYGIO7.js";
-import "./chunk-4QXB6PEO.js";
+} from "./chunk-IZSO75NZ.js";
+import "./chunk-QLPTHTVB.js";
 import "./chunk-YZFATT7X.js";
 export {
   evaluateGuard,