@neuroverseos/governance 0.2.1 → 0.2.3

package/dist/{guard-contract-D-2LQInm.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;
@@ -340,6 +356,38 @@ interface PlanConstraint {
     /** Pattern that activates this constraint. */
     trigger?: string;
 }
+/**
+ * How step completion is determined:
+ *   - 'trust'    — caller asserts completion, plan advances (default)
+ *   - 'verified' — steps with a `verify` field require evidence to advance;
+ *                   steps without `verify` still advance on trust
+ */
+type PlanCompletionMode = 'trust' | 'verified';
+/**
+ * Evidence provided when advancing a step in verified mode.
+ * The verifier checks that evidence.type matches step.verify.
+ */
+interface StepEvidence {
+    /** Evidence type — must match the step's `verify` field. */
+    type: string;
+    /** Proof payload (URL, hash, output snippet, etc.). */
+    proof: string;
+    /** When the evidence was produced. */
+    timestamp?: string;
+}
+/**
+ * Result of attempting to advance a step.
+ */
+interface AdvanceResult {
+    /** Whether the step was successfully advanced. */
+    success: boolean;
+    /** Updated plan (if success). */
+    plan?: PlanDefinition;
+    /** Why advancement failed (if !success). */
+    reason?: string;
+    /** The evidence that was accepted (if verified mode). */
+    evidence?: StepEvidence;
+}
 interface PlanDefinition {
     /** Unique plan identifier. */
     plan_id: string;
@@ -347,6 +395,12 @@ interface PlanDefinition {
     objective: string;
     /** Whether steps must run in order. */
     sequential: boolean;
+    /**
+     * How step completion is determined.
+     *   - 'trust' (default) — caller asserts "done", plan advances
+     *   - 'verified' — steps with `verify` require evidence to advance
+     */
+    completion: PlanCompletionMode;
     /** The steps in this plan. */
     steps: PlanStep[];
     /** Constraints that apply to this plan. */
@@ -483,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.
@@ -523,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 */
@@ -595,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 */
@@ -659,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 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 SafetyCheck 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 PlanConstraint as k, type PlanExitCode as l, type PlanStatus as m, type PlanStep as n, type PrecedenceResolution as o, type VerdictEvidence as p };
+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-D7X4CVAE.js → guard-engine-QFMIBWJY.js}

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

package/dist/{impact-BWULZ5RP.js → impact-UB6DXKSX.js}

@@ -1,12 +1,12 @@
 import {
   generateImpactReport,
   renderImpactReport
-} from "./chunk-ADV7Q2LJ.js";
+} from "./chunk-KTFTTLTP.js";
 import {
   readAuditLog
-} from "./chunk-2JQJ5U5X.js";
-import "./chunk-PQBJBVSW.js";
-import "./chunk-P74Y66ZV.js";
+} from "./chunk-REXY4LUL.js";
+import "./chunk-IZSO75NZ.js";
+import "./chunk-QLPTHTVB.js";
 import "./chunk-YZFATT7X.js";
 
 // src/cli/impact.ts

package/dist/{improve-GPUBKTEA.js → improve-XZA57GER.js}

@@ -1,9 +1,12 @@
+import {
+  resolveWorldPath
+} from "./chunk-BQZMOEML.js";
 import {
   improveWorld,
   renderImproveText
-} from "./chunk-GR6DGCZ2.js";
-import "./chunk-FYS2CBUW.js";
+} from "./chunk-BMOXICAB.js";
 import "./chunk-7P3S7MAY.js";
+import "./chunk-FYS2CBUW.js";
 import {
   loadWorld
 } from "./chunk-JZPQGIKR.js";
@@ -26,28 +29,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);