@neuroverseos/governance 0.3.1 → 0.3.3

package/dist/index.d.ts

@@ -0,0 +1,2195 @@
+import { G as GuardEvent, W as WorldDefinition, b as GuardEngineOptions, a as GuardVerdict, P as PlanDefinition, S as StepEvidence, A as AdvanceResult, d as PlanVerdict, e as PlanCheck, c as PlanProgress, f as AgentBehaviorState, g as GuardStatus, C as Consequence, R as Reward, h as Guard, I as Invariant, i as Rule, V as ViabilityStatus } from './guard-contract-DqFcTScd.js';
+export { E as EvaluationTrace, j as GUARD_EXIT_CODES, k as GuardCheck, l as GuardExitCode, m as IntentRecord, n as InvariantCheck, K as KernelRuleCheck, L as LevelCheck, o as PLAN_EXIT_CODES, p as PlanCompletionMode, q as PlanConstraint, r as PlanExitCode, s as PlanStatus, t as PlanStep, u as PrecedenceResolution, v as RoleCheck, w as SafetyCheck, x as VerdictEvidence } from './guard-contract-DqFcTScd.js';
+
+/**
+ * Guard Engine — Deterministic Governance Evaluator
+ *
+ * Pure function: (event, world, options) → verdict
+ *
+ * Evaluates a GuardEvent against a loaded WorldDefinition and produces
+ * a GuardVerdict with evidence and optional evaluation trace.
+ *
+ * Evaluation chain (first-match-wins on BLOCK/PAUSE):
+ *   1.   Safety checks (prompt injection, scope escape)    → PAUSE
+ *   1.5  Plan enforcement (task scope)                     → BLOCK/PAUSE
+ *   2.   Role-specific rules (cannotDo, requiresApproval)  → BLOCK/PAUSE
+ *   3.   Declarative guards (guards.json)                  → BLOCK/PAUSE/WARN
+ *   4.   Kernel rules (kernel.json forbidden patterns)     → BLOCK
+ *   5.   Level constraints (basic/standard/strict)         → PAUSE
+ *   6.   Default                                           → ALLOW
+ *
+ * Invariant checks run unconditionally and are recorded in evidence
+ * but do not produce verdicts — they measure world health.
+ *
+ * INVARIANTS:
+ *   - Deterministic: same event + same world → same verdict.
+ *   - Zero network calls. Zero LLM calls. Zero async.
+ *   - Every check is recorded in the trace, not just the decider.
+ *   - No hidden logic. Everything is in the world file or declared here.
+ */
+
+declare function evaluateGuard(event: GuardEvent, world: WorldDefinition, options?: GuardEngineOptions): GuardVerdict;
+/**
+ * Build a normalized allowlist key from a GuardEvent.
+ *
+ * Format: `tool::intent` (both lowercased, intent trimmed).
+ * Tool defaults to '*' when absent.
+ *
+ * Callers use this to:
+ *   1. Add keys to the allowlist set (on user "allow-always" decision)
+ *   2. The engine uses it to check membership before evaluation
+ *
+ * The key is opaque — callers should always use this function
+ * rather than constructing keys manually.
+ */
+declare function eventToAllowlistKey(event: GuardEvent): string;
+
+/**
+ * Plan Parser — Deterministic Markdown-to-PlanDefinition Parser
+ *
+ * Parses a simple markdown format into a PlanDefinition.
+ * No AI needed. This is pure parsing like bootstrap-parser.
+ *
+ * Supported syntax:
+ *   - YAML frontmatter: plan_id, objective, sequential, completion, budget, expires, world
+ *   - # Steps section: each `- ` line becomes a PlanStep
+ *   - # Constraints section: each `- ` line becomes a PlanConstraint
+ *   - Step dependencies: (after: step_id)
+ *   - Tool restrictions: [tools: http, shell]
+ *   - Tags: [tag: deploy, marketing]
+ *   - Verification: [verify: condition_name]
+ *   - Approval constraints: [type: approval]
+ */
+
+interface PlanParseResult {
+    success: boolean;
+    plan?: PlanDefinition;
+    errors: string[];
+}
+/**
+ * Parse a plan markdown string into a PlanDefinition.
+ *
+ * Format:
+ * ```markdown
+ * ---
+ * plan_id: my_plan
+ * objective: Do the thing
+ * sequential: false
+ * ---
+ *
+ * # Steps
+ * - Step one [tag: deploy]
+ * - Step two (after: step_one) [verify: check_name]
+ *
+ * # Constraints
+ * - No spending above $500
+ * - External comms require review [type: approval]
+ * ```
+ */
+declare function parsePlanMarkdown(markdown: string): PlanParseResult;
+
+/**
+ * Plan Engine — Deterministic Plan Enforcement Evaluator
+ *
+ * Pure function: (event, plan) → PlanVerdict
+ *
+ * Evaluates a GuardEvent against a PlanDefinition to determine
+ * whether the action is on-plan, off-plan, or violates constraints.
+ *
+ * Uses two-tier matching:
+ *   Tier 1: Keyword + tag matching (fast, deterministic)
+ *   Tier 2: Intent similarity scoring (precomputed vectors, no LLM)
+ *
+ * INVARIANTS:
+ *   - Deterministic: same event + same plan → same verdict.
+ *   - No LLM calls. No network calls.
+ *   - Plans can only restrict, never expand.
+ *   - OFF_PLAN always includes closest step for self-correction.
+ */
+
+/**
+ * Get the current progress of a plan.
+ */
+declare function getPlanProgress(plan: PlanDefinition): PlanProgress;
+/**
+ * Mark a step as completed and return a new plan.
+ * Does not mutate the original plan.
+ *
+ * Behavior depends on the plan's completion mode:
+ *
+ *   completion: 'trust' (default)
+ *     Caller says "done", step advances. No evidence needed.
+ *
+ *   completion: 'verified'
+ *     Steps with a `verify` field require evidence to advance.
+ *     The evidence type must match the step's verify field.
+ *     Steps without `verify` still advance on trust.
+ *
+ * @param plan     - The current plan (not mutated)
+ * @param stepId   - Which step to advance
+ * @param evidence - Proof of completion (required in verified mode for steps with verify)
+ * @returns AdvanceResult with success flag and updated plan or reason
+ */
+declare function advancePlan(plan: PlanDefinition, stepId: string, evidence?: StepEvidence): AdvanceResult;
+/**
+ * Evaluate an event against a plan.
+ *
+ * Returns a PlanVerdict indicating whether the action is on-plan,
+ * off-plan, violates constraints, or the plan is complete.
+ */
+declare function evaluatePlan(event: GuardEvent, plan: PlanDefinition): PlanVerdict;
+/**
+ * Build a PlanCheck for inclusion in the guard engine's EvaluationTrace.
+ */
+declare function buildPlanCheck(event: GuardEvent, plan: PlanDefinition, verdict: PlanVerdict): PlanCheck;
+
+/**
+ * Model Adapter — Minimal LLM Connection Layer
+ *
+ * Connects to any OpenAI-compatible API (OpenAI, Anthropic, Ollama, etc.)
+ * using Node's built-in fetch. Zero dependencies.
+ *
+ * The adapter does exactly two things:
+ *   1. Send messages to the model
+ *   2. Receive responses (text + tool calls)
+ *
+ * No orchestration, no memory management, no retries.
+ * The session manager handles all of that.
+ */
+interface ModelConfig {
+    /** API base URL (e.g., "https://api.openai.com/v1") */
+    baseUrl: string;
+    /** API key for authentication */
+    apiKey: string;
+    /** Model identifier (e.g., "gpt-4o", "claude-sonnet-4-20250514") */
+    model: string;
+    /** System prompt prepended to all conversations */
+    systemPrompt?: string;
+    /** Max tokens for response. Default: 4096. */
+    maxTokens?: number;
+}
+interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | null;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+}
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ModelResponse {
+    content: string | null;
+    toolCalls: ToolCall[];
+    finishReason: string;
+}
+declare class ModelAdapter {
+    private config;
+    private messages;
+    private tools;
+    constructor(config: ModelConfig, tools?: ToolDefinition[]);
+    /**
+     * Send a user message and get the model's response.
+     */
+    chat(userMessage: string): Promise<ModelResponse>;
+    /**
+     * Send a tool result back to the model and get the next response.
+     */
+    sendToolResult(toolCallId: string, result: string): Promise<ModelResponse>;
+    /**
+     * Send a governance block message as a tool result.
+     */
+    sendBlockedResult(toolCallId: string, reason: string): Promise<ModelResponse>;
+    /**
+     * Call the model API and parse the response.
+     */
+    private complete;
+    /** Get current message count (for context tracking). */
+    get messageCount(): number;
+}
+interface ProviderPreset {
+    baseUrl: string;
+    defaultModel: string;
+    envVar: string;
+}
+declare const PROVIDERS: Record<string, ProviderPreset>;
+/**
+ * Resolve a provider name to a ModelConfig.
+ * Reads API key from environment variable.
+ */
+declare function resolveProvider(provider: string, overrides?: Partial<ModelConfig>): ModelConfig;
+
+/**
+ * Session Manager — Governed Runtime Session
+ *
+ * Orchestrates a governed AI session:
+ *   1. Load world + plan
+ *   2. Connect to model
+ *   3. Intercept tool calls
+ *   4. Evaluate with guard engine
+ *   5. Execute or block
+ *   6. Track plan progress
+ *
+ * The session manager is thin orchestration, not a framework.
+ * All intelligence lives in the guard engine and plan engine.
+ */
+
+interface SessionConfig {
+    /** Path to world directory. */
+    worldPath?: string;
+    /** Pre-loaded world definition (alternative to worldPath). */
+    world?: WorldDefinition;
+    /** Plan definition (pre-loaded). */
+    plan?: PlanDefinition;
+    /** Enforcement level override. */
+    level?: 'basic' | 'standard' | 'strict';
+    /** Include trace in verdicts. */
+    trace?: boolean;
+    /** Called when a verdict is produced. */
+    onVerdict?: (verdict: GuardVerdict, event: GuardEvent) => void;
+    /** Called when plan progress changes. */
+    onPlanProgress?: (progress: PlanProgress) => void;
+    /** Called when the plan is complete. */
+    onPlanComplete?: () => void;
+    /** Called when a tool is executed successfully. */
+    onToolResult?: (toolName: string, result: string) => void;
+    /** Tool executor — runs the actual tool. */
+    toolExecutor?: (name: string, args: Record<string, unknown>) => Promise<string>;
+}
+interface SessionState {
+    /** Whether the session is active. */
+    active: boolean;
+    /** Loaded world. */
+    world: WorldDefinition;
+    /** Active plan (mutable as steps complete). */
+    plan?: PlanDefinition;
+    /** Current plan progress. */
+    progress?: PlanProgress;
+    /** Total actions evaluated. */
+    actionsEvaluated: number;
+    /** Total actions allowed. */
+    actionsAllowed: number;
+    /** Total actions blocked. */
+    actionsBlocked: number;
+    /** Total actions paused. */
+    actionsPaused: number;
+    /** Total actions modified. */
+    actionsModified: number;
+    /** Total actions penalized. */
+    actionsPenalized: number;
+    /** Total actions rewarded. */
+    actionsRewarded: number;
+    /** Agent behavior states — tracks cooldowns, influence, rewards per agent. */
+    agentStates: Map<string, AgentBehaviorState>;
+}
+declare class SessionManager {
+    private config;
+    private state;
+    private engineOptions;
+    private executor;
+    constructor(config: SessionConfig);
+    /**
+     * Initialize the session — load world from disk if needed.
+     */
+    start(): Promise<SessionState>;
+    /**
+     * Evaluate a single event against governance.
+     * Returns the verdict without executing anything.
+     */
+    evaluate(event: GuardEvent): GuardVerdict;
+    /**
+     * Advance all agent states by one round.
+     * Call this at the end of each simulation round to decrement cooldowns.
+     */
+    tickRound(): void;
+    /**
+     * Get the behavior state for a specific agent.
+     */
+    getAgentState(agentId: string): AgentBehaviorState | undefined;
+    /**
+     * Evaluate and execute a tool call.
+     * Returns the execution result or block reason.
+     */
+    executeToolCall(toolCall: ToolCall): Promise<{
+        allowed: boolean;
+        verdict: GuardVerdict;
+        result?: string;
+    }>;
+    /**
+     * Process a model response — evaluate and execute all tool calls.
+     * Returns results for each tool call.
+     */
+    processModelResponse(response: ModelResponse, model: ModelAdapter): Promise<ModelResponse>;
+    /** Get current session state. */
+    getState(): SessionState;
+    /** Stop the session. */
+    stop(): SessionState;
+}
+/**
+ * Run in pipe mode — read JSON lines from stdin, evaluate each,
+ * write verdicts to stdout. Works with any language or framework.
+ *
+ * Usage:
+ *   my_agent | neuroverse run --pipe --world ./world/ --plan plan.json
+ *
+ * Each line of stdin should be a GuardEvent JSON.
+ * Each line of stdout will be a GuardVerdict JSON.
+ */
+declare function runPipeMode(config: SessionConfig): Promise<void>;
+/**
+ * Run an interactive governed chat session.
+ *
+ * Usage:
+ *   neuroverse run --world ./world/ --plan plan.json --provider openai
+ */
+declare function runInteractiveMode(config: SessionConfig, model: ModelAdapter): Promise<void>;
+
+/**
+ * NeuroVerse MCP Server — Governance as an MCP Tool Provider
+ *
+ * Implements the Model Context Protocol (MCP) over stdio.
+ * Any MCP-compatible client (Claude Desktop, Cursor, etc.) can
+ * connect to this server and get governed tool access.
+ *
+ * Architecture:
+ *   MCP Client (Claude, Cursor, etc.)
+ *     ↓ stdio (JSON-RPC)
+ *   NeuroVerse MCP Server
+ *     ↓ evaluateGuard()
+ *   Tool Execution (shell, http, file, etc.)
+ *
+ * The server exposes governance-wrapped tools. Every tool call
+ * passes through the guard engine before execution. Blocked
+ * actions return the governance reason to the model.
+ *
+ * MCP Protocol: JSON-RPC 2.0 over stdio
+ *   - initialize → capabilities
+ *   - tools/list → available tools
+ *   - tools/call → evaluate + execute
+ */
+
+interface McpServerConfig {
+    /** Path to world directory. */
+    worldPath?: string;
+    /** Pre-loaded world. */
+    world?: WorldDefinition;
+    /** Active plan. */
+    plan?: PlanDefinition;
+    /** Path to plan.json (loaded on start). */
+    planPath?: string;
+    /** Enforcement level. */
+    level?: 'basic' | 'standard' | 'strict';
+    /** Include trace in verdicts. */
+    trace?: boolean;
+    /** Enable shell tool. Default: true. */
+    enableShell?: boolean;
+    /** Enable file tools. Default: true. */
+    enableFiles?: boolean;
+    /** Enable HTTP tool. Default: true. */
+    enableHttp?: boolean;
+    /** Working directory for file/shell operations. */
+    workingDir?: string;
+}
+declare class McpGovernanceServer {
+    private world;
+    private plan?;
+    private config;
+    private engineOptions;
+    private initialized;
+    private actionsEvaluated;
+    private actionsAllowed;
+    private actionsBlocked;
+    constructor(config: McpServerConfig);
+    /**
+     * Start the MCP server — reads JSON-RPC from stdin, writes to stdout.
+     */
+    start(): Promise<void>;
+    private handleRawLine;
+    private send;
+    private sendResult;
+    private sendError;
+    private handleRequest;
+    private handleNotification;
+    private handleInitialize;
+    private handleToolsList;
+    private handleToolsCall;
+    private executeTool;
+    private buildEvent;
+    private executeActualTool;
+    private toolGovernanceCheck;
+    private toolPlanStatus;
+    private toolPlanAdvance;
+}
+
+/**
+ * Audit Logger — Runtime Governance Telemetry
+ *
+ * Records every action evaluated by the governance engine.
+ * Provides the governance paper trail: what happened, why, and when.
+ *
+ * Architecture:
+ *   - AuditEvent is the atomic record (one per evaluateGuard call)
+ *   - AuditLogger is the pluggable interface (file, database, stream)
+ *   - FileAuditLogger is the built-in file-based implementation
+ *   - createGovernanceEngine wraps evaluateGuard with automatic logging
+ *
+ * INVARIANTS:
+ *   - Logging never blocks or fails the governance decision
+ *   - Every AuditEvent includes the full verdict + evidence
+ *   - Events are append-only (immutable log)
+ */
+
+/**
+ * A single governance evaluation record.
+ * One of these is produced for every call to evaluateGuard.
+ */
+interface AuditEvent {
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** World identity */
+    worldId: string;
+    worldName: string;
+    worldVersion: string;
+    /** The action that was evaluated */
+    intent: string;
+    tool?: string;
+    scope?: string;
+    actor?: string;
+    direction?: 'input' | 'output';
+    /** The governance decision */
+    decision: 'ALLOW' | 'BLOCK' | 'PAUSE' | 'MODIFY' | 'PENALIZE' | 'REWARD' | 'NEUTRAL';
+    reason?: string;
+    ruleId?: string;
+    warning?: string;
+    /** Consequence applied (for PENALIZE decisions) */
+    consequence?: {
+        type: string;
+        rounds?: number;
+        magnitude?: number;
+        description: string;
+    };
+    /** Reward applied (for REWARD decisions) */
+    reward?: {
+        type: string;
+        rounds?: number;
+        magnitude?: number;
+        description: string;
+    };
+    /** Intent tracking — original vs final action */
+    originalIntent?: string;
+    finalAction?: string;
+    /** Which rules/guards matched */
+    guardsMatched: string[];
+    rulesMatched: string[];
+    /** Invariant health */
+    invariantsSatisfied: number;
+    invariantsTotal: number;
+    /** Enforcement level used */
+    enforcementLevel: string;
+    /** Evaluation duration in milliseconds (if trace was enabled) */
+    durationMs?: number;
+    /** Full event args (optional, for detailed audit) */
+    args?: Record<string, unknown>;
+}
+/**
+ * Summary of governance activity over a set of audit events.
+ */
+interface AuditSummary {
+    totalActions: number;
+    allowed: number;
+    blocked: number;
+    paused: number;
+    modified: number;
+    penalized: number;
+    rewarded: number;
+    neutral: number;
+    /** Unique actors seen */
+    actors: string[];
+    /** Actions grouped by intent */
+    topIntents: {
+        intent: string;
+        count: number;
+        blocked: number;
+        paused: number;
+        penalized: number;
+        rewarded: number;
+    }[];
+    /** Most frequently triggered rules */
+    topRules: {
+        ruleId: string;
+        count: number;
+    }[];
+    /** Time range */
+    firstEvent: string;
+    lastEvent: string;
+    /** Behavioral economy summary */
+    behavioralEconomy: {
+        totalPenalties: number;
+        totalRewards: number;
+        netPressure: number;
+        redirectionRate: number;
+    };
+}
+/**
+ * Pluggable audit logger interface.
+ * Implement this to send audit events to any destination.
+ */
+interface AuditLogger {
+    /** Append an audit event. Must not throw. */
+    log(event: AuditEvent): void | Promise<void>;
+    /** Flush any buffered events. */
+    flush?(): void | Promise<void>;
+}
+/**
+ * Append-only file logger using newline-delimited JSON (NDJSON).
+ * Each line is a self-contained JSON audit event.
+ *
+ * Log file location defaults to .neuroverse/audit.ndjson
+ */
+declare class FileAuditLogger implements AuditLogger {
+    private logPath;
+    private buffer;
+    private flushTimer;
+    private flushIntervalMs;
+    constructor(logPath: string, options?: {
+        flushIntervalMs?: number;
+    });
+    log(event: AuditEvent): void;
+    flush(): Promise<void>;
+}
+/**
+ * Simple logger that writes to stderr. Useful for development.
+ */
+declare class ConsoleAuditLogger implements AuditLogger {
+    log(event: AuditEvent): void;
+}
+/**
+ * Sends events to multiple loggers. Useful for file + console, file + webhook, etc.
+ */
+declare class CompositeAuditLogger implements AuditLogger {
+    private loggers;
+    constructor(...loggers: AuditLogger[]);
+    log(event: AuditEvent): void;
+    flush(): Promise<void>;
+}
+/**
+ * Convert a GuardEvent + GuardVerdict into an AuditEvent.
+ */
+declare function verdictToAuditEvent(event: GuardEvent, verdict: GuardVerdict): AuditEvent;
+interface GovernanceEngineOptions extends GuardEngineOptions {
+    /** Audit logger instance. If provided, every evaluation is logged. */
+    auditLogger?: AuditLogger;
+    /** Include args in audit events. Default: false (privacy). */
+    auditArgs?: boolean;
+}
+/**
+ * Create a governed evaluation function that wraps evaluateGuard
+ * with automatic audit logging.
+ *
+ * Usage:
+ *   const engine = createGovernanceEngine(world, {
+ *     auditLogger: new FileAuditLogger('.neuroverse/audit.ndjson'),
+ *   });
+ *
+ *   const verdict = engine.evaluate(event);
+ */
+declare function createGovernanceEngine(world: WorldDefinition, options?: GovernanceEngineOptions): {
+    /**
+     * Evaluate a governance event and log the result.
+     */
+    evaluate(event: GuardEvent): GuardVerdict;
+    /** Flush the audit logger. */
+    flush(): Promise<void>;
+    /** The underlying world definition. */
+    world: WorldDefinition;
+};
+/**
+ * Read audit events from an NDJSON log file.
+ *
+ * @param logPath - Path to the audit log file
+ * @param filter - Optional filter function
+ * @returns Array of matching audit events
+ */
+declare function readAuditLog(logPath: string, filter?: (event: AuditEvent) => boolean): Promise<AuditEvent[]>;
+/**
+ * Summarize a set of audit events.
+ */
+declare function summarizeAuditEvents(events: AuditEvent[]): AuditSummary;
+
+/**
+ * Verdict Formatter — Human-Readable Verdict Output
+ *
+ * Converts a GuardVerdict into a consistent, human-readable string.
+ * Used by adapters, CLIs, and UIs to display governance decisions.
+ *
+ * Design:
+ *   - One function, one concern: verdict → string
+ *   - No side effects, no I/O
+ *   - Adapters call this so every integration has consistent messaging
+ */
+
+interface FormatVerdictOptions {
+    /** Include rule/guard ID. Default: true. */
+    showRuleId?: boolean;
+    /** Include evidence summary. Default: false. */
+    showEvidence?: boolean;
+    /** Include warning if present. Default: true. */
+    showWarning?: boolean;
+    /** Use ANSI colors in output. Default: false. */
+    color?: boolean;
+    /** Compact single-line format. Default: false. */
+    compact?: boolean;
+}
+/**
+ * Format a GuardVerdict as a human-readable string.
+ *
+ * Examples:
+ *   formatVerdict(verdict)
+ *   // "BLOCKED\n  Rule: margin_floor\n  Reason: margin ratio below 10%"
+ *
+ *   formatVerdict(verdict, { compact: true })
+ *   // "BLOCKED — margin_floor: margin ratio below 10%"
+ *
+ *   formatVerdict(verdict, { color: true })
+ *   // Same but with ANSI colors
+ */
+declare function formatVerdict(verdict: GuardVerdict, options?: FormatVerdictOptions): string;
+/**
+ * Format a verdict as a short one-line status message.
+ * Useful for logging, status bars, and notifications.
+ *
+ * Example: "BLOCKED: margin_floor — margin ratio below 10%"
+ */
+declare function formatVerdictOneLine(verdict: GuardVerdict): string;
+
+/**
+ * Governance Impact Report — Counterfactual Audit
+ *
+ * Answers: "What would have happened if governance did not exist?"
+ *
+ * This is the killer enterprise feature. It doesn't just log what happened —
+ * it proves the value of governance by showing what it prevented.
+ *
+ * Architecture:
+ *   - Reads audit events (from FileAuditLogger NDJSON)
+ *   - Classifies blocked/paused actions by risk category
+ *   - Produces an ImpactReport with aggregated prevention metrics
+ *   - CLI renders as human-readable or JSON
+ *
+ * INVARIANTS:
+ *   - No speculation — only reports on actual evaluated actions
+ *   - Risk categories derived from world rules, not invented
+ *   - All numbers are exact counts from the audit log
+ */
+
+/**
+ * A counterfactual governance impact report.
+ */
+interface ImpactReport {
+    /** Report metadata */
+    generatedAt: string;
+    periodStart: string;
+    periodEnd: string;
+    worldName: string;
+    /** High-level stats */
+    totalEvaluations: number;
+    totalBlocked: number;
+    totalPaused: number;
+    totalAllowed: number;
+    totalModified: number;
+    totalPenalized: number;
+    totalRewarded: number;
+    totalNeutral: number;
+    /** Prevention rate: (blocked + paused + modified + penalized) / total */
+    preventionRate: number;
+    /** Redirection rate: everything not ALLOW/NEUTRAL */
+    redirectionRate: number;
+    /** Blocked actions grouped by category */
+    preventedByCategory: PreventionCategory[];
+    /** Top prevented intents */
+    topPreventedIntents: {
+        intent: string;
+        count: number;
+        topRule: string;
+    }[];
+    /** Actors with most blocked actions (potential policy violations) */
+    hotActors: {
+        actor: string;
+        blocked: number;
+        paused: number;
+        total: number;
+    }[];
+    /** Rules that triggered most often */
+    mostActiveRules: {
+        ruleId: string;
+        blockCount: number;
+        pauseCount: number;
+    }[];
+    /** Hourly activity pattern (governance load) */
+    hourlyDistribution: {
+        hour: number;
+        total: number;
+        blocked: number;
+    }[];
+    /** Repeat offenders: actions attempted more than once after being blocked */
+    repeatViolations: {
+        intent: string;
+        actor: string;
+        attempts: number;
+        firstSeen: string;
+        lastSeen: string;
+    }[];
+}
+interface PreventionCategory {
+    category: string;
+    count: number;
+    /** Example intents in this category */
+    examples: string[];
+}
+/**
+ * Generate a governance impact report from audit events.
+ */
+declare function generateImpactReport(events: AuditEvent[]): ImpactReport;
+/**
+ * Render an impact report as human-readable text.
+ */
+declare function renderImpactReport(report: ImpactReport): string;
+/**
+ * Generate an impact report directly from an audit log file.
+ */
+declare function generateImpactReportFromFile(logPath: string): Promise<ImpactReport>;
+
+/**
+ * Decision Flow Engine — Intent → Rule → Outcome Visualization
+ *
+ * This is the core of the behavioral governance visualization.
+ * It transforms audit events into a flow structure that shows:
+ *
+ *   LEFT (Intent Pool)    →    CENTER (Rules)    →    RIGHT (Outcome Pool)
+ *   What agents wanted          What intercepted        What actually happened
+ *
+ * The gap between intent and outcome = governance value.
+ *
+ * Key metric: "X% of agent intent was redirected by governance"
+ *
+ * INVARIANTS:
+ *   - Pure function: audit events in, flow structure out.
+ *   - No speculation — only reports on actual evaluated actions.
+ *   - Every flow path is traceable to a specific audit event.
+ */
+
+/**
+ * A cluster of agents with the same intent.
+ */
+interface IntentCluster {
+    /** The original intent (e.g., "sell", "publish", "attack") */
+    intent: string;
+    /** Number of agents with this intent */
+    agentCount: number;
+    /** Intensity score (0-1) based on volume and risk */
+    intensity: number;
+    /** Individual agent IDs in this cluster */
+    agents: string[];
+}
+/**
+ * A rule that intercepted actions in the flow.
+ */
+interface RuleObstacle {
+    /** Rule/guard ID */
+    ruleId: string;
+    /** Human-readable label */
+    label: string;
+    /** How many actions this rule intercepted */
+    interceptCount: number;
+    /** Breakdown by enforcement type */
+    enforcements: {
+        blocked: number;
+        modified: number;
+        penalized: number;
+        paused: number;
+        rewarded: number;
+    };
+}
+/**
+ * An outcome cluster — what agents ended up doing.
+ */
+interface OutcomeCluster {
+    /** The enforcement type that produced this outcome */
+    enforcement: GuardStatus;
+    /** Number of agents with this outcome */
+    agentCount: number;
+    /** For MODIFY: what they were changed to */
+    modifiedTo?: string;
+    /** Agent IDs in this cluster */
+    agents: string[];
+    /** Visual style hint */
+    style: 'green' | 'yellow' | 'red' | 'gray' | 'blue' | 'white';
+}
+/**
+ * A single flow path from intent → rule → outcome.
+ */
+interface FlowPath {
+    /** Source intent */
+    intent: string;
+    /** Rule that intercepted (if any) */
+    ruleId?: string;
+    /** Resulting enforcement */
+    enforcement: GuardStatus;
+    /** Agent ID */
+    agentId: string;
+    /** Original action */
+    originalAction: string;
+    /** Final action */
+    finalAction: string;
+    /** Consequence applied (if PENALIZE) */
+    consequence?: Consequence;
+    /** Reward applied (if REWARD) */
+    reward?: Reward;
+}
+/**
+ * The complete Decision Flow — the visualization data structure.
+ *
+ * LEFT → CENTER → RIGHT
+ * Intents → Rules → Outcomes
+ */
+interface DecisionFlow {
+    /** Left column: intent clusters */
+    intents: IntentCluster[];
+    /** Center column: rule obstacles */
+    rules: RuleObstacle[];
+    /** Right column: outcome clusters */
+    outcomes: OutcomeCluster[];
+    /** Every individual flow path */
+    paths: FlowPath[];
+    /** Key metrics */
+    metrics: DecisionFlowMetrics;
+    /** Time window */
+    periodStart: string;
+    periodEnd: string;
+    worldName: string;
+}
+/**
+ * The headline metrics for the Decision Flow.
+ */
+interface DecisionFlowMetrics {
+    /** Total intents evaluated */
+    totalIntents: number;
+    /** How many were redirected (not ALLOW) */
+    totalRedirected: number;
+    /** Headline: "X% of agent intent was redirected by governance" */
+    redirectionRate: number;
+    /** Breakdown by enforcement type */
+    byEnforcement: Record<string, number>;
+    /** Total penalties applied */
+    totalPenalties: number;
+    /** Total rewards applied */
+    totalRewards: number;
+    /** Net behavioral pressure (rewards - penalties) */
+    netBehavioralPressure: number;
+}
+/**
+ * Generate a Decision Flow from audit events.
+ *
+ * This is the primary entry point — takes raw audit data and produces
+ * the complete visualization structure.
+ */
+declare function generateDecisionFlow(events: AuditEvent[]): DecisionFlow;
+/**
+ * Create a fresh agent behavior state.
+ */
+declare function createAgentState(agentId: string): AgentBehaviorState;
+/**
+ * Apply a consequence to an agent's behavior state.
+ * Returns the updated state (immutable — creates a new object).
+ */
+declare function applyConsequence(state: AgentBehaviorState, consequence: Consequence, ruleId: string): AgentBehaviorState;
+/**
+ * Apply a reward to an agent's behavior state.
+ * Returns the updated state (immutable).
+ */
+declare function applyReward(state: AgentBehaviorState, reward: Reward, ruleId: string): AgentBehaviorState;
+/**
+ * Advance all agent states by one round.
+ * Decrements cooldowns, applies time-based effects.
+ */
+declare function tickAgentStates(states: Map<string, AgentBehaviorState>): Map<string, AgentBehaviorState>;
+/**
+ * Render a Decision Flow as human-readable text.
+ * This is what `neuroverse decision-flow` prints.
+ */
+declare function renderDecisionFlow(flow: DecisionFlow): string;
+
+/**
+ * World Loader — Shared world file loading for CLI commands
+ *
+ * Loads a WorldDefinition from a directory containing individual JSON files.
+ *
+ * Used by: neuroverse guard, neuroverse validate, neuroverse init
+ * Not used by: neuroverse bootstrap (which produces world files, not consumes them)
+ */
+
+/**
+ * Load a WorldDefinition from a directory of JSON files.
+ *
+ * Reads all standard world files and assembles them into a WorldDefinition.
+ * Missing optional files are handled gracefully with defaults.
+ * Missing required files (world.json) throw.
+ */
+declare function loadWorldFromDirectory(dirPath: string): Promise<WorldDefinition>;
+/**
+ * Load a world from a directory path.
+ */
+declare function loadWorld(worldPath: string): Promise<WorldDefinition>;
+
+/**
+ * World Resolver — Resolve world names to paths
+ *
+ * Resolution order:
+ *   1. Explicit path (absolute or relative) → use directly
+ *   2. NEUROVERSE_WORLD env var → resolve as name or path
+ *   3. .neuroverse/active_world file → read world name
+ *   4. Auto-detect if only one world exists in .neuroverse/worlds/
+ *
+ * World name resolution:
+ *   "marketing" → .neuroverse/worlds/marketing/
+ *   "./my-world/" → use as-is
+ *   "/absolute/path" → use as-is
+ */
+interface WorldInfo {
+    name: string;
+    path: string;
+    active: boolean;
+}
+/**
+ * List all compiled worlds in .neuroverse/worlds/
+ */
+declare function listWorlds(cwd?: string): WorldInfo[];
+/**
+ * Get the active world name from .neuroverse/active_world
+ */
+declare function getActiveWorldName(cwd?: string): string | undefined;
+/**
+ * Set the active world by writing .neuroverse/active_world
+ */
+declare function setActiveWorld(name: string, cwd?: string): void;
+/**
+ * Resolve a world reference to an absolute path.
+ *
+ * @param explicit - Value from --world flag (may be undefined)
+ * @param cwd - Working directory for relative resolution
+ * @returns Resolved absolute path to the world directory
+ */
+declare function resolveWorldPath(explicit?: string, cwd?: string): string | undefined;
+/**
+ * Describe how the current world was resolved (for "Using world:" messages).
+ * Returns { name, source } or undefined if no world is active.
+ */
+declare function describeActiveWorld(explicit?: string, cwd?: string): {
+    name: string;
+    source: string;
+} | undefined;
+
+/**
+ * Condition Engine — Structured operator evaluation
+ *
+ * Ported from the OpenClaw governance plugin. Provides 12 operators
+ * for evaluating conditions against guard events:
+ *
+ *   ==, !=, >, <, >=, <=, in,
+ *   contains, contains_any, matches_pattern, starts_with, ends_with
+ *
+ * Supports dot-notation field resolution (e.g. "args.command", "args.file_path")
+ * for inspecting tool arguments.
+ *
+ * Deterministic. No AI. No network. Sub-millisecond per evaluation.
+ */
+
+type ConditionOperator = '==' | '!=' | '>' | '<' | '>=' | '<=' | 'in' | 'contains' | 'contains_any' | 'matches_pattern' | 'starts_with' | 'ends_with';
+interface Condition {
+    field: string;
+    operator: ConditionOperator;
+    value: string | string[] | number | boolean;
+}
+interface ConditionResult {
+    matched: boolean;
+    evidence: string | null;
+}
+/**
+ * Evaluate a single condition against a guard event.
+ * Returns whether it matched and what evidence was found.
+ */
+declare function evaluateCondition(condition: Condition, event: GuardEvent): ConditionResult;
+
+/**
+ * Validate Contract — CLI World File Static Analysis Types
+ *
+ * Defines the input/output contract for `neuroverse validate`.
+ *
+ * WorldDefinition comes in (loaded from .nv-world.zip or directory).
+ * ValidateReport goes out (stdout JSON).
+ * Exit code encodes health: 0=PASS, 1=FAIL, 2=WARN.
+ *
+ * The validate engine performs static analysis on world files:
+ *   - Completeness: Are all required blocks present and non-empty?
+ *   - Referential integrity: Do rules reference declared state variables?
+ *   - Guard coverage: Do invariants have backing structural guards?
+ *   - Contradiction detection: Do rules conflict with each other?
+ *   - Orphan detection: Are there unreachable rules or unused variables?
+ *
+ * INVARIANTS:
+ *   - Deterministic: same world → same report.
+ *   - Zero network calls.
+ *   - Every finding includes the source block and a human-readable message.
+ */
+/**
+ * Controls the strictness of governance validation.
+ *
+ * - `dev`:      Lenient — governance findings are downgraded to info. Build always succeeds.
+ * - `standard`: Recommended default — governance findings are warnings. Build always succeeds.
+ * - `strict`:   Compliance — governance findings stay as warnings but are flagged for attention.
+ *               Build still succeeds (worlds always work) but the report highlights all gaps.
+ *
+ * Structural issues (missing blocks, broken references, schema violations) are
+ * always reported at their natural severity regardless of mode.
+ */
+type ValidationMode = 'dev' | 'standard' | 'strict';
+type FindingSeverity = 'error' | 'warning' | 'info';
+type FindingCategory = 'completeness' | 'referential-integrity' | 'guard-coverage' | 'contradiction' | 'orphan' | 'schema-violation' | 'semantic-tension';
+/**
+ * A single finding from static analysis.
+ */
+interface ValidateFinding {
+    /** Unique ID for this finding type (e.g., "missing-thesis", "orphan-rule-003") */
+    id: string;
+    /** Human-readable message */
+    message: string;
+    /** Error, warning, or informational */
+    severity: FindingSeverity;
+    /** What category of issue this is */
+    category: FindingCategory;
+    /** Which world file block(s) are affected */
+    affectedBlocks: string[];
+    /** Specific field or rule ID that triggered this finding */
+    source?: string;
+    /** Suggested fix (when deterministically derivable) */
+    suggestion?: string;
+}
+/**
+ * Summary of world health by category.
+ */
+interface ValidateSummary {
+    /** Total findings by severity */
+    errors: number;
+    warnings: number;
+    info: number;
+    /** Block completeness score (0-100) */
+    completenessScore: number;
+    /** Invariant coverage percentage (invariants with backing guards) */
+    invariantCoverage: number;
+    /** Whether the world is valid enough to run */
+    canRun: boolean;
+    /** Whether the world passes full validation (no errors) */
+    isHealthy: boolean;
+    /** Governance health — actionable summary of coverage gaps */
+    governanceHealth?: GovernanceHealth;
+}
+/**
+ * Actionable governance health summary.
+ * Provides at-a-glance understanding of how well-governed a world is.
+ */
+interface GovernanceHealth {
+    /** How many declared action surfaces are governed vs total */
+    surfacesCovered: number;
+    surfacesTotal: number;
+    /** Individual surface governance status */
+    surfaces: Array<{
+        name: string;
+        governed: boolean;
+    }>;
+    /** How many structural invariants are enforced vs total */
+    invariantsEnforced: number;
+    invariantsTotal: number;
+    /** Number of shadowed guards detected */
+    shadowedGuards: number;
+    /** Number of unenforced invariants */
+    unenforcedInvariants: number;
+    /** Number of unreachable rules/gates (dead policy logic) */
+    unreachableRules: number;
+    /** Number of enum variables with incomplete state coverage */
+    incompleteStateCoverage: number;
+    /** Overall risk level */
+    riskLevel: 'low' | 'moderate' | 'high';
+}
+/**
+ * The validate report — what goes to stdout.
+ *
+ * Exit codes:
+ *   0 = PASS  (no errors, world is healthy)
+ *   1 = FAIL  (errors found, world cannot run safely)
+ *   2 = WARN  (warnings found but world can run)
+ *   3 = ERROR (invalid input, could not parse world)
+ */
+interface ValidateReport {
+    /** World identity */
+    worldId: string;
+    worldName: string;
+    worldVersion: string;
+    /** When the validation ran */
+    validatedAt: number;
+    /** Duration of validation */
+    durationMs: number;
+    /** High-level summary */
+    summary: ValidateSummary;
+    /** Validation mode used */
+    validationMode: ValidationMode;
+    /** All findings, ordered by severity (errors first) */
+    findings: ValidateFinding[];
+}
+declare const VALIDATE_EXIT_CODES: {
+    readonly PASS: 0;
+    readonly FAIL: 1;
+    readonly WARN: 2;
+    readonly ERROR: 3;
+};
+type ValidateExitCode = (typeof VALIDATE_EXIT_CODES)[keyof typeof VALIDATE_EXIT_CODES];
+
+/**
+ * Validate Engine — World File Static Analysis
+ *
+ * Pure function: (world) → report
+ *
+ * Performs comprehensive static analysis on a WorldDefinition:
+ *   1. Completeness — are required blocks present and non-empty?
+ *   2. Referential integrity — do rules reference declared variables?
+ *   3. Guard coverage — do invariants have backing structural guards?
+ *   3b. Semantic coverage — can any guard actually intercept the invariant's action class?
+ *   4. Contradiction detection — do rules conflict?
+ *   5. Guard shadow detection — do guards shadow or conflict with each other?
+ *   5b. Fail-closed surface detection — are action surfaces ungoverned?
+ *   6. Reachability analysis — are there rules/guards that can never trigger?
+ *   7. State space coverage — do guard conditions cover all enumerated states?
+ *   8. Orphan detection — unused variables, unreachable rules
+ *   9. Schema validation — values within declared ranges
+ *
+ * INVARIANTS:
+ *   - Deterministic: same world → same report, always.
+ *   - Zero network calls. Zero LLM calls. Zero async.
+ *   - Every finding is traceable to specific world file blocks.
+ */
+
+/**
+ * Validate a world definition and produce a report.
+ *
+ * This is the entire validate engine. One function. Deterministic.
+ */
+declare function validateWorld(world: WorldDefinition, mode?: ValidationMode): ValidateReport;
+
+/**
+ * Bootstrap Contract — Markdown → WorldDefinition Compilation Types
+ *
+ * Defines the input/output contract for `neuroverse bootstrap`.
+ *
+ * Input:  .nv-world.md file (structured markdown)
+ * Output: WorldDefinition (passed to validate, guard, or compileWorldToZip)
+ *
+ * The markdown format is:
+ *   - YAML frontmatter for world identity and metadata
+ *   - H1 sections for each block (Thesis, Invariants, State, etc.)
+ *   - Structured sub-sections within each block
+ *   - Deterministically parseable — no LLM, no heuristics
+ *
+ * Exit codes:
+ *   0 = SUCCESS  (compiled cleanly)
+ *   1 = FAIL     (parse errors, missing required sections)
+ *   3 = ERROR    (file not found, invalid input)
+ */
+type ParseSeverity = 'error' | 'warning' | 'info';
+/**
+ * A single parse issue found during markdown compilation.
+ */
+interface ParseIssue {
+    /** Line number in the source markdown (1-based) */
+    line: number;
+    /** Which section the issue was found in */
+    section: string;
+    /** Human-readable message */
+    message: string;
+    /** Severity */
+    severity: ParseSeverity;
+}
+/**
+ * The result of parsing a .nv-world.md file.
+ */
+interface BootstrapResult {
+    /** Whether compilation succeeded (no errors) */
+    success: boolean;
+    /** Source file path */
+    sourcePath: string;
+    /** All parse issues */
+    issues: ParseIssue[];
+    /** Parsed sections (for debugging) */
+    parsedSections: string[];
+    /** Duration */
+    durationMs: number;
+}
+/**
+ * YAML frontmatter parsed from the markdown header.
+ */
+interface ParsedFrontmatter {
+    world_id: string;
+    name: string;
+    version?: string;
+    runtime_mode?: string;
+    default_profile?: string;
+    alternative_profile?: string;
+}
+/**
+ * A parsed invariant from the Invariants section.
+ */
+interface ParsedInvariant {
+    id: string;
+    label: string;
+    enforcement: string;
+    mutable: boolean;
+    line: number;
+}
+/**
+ * A parsed state variable from the State section.
+ */
+interface ParsedStateVariable {
+    id: string;
+    type: 'number' | 'enum' | 'boolean';
+    default: string | number | boolean;
+    label: string;
+    description: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: string[];
+    line: number;
+}
+/**
+ * A parsed assumption profile from the Assumptions section.
+ */
+interface ParsedAssumptionProfile {
+    id: string;
+    name: string;
+    description: string;
+    parameters: Record<string, string | number | boolean>;
+    line: number;
+}
+/**
+ * A parsed trigger from a rule.
+ */
+interface ParsedTrigger {
+    field: string;
+    operator: string;
+    value: string | number | boolean;
+    source: 'state' | 'assumption';
+}
+/**
+ * A parsed effect from a rule.
+ */
+interface ParsedEffect {
+    target: string;
+    operation: string;
+    value: number | boolean | string;
+}
+/**
+ * A parsed rule from the Rules section.
+ */
+interface ParsedRule {
+    id: string;
+    label: string;
+    severity: string;
+    description?: string;
+    order: number;
+    triggers: ParsedTrigger[];
+    effects: ParsedEffect[];
+    collapse_check?: {
+        field: string;
+        operator: string;
+        value: number;
+    };
+    causal_translation?: {
+        trigger_text: string;
+        rule_text: string;
+        shift_text: string;
+        effect_text: string;
+    };
+    line: number;
+}
+/**
+ * A parsed gate from the Gates section.
+ */
+interface ParsedGate {
+    status: string;
+    field: string;
+    operator: string;
+    value: number;
+    line: number;
+}
+/**
+ * A parsed outcome from the Outcomes section.
+ */
+interface ParsedOutcome {
+    id: string;
+    type: string;
+    range?: [number, number];
+    display?: string;
+    label: string;
+    primary?: boolean;
+    assignment?: string;
+    line: number;
+}
+/**
+ * The full parsed intermediate representation.
+ */
+interface ParsedWorld {
+    frontmatter: ParsedFrontmatter;
+    thesis: string;
+    invariants: ParsedInvariant[];
+    stateVariables: ParsedStateVariable[];
+    assumptions: ParsedAssumptionProfile[];
+    rules: ParsedRule[];
+    gates: ParsedGate[];
+    outcomes: ParsedOutcome[];
+}
+declare const BOOTSTRAP_EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly FAIL: 1;
+    readonly ERROR: 3;
+};
+type BootstrapExitCode = (typeof BOOTSTRAP_EXIT_CODES)[keyof typeof BOOTSTRAP_EXIT_CODES];
+
+/**
+ * Bootstrap Parser — .nv-world.md → ParsedWorld
+ *
+ * Deterministic markdown parser for the NeuroVerse world authoring format.
+ * No LLM calls. No heuristics. Pattern matching on structured markdown.
+ *
+ * ## Markdown Format (.nv-world.md)
+ *
+ * ```markdown
+ * ---
+ * world_id: my-world
+ * name: My World
+ * version: 1.0.0
+ * default_profile: baseline
+ * alternative_profile: alternative
+ * ---
+ *
+ * # Thesis
+ * The structural claim this world tests...
+ *
+ * # Invariants
+ * - `invariant_id` — Label text (structural, immutable)
+ * - `another_id` — Another label (structural, immutable)
+ *
+ * # State
+ * ## variable_name
+ * - type: number
+ * - min: 0
+ * - max: 100
+ * - step: 5
+ * - default: 50
+ * - label: Human Label
+ * - description: What this variable represents
+ *
+ * ## another_variable
+ * - type: enum
+ * - options: option_a, option_b, option_c
+ * - default: option_a
+ * - label: Another Variable
+ * - description: Description here
+ *
+ * # Assumptions
+ * ## baseline
+ * - name: Baseline Scenario
+ * - description: The default conditions
+ * - param_key: param_value
+ *
+ * ## alternative
+ * - name: Alternative Scenario
+ * - description: What changes
+ * - param_key: different_value
+ *
+ * # Rules
+ * ## rule-001: Rule Label (structural)
+ * Description of what this rule does.
+ *
+ * When field == "value" [state] AND other_field > 50 [assumption]
+ * Then target *= 0.30, other_target = false
+ * Collapse: field < 0.03
+ *
+ * > trigger: Trigger text here
+ * > rule: Rule text here
+ * > shift: Shift text here
+ * > effect: Effect text here
+ *
+ * # Gates
+ * - THRIVING: effective_margin >= 40
+ * - STABLE: effective_margin >= 20
+ * - COMPRESSED: effective_margin >= 10
+ * - CRITICAL: effective_margin > 3
+ * - MODEL_COLLAPSES: effective_margin <= 3
+ *
+ * # Outcomes
+ * ## outcome_id
+ * - type: number
+ * - range: 0-100
+ * - display: percentage
+ * - label: Outcome Label
+ * - primary: true
+ * ```
+ */
+
+/**
+ * Parse a .nv-world.md string into a ParsedWorld.
+ *
+ * Returns the parsed world and a list of issues.
+ * Callers should check issues for severity === 'error' before proceeding.
+ */
+declare function parseWorldMarkdown(markdown: string): {
+    world: ParsedWorld | null;
+    issues: ParseIssue[];
+};
+
+/**
+ * Bootstrap Emitter — ParsedWorld → WorldDefinition
+ *
+ * Converts the intermediate representation from the parser
+ * into a proper WorldDefinition that the guard engine, validate engine,
+ * and compileWorldToZip() all consume.
+ *
+ * Fills in sensible defaults for optional fields.
+ * Reports issues when the parsed data can't cleanly map to the target type.
+ *
+ * Deterministic. Same parsed input → same WorldDefinition output.
+ */
+
+/**
+ * Convert a ParsedWorld into a WorldDefinition.
+ *
+ * Returns the world definition and any issues encountered during emission.
+ */
+declare function emitWorldDefinition(parsed: ParsedWorld): {
+    world: WorldDefinition;
+    issues: ParseIssue[];
+};
+
+/**
+ * Add Engine — Incremental Governance Authoring
+ *
+ * Appends guards, rules, or invariants to a compiled world directory.
+ * Runs validation after every addition. Deterministic, no LLM calls.
+ *
+ * Three construct types map to user intent:
+ *   "Block X"                    → Guard   (action control)
+ *   "If X happens → Y changes"  → Rule    (world evolution)
+ *   "X must always be true"      → Invariant (hard constraint)
+ *
+ * Architecture:
+ *   addGuard()     → append to guards.json → validate → report
+ *   addRule()      → write rules/rule-NNN.json → validate → report
+ *   addInvariant() → append to invariants.json → validate → report
+ */
+
+interface AddResult {
+    /** What was added */
+    type: 'guard' | 'rule' | 'invariant';
+    /** The ID of the added construct */
+    id: string;
+    /** The file that was written */
+    file: string;
+    /** Whether validation passed after addition */
+    valid: boolean;
+    /** Validation findings (errors/warnings) introduced by this addition */
+    findings: ValidateReport['findings'];
+    /** The full object that was written */
+    construct: Guard | Rule | Invariant;
+}
+interface AddGuardInput {
+    /** Human-readable label (e.g., "Block dairy orders") */
+    label: string;
+    /** What enforcement to apply */
+    enforcement: Guard['enforcement'];
+    /** Intent patterns to match (e.g., ["order*dairy", "purchase*dairy"]) */
+    intentPatterns: string[];
+    /** Optional description */
+    description?: string;
+    /** Optional category override */
+    category?: Guard['category'];
+    /** Optional tool filter */
+    appliesTo?: string[];
+    /** Optional reason for block/pause */
+    reason?: string;
+    /** Optional invariant reference */
+    invariantRef?: string;
+    /** Optional explicit ID */
+    id?: string;
+}
+declare function addGuard(worldDir: string, input: AddGuardInput): Promise<AddResult>;
+interface AddRuleInput {
+    /** Human-readable label */
+    label: string;
+    /** Severity level */
+    severity: Rule['severity'];
+    /** Description of what this rule does */
+    description?: string;
+    /** Trigger conditions */
+    triggers: Rule['triggers'];
+    /** Effects when triggered */
+    effects?: Rule['effects'];
+    /** Optional collapse check */
+    collapseCheck?: Rule['collapse_check'];
+    /** Causal translation (human-readable explanation) */
+    causalTranslation?: Rule['causal_translation'];
+    /** Optional explicit ID */
+    id?: string;
+}
+declare function addRule(worldDir: string, input: AddRuleInput): Promise<AddResult>;
+interface AddInvariantInput {
+    /** Human-readable label (e.g., "Budget must never exceed 1000") */
+    label: string;
+    /** Enforcement type */
+    enforcement?: Invariant['enforcement'];
+    /** Optional explicit ID */
+    id?: string;
+}
+declare function addInvariant(worldDir: string, input: AddInvariantInput): Promise<AddResult>;
+/**
+ * Classify a natural-language intent into the correct construct type.
+ * This is a simple deterministic classifier — no LLM required.
+ *
+ * Returns 'guard' | 'rule' | 'invariant' | 'ambiguous'
+ */
+type ConstructType = 'guard' | 'rule' | 'invariant' | 'ambiguous';
+declare function classifyIntent(text: string): ConstructType;
+/**
+ * Parse a natural-language guard description into AddGuardInput.
+ * Handles common patterns like:
+ *   "Block dairy orders"
+ *   "Pause if cost > 500"
+ *   "Warn on shell access"
+ */
+declare function parseGuardDescription(text: string): AddGuardInput;
+
+/**
+ * Derive Contract — AI-Assisted World Synthesis Types
+ *
+ * Defines the input/output contract for `neuroverse derive`.
+ *
+ * Input:  Arbitrary markdown files/directories
+ * Output: .nv-world.md file constrained by DerivationWorld
+ *
+ * Exit codes:
+ *   0 = SUCCESS          (valid file written)
+ *   1 = VALIDATION_FAIL  (output failed parseWorldMarkdown)
+ *   2 = INPUT_ERROR      (missing input, empty dir, unreadable)
+ *   3 = PROVIDER_ERROR   (no config, API failure, timeout)
+ */
+declare const DERIVE_EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly VALIDATION_FAIL: 1;
+    readonly INPUT_ERROR: 2;
+    readonly PROVIDER_ERROR: 3;
+};
+type DeriveExitCode = (typeof DERIVE_EXIT_CODES)[keyof typeof DERIVE_EXIT_CODES];
+declare const CONFIGURE_AI_EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly VALIDATION_FAIL: 1;
+    readonly ERROR: 3;
+};
+interface DeriveResult {
+    success: boolean;
+    outputPath: string;
+    sectionsDetected: string[];
+    validationErrors: number;
+    validationWarnings: number;
+    findings: DeriveFinding[];
+    gate?: string;
+    normalization?: NormalizationSummary;
+    durationMs: number;
+}
+interface NormalizationSummary {
+    fixCount: number;
+    invariantIds: number;
+    gateThresholds: number;
+    triggerTags: number;
+}
+interface DeriveFinding {
+    severity: 'error' | 'warning';
+    section: string;
+    message: string;
+    line?: number;
+}
+interface CollectedSource {
+    filename: string;
+    content: string;
+}
+interface AIProviderConfig {
+    provider: string;
+    model: string;
+    apiKey: string;
+    endpoint: string | null;
+}
+interface AIProvider {
+    complete(systemPrompt: string, userPrompt: string): Promise<string>;
+}
+
+/**
+ * Derive Engine — AI-Assisted World Synthesis Pipeline
+ *
+ * Pipeline:
+ *   collect → prompt → AI → extract → parseWorldMarkdown → write → JSON
+ *
+ * DerivationWorld is advisory only:
+ *   - Gate status is reported but never blocks file writing
+ *   - parseWorldMarkdown errors ARE blocking (invalid .nv-world.md)
+ *   - Governance engine does NOT run during derive
+ */
+
+/**
+ * Extract .nv-world.md content from LLM response.
+ *
+ * Handles:
+ *   - Triple backtick fences (```markdown ... ``` or ``` ... ```)
+ *   - Sentinel markers (BEGIN NV WORLD / END NV WORLD)
+ *   - Raw content starting with ---
+ *
+ * Pre-parse safety: output must contain `world_id:` in frontmatter.
+ */
+declare function extractWorldMarkdown(raw: string): string | null;
+interface DeriveOptions {
+    inputPath: string;
+    outputPath: string;
+    validate: boolean;
+    dryRun: boolean;
+    providerOverride?: Partial<AIProviderConfig>;
+}
+declare function deriveWorld(options: DeriveOptions): Promise<{
+    result: DeriveResult;
+    exitCode: number;
+    dryRunOutput?: {
+        systemPrompt: string;
+        userPrompt: string;
+    };
+}>;
+
+/**
+ * Derive Normalizer — Post-processing pass for AI output drift
+ *
+ * Runs AFTER AI generation but BEFORE parsing. Normalizes common
+ * deviations from the strict .nv-world.md grammar so the parser
+ * can accept the output.
+ *
+ * Transformations:
+ *   1. Invariant lines: adds backtick-wrapped IDs when missing
+ *   2. Gate lines: converts symbolic values to numeric thresholds
+ *   3. Trigger lines: ensures [state] / [assumption] source tags
+ *
+ * INVARIANTS:
+ *   - Deterministic: same input → same output, always.
+ *   - Zero network calls. Zero LLM calls.
+ *   - Never removes content — only reformats.
+ *   - Operates on raw markdown string, not parsed structures.
+ */
+interface NormalizerReport {
+    /** Total number of lines fixed */
+    fixCount: number;
+    /** Number of invariant IDs wrapped in backticks */
+    invariantIds: number;
+    /** Number of symbolic gate thresholds converted to numeric */
+    gateThresholds: number;
+    /** Number of triggers tagged with [state] */
+    triggerTags: number;
+}
+/**
+ * Normalize AI-generated .nv-world.md content to fix common drift patterns.
+ *
+ * Returns the normalized markdown string and a detailed fix report.
+ */
+declare function normalizeWorldMarkdown(markdown: string): {
+    normalized: string;
+    fixCount: number;
+    report: NormalizerReport;
+};
+
+/**
+ * Explain Engine — Generates human-readable narrative summaries from compiled worlds.
+ *
+ * No AI calls. Pure template-based rendering from WorldDefinition data.
+ *
+ * Sections:
+ *   1. Core thesis and identity
+ *   2. Key dynamics (rules with causal_translation)
+ *   3. State variables (what can change)
+ *   4. Invariants (what cannot change)
+ *   5. Viability gates (health thresholds)
+ *   6. Dramatic tensions (opposing rule effects)
+ *   7. Outcomes (what gets measured)
+ */
+
+interface ExplainOutput {
+    worldName: string;
+    worldId: string;
+    thesis: string;
+    dynamics: DynamicSummary[];
+    stateVariables: VariableSummary[];
+    invariants: InvariantSummary[];
+    gates: GateSummary[];
+    tensions: TensionSummary[];
+    outcomes: OutcomeSummary[];
+    stats: WorldStats;
+}
+interface DynamicSummary {
+    ruleId: string;
+    label: string;
+    severity: string;
+    triggerDescription: string;
+    effectDescription: string;
+    targets: string[];
+}
+interface VariableSummary {
+    name: string;
+    label: string;
+    type: string;
+    defaultValue: string | number | boolean;
+    range?: string;
+}
+interface InvariantSummary {
+    id: string;
+    label: string;
+    enforcement: string;
+}
+interface GateSummary {
+    status: string;
+    field: string;
+    threshold: string;
+}
+interface TensionSummary {
+    variable: string;
+    increasedBy: string[];
+    decreasedBy: string[];
+}
+interface OutcomeSummary {
+    id: string;
+    label: string;
+    type: string;
+    primary: boolean;
+}
+interface WorldStats {
+    invariants: number;
+    stateVariables: number;
+    rules: number;
+    gates: number;
+    outcomes: number;
+    assumptions: number;
+}
+declare function explainWorld(world: WorldDefinition): ExplainOutput;
+declare function renderExplainText(output: ExplainOutput): string;
+
+/**
+ * Simulate Engine — Deterministic State Evolution (Reference Simulator)
+ *
+ * Pure function: (world, options) → SimulationResult
+ *
+ * This is NeuroVerse's REFERENCE SIMULATOR — one way to model how a world
+ * evolves over time. It is NOT the governance engine.
+ *
+ * simulateWorld() ≠ evaluateGuard()
+ *
+ *   evaluateGuard()  — Runtime enforcement. Decides if an action is allowed.
+ *                      Includes safety layer, role checks, plan enforcement,
+ *                      kernel rules, level constraints. Use for governance.
+ *
+ *   simulateWorld()  — State evolution modeling. Evaluates rule triggers,
+ *                      applies effects, tracks viability over N steps.
+ *                      Use for scenario planning and what-if analysis.
+ *
+ * World files (.nv-world.md) are portable — they define rules, roles, and
+ * constraints that can be consumed by any simulator or governance engine.
+ * This simulator is a reference implementation, not the only interpreter.
+ *
+ * Supports:
+ *   - Single-step evaluation (default)
+ *   - Multi-step iteration (--steps N)
+ *   - State overrides (start from non-default values)
+ *   - Assumption profile selection
+ *   - Collapse detection (early termination)
+ *
+ * INVARIANTS:
+ *   - Deterministic: same world + same options → same result.
+ *   - Zero network calls. Zero LLM calls. Zero async.
+ *   - Every rule evaluation is recorded in the trace.
+ *   - World definition is REQUIRED — no world, no simulation.
+ */
+
+interface SimulateOptions {
+    /** Number of simulation steps (default: 1) */
+    steps?: number;
+    /** State variable overrides (start values) */
+    stateOverrides?: Record<string, string | number | boolean>;
+    /** Assumption profile to use (default: world default) */
+    profile?: string;
+}
+interface SimulationResult {
+    worldId: string;
+    worldName: string;
+    profile: string;
+    initialState: Record<string, string | number | boolean>;
+    steps: SimulationStep[];
+    finalState: Record<string, string | number | boolean>;
+    finalViability: ViabilityStatus;
+    collapsed: boolean;
+    collapseStep?: number;
+    collapseRule?: string;
+}
+interface SimulationStep {
+    step: number;
+    rulesEvaluated: RuleEvaluation[];
+    rulesFired: number;
+    stateAfter: Record<string, string | number | boolean>;
+    viability: ViabilityStatus;
+    collapsed: boolean;
+}
+interface RuleEvaluation {
+    ruleId: string;
+    label: string;
+    triggered: boolean;
+    excluded: boolean;
+    effects: AppliedEffect[];
+    collapsed: boolean;
+    collapseField?: string;
+}
+interface AppliedEffect {
+    target: string;
+    operation: string;
+    value: number | boolean | string;
+    before: string | number | boolean;
+    after: string | number | boolean;
+}
+declare function simulateWorld(world: WorldDefinition, options?: SimulateOptions): SimulationResult;
+declare function renderSimulateText(result: SimulationResult): string;
+
+/**
+ * Improve Engine — Actionable Suggestions from World Analysis
+ *
+ * Pure function: (world) → ImprovementReport
+ *
+ * Runs validation, simulation, and structural analysis to produce
+ * prioritized, actionable suggestions for improving a world.
+ *
+ * Categories:
+ *   1. Critical fixes — errors that prevent the world from running
+ *   2. Structural gaps — missing guards, orphan variables, etc.
+ *   3. Balance suggestions — detected from simulation dynamics
+ *   4. Completeness — optional blocks that would strengthen the world
+ *
+ * INVARIANTS:
+ *   - Deterministic: same world → same report.
+ *   - Zero network calls. Zero LLM calls. Zero async.
+ */
+
+type SuggestionPriority = 'critical' | 'high' | 'medium' | 'low';
+type SuggestionCategory = 'fix' | 'structure' | 'balance' | 'completeness' | 'coverage';
+interface Suggestion {
+    id: string;
+    priority: SuggestionPriority;
+    category: SuggestionCategory;
+    title: string;
+    description: string;
+    action: string;
+    affectedFiles: string[];
+}
+interface ImprovementReport {
+    worldId: string;
+    worldName: string;
+    score: number;
+    suggestions: Suggestion[];
+    stats: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    };
+}
+declare function improveWorld(world: WorldDefinition): ImprovementReport;
+declare function renderImproveText(report: ImprovementReport): string;
+
+/**
+ * Runtime Types — Simple input types for HTTP/demo consumers
+ *
+ * These types are the "easy API" for code that doesn't load full world files.
+ * The govern() bridge converts these into the guard engine's native types.
+ */
+/**
+ * A plain-object description of an agent action.
+ * This is what HTTP clients and Python simulations send.
+ */
+interface AgentAction {
+    /** Agent or role identifier */
+    agentId: string;
+    /** Action type (e.g., "publish", "trade", "share", "cite") */
+    type: string;
+    /** Human-readable description of what the agent is doing */
+    description: string;
+    /** Action magnitude/intensity (0-1 scale) */
+    magnitude?: number;
+    /** Arbitrary context data */
+    context?: Record<string, unknown>;
+}
+/**
+ * Arbitrary key-value state passed alongside an action.
+ * Used by the simulation bridge to provide environmental context.
+ */
+type WorldState = Record<string, unknown>;
+/**
+ * Configuration for creating a governor instance.
+ */
+interface GovernorConfig {
+    /** Path to a .nv-world.md or .nv-world.zip file */
+    worldPath?: string;
+    /** Enable evaluation trace in verdicts */
+    trace?: boolean;
+    /** Enforcement level override */
+    level?: 'basic' | 'standard' | 'strict';
+}
+
+/**
+ * Govern — Thin bridge from HTTP/demo consumers to the real guard engine.
+ *
+ * This is NOT a second engine. It is NOT a parser.
+ * It converts AgentAction → GuardEvent, loads a world, and calls evaluateGuard().
+ * That's it. Zero intelligence. Zero interpretation.
+ *
+ * Rule parsing belongs in `neuroverse add`. Evaluation belongs in guard-engine.ts.
+ * This bridge just translates types and calls the real thing.
+ *
+ * Architecture:
+ *   [HTTP request] → govern(action, worldPath) → evaluateGuard(event, world) → GuardVerdict
+ */
+
+/**
+ * Convert an AgentAction (HTTP/demo format) → GuardEvent (engine format).
+ * Pure mapping. No interpretation. No intelligence.
+ */
+declare function actionToGuardEvent(action: AgentAction): GuardEvent;
+/**
+ * Evaluate a single action against a loaded world.
+ *
+ * This is the entire bridge. AgentAction in, GuardVerdict out.
+ * Uses the same evaluateGuard() as `neuroverse guard`.
+ */
+declare function govern(action: AgentAction, world: WorldDefinition, options?: GuardEngineOptions): GuardVerdict;
+/**
+ * A governor holds a loaded world and evaluates actions against it.
+ * Used by the demo server to avoid re-loading the world on every request.
+ */
+interface Governor {
+    /** Evaluate an action against the loaded world */
+    evaluate(action: AgentAction): GuardVerdict;
+    /** Reload the world from disk (call after rules change) */
+    reload(): Promise<void>;
+    /** The loaded world definition */
+    readonly world: WorldDefinition;
+}
+/**
+ * Create a governor instance that holds a loaded world.
+ *
+ * Usage:
+ *   const gov = await createGovernor({ worldPath: '/tmp/neuroverse-demo' });
+ *   const verdict = gov.evaluate(action);
+ *   // After rule changes:
+ *   await gov.reload();
+ */
+declare function createGovernor(config: GovernorConfig): Promise<Governor>;
+/**
+ * Write a minimal world directory from plain-text rules.
+ *
+ * This is for the demo server: UI sends plain-text rules,
+ * we write them as kernel forbidden_patterns, then load
+ * the world through the normal loadWorld() path.
+ *
+ * NO interpretation. Each rule line becomes a kernel forbidden pattern.
+ * The guard engine does the matching.
+ */
+declare function writeTempWorld(dir: string, policyLines: string[]): Promise<void>;
+
+/**
+ * Behavioral Contract — Types for the Behavioral Analysis Engine
+ *
+ * Extracted from behavioral-engine.ts so other modules (CLI, API, tests)
+ * can depend on the contract without pulling in implementation.
+ *
+ * Types:
+ *   ActionCategory  — Categories of agent actions for behavioral shift tracking
+ *   Adaptation      — A classified behavioral adaptation (what an agent did instead)
+ *   BehavioralPattern — An emergent behavioral pattern detected across agents
+ *   NetworkContext  — Network-level context for narrative generation
+ */
+
+/** Categories of agent actions for behavioral shift tracking */
+type ActionCategory = 'amplifying' | 'passive' | 'engaging' | 'corrective' | 'transactional' | 'creative' | 'analytical' | 'unknown';
+/** A classified behavioral adaptation — what an agent did instead */
+interface Adaptation {
+    /** Agent identifier */
+    agentId: string;
+    /** What the agent intended to do */
+    intendedAction: string;
+    /** What the agent actually did (after governance) */
+    executedAction: string;
+    /** Named behavioral shift category */
+    shiftType: string;
+    /** Governance status that caused the shift */
+    verdict: GuardStatus;
+    /** Rule that caused the shift */
+    ruleId?: string;
+    /** Human-readable reason */
+    reason?: string;
+}
+/** An emergent behavioral pattern detected across multiple agents */
+interface BehavioralPattern {
+    /** Pattern type identifier */
+    type: string;
+    /** Human-readable description */
+    description: string;
+    /** Pattern strength (0-1), based on fraction of agents affected */
+    strength: number;
+    /** Number of agents exhibiting this pattern */
+    agentsAffected: number;
+}
+/** Network-level context for narrative generation */
+interface NetworkContext {
+    mood?: string;
+    misinfoLevel?: number;
+    totalAgents?: number;
+    totalActions?: number;
+    [key: string]: unknown;
+}
+
+/**
+ * Behavioral Analysis Engine — What Governance UNLOCKS
+ *
+ * This is the differentiator. Every governance system can tell you
+ * what it blocked. Only NeuroVerse tells you:
+ *   - What agents did INSTEAD (adaptation classification)
+ *   - What patterns emerged COLLECTIVELY (behavioral detection)
+ *   - WHY it matters IN PROSE (narrative generation)
+ *
+ * "Governance is the engine — but we also always want to show people
+ *  the knowledge that constraining unlocks."
+ *
+ * Architecture:
+ *   GuardVerdict[] → classifyAdaptation() → Adaptation[]
+ *   Adaptation[]   → detectBehavioralPatterns() → BehavioralPattern[]
+ *   Pattern[]      → generateAdaptationNarrative() → string
+ *
+ * Pure functions. No network. No LLM. Deterministic.
+ */
+
+/**
+ * Classify what behavioral shift governance caused for a single agent action.
+ *
+ * Takes the original intent and the actual execution, returns a named shift.
+ * Pure function. No side effects.
+ */
+declare function classifyAdaptation(intendedAction: string, executedAction: string): string;
+/**
+ * Build an Adaptation from a GuardVerdict with intent tracking.
+ * Uses the IntentRecord attached to the verdict (if present).
+ */
+declare function adaptationFromVerdict(agentId: string, intendedAction: string, executedAction: string, verdict: GuardVerdict): Adaptation;
+/**
+ * Detect emergent collective patterns from a batch of adaptations.
+ *
+ * This is NOT just counting. It detects:
+ *   - Coordinated silence (many agents forced idle)
+ *   - Misinformation suppression (amplification specifically blocked)
+ *   - Constructive redirection (agents shifted to positive actions)
+ *   - High governance impact (large fraction of agents affected)
+ *   - Trading halt (transactional agents stopped)
+ *
+ * Pure function. Deterministic. Same inputs → same patterns.
+ */
+declare function detectBehavioralPatterns(adaptations: Adaptation[], totalAgents: number): BehavioralPattern[];
+/**
+ * Generate a human-readable cause-effect narrative from patterns.
+ *
+ * This is the "money moment" — the prose explanation of what governance
+ * caused to happen. Not a log. Not a report. A story.
+ *
+ * "5 agents went silent instead of amplifying. 3 redirected to fact-checking.
+ *  Network mood: polarized, misinfo level: 45%"
+ */
+declare function generateAdaptationNarrative(patterns: BehavioralPattern[], context?: NetworkContext): string;
+
+/**
+ * API Handlers — Server-side request handlers for the demo server.
+ *
+ * These are pure functions that handle HTTP request bodies and return
+ * response objects. No HTTP framework dependency — just data in, data out.
+ *
+ * The demo server (src/cli/demo.ts) wires these to routes.
+ */
+declare function handleHealthCheck(): {
+    status: string;
+    engine: string;
+    version: string;
+    capabilities: string[];
+};
+declare function handleListPresets(policiesDir?: string): Promise<{
+    presets: Array<{
+        id: string;
+        name: string;
+        description: string;
+        rules: string;
+    }>;
+}>;
+/**
+ * Run governed reasoning on a scenario.
+ * Takes a scenario description + world path, evaluates through the guard engine.
+ */
+declare function handleReasonRequest(body: {
+    scenario?: string;
+    worldPath?: string;
+    intent?: string;
+    tool?: string;
+    roleId?: string;
+}): Promise<Record<string, unknown>>;
+/**
+ * Create a shareable scenario capsule — a self-contained snapshot
+ * of a governance scenario that can be shared or replayed.
+ */
+declare function handleCreateCapsule(body: {
+    scenario?: string;
+    rules?: string[];
+    events?: Array<{
+        intent: string;
+        tool?: string;
+    }>;
+}): {
+    capsuleId: string;
+    scenario: string;
+    rules: string[];
+    events: Array<{
+        intent: string;
+        tool?: string;
+    }>;
+    createdAt: string;
+};
+
+export { type AIProvider, type AIProviderConfig, type ActionCategory, type Adaptation, type AddGuardInput, type AddInvariantInput, type AddResult, type AddRuleInput, AdvanceResult, type AgentAction, AgentBehaviorState, type AppliedEffect, type AuditEvent, type AuditLogger, type AuditSummary, BOOTSTRAP_EXIT_CODES, type BehavioralPattern, type BootstrapExitCode, type BootstrapResult, CONFIGURE_AI_EXIT_CODES, type ChatMessage, type CollectedSource, CompositeAuditLogger, type Condition, type ConditionOperator, type ConditionResult, Consequence, ConsoleAuditLogger, type ConstructType, DERIVE_EXIT_CODES, type DecisionFlow, type DecisionFlowMetrics, type DeriveExitCode, type DeriveFinding, type DeriveResult, type ExplainOutput, FileAuditLogger, type FindingCategory, type FindingSeverity, type FlowPath, type FormatVerdictOptions, type GovernanceEngineOptions, type GovernanceHealth, type Governor, type GovernorConfig, GuardEngineOptions, GuardEvent, GuardStatus, GuardVerdict, type ImpactReport, type ImprovementReport, type IntentCluster, McpGovernanceServer, type McpServerConfig, ModelAdapter, type ModelConfig, type ModelResponse, type NetworkContext, type NormalizationSummary, type OutcomeCluster, PROVIDERS, type ParseIssue, type ParsedAssumptionProfile, type ParsedEffect, type ParsedFrontmatter, type ParsedGate, type ParsedInvariant, type ParsedOutcome, type ParsedRule, type ParsedStateVariable, type ParsedTrigger, type ParsedWorld, PlanCheck, PlanDefinition, type PlanParseResult, PlanProgress, PlanVerdict, type PreventionCategory, type ProviderPreset, Reward, type RuleEvaluation, type RuleObstacle, type SessionConfig, SessionManager, type SessionState, type SimulateOptions, type SimulationResult, type SimulationStep, StepEvidence, type Suggestion, type SuggestionCategory, type SuggestionPriority, type ToolCall, type ToolDefinition, VALIDATE_EXIT_CODES, type ValidateExitCode, type ValidateFinding, type ValidateReport, type ValidateSummary, type ValidationMode, type WorldInfo, type WorldState, actionToGuardEvent, adaptationFromVerdict, addGuard, addInvariant, addRule, advancePlan, applyConsequence, applyReward, buildPlanCheck, classifyAdaptation, classifyIntent, createAgentState, createGovernanceEngine, createGovernor, deriveWorld, describeActiveWorld, detectBehavioralPatterns, emitWorldDefinition, evaluateCondition, evaluateGuard, evaluatePlan, eventToAllowlistKey, explainWorld, extractWorldMarkdown, formatVerdict, formatVerdictOneLine, generateAdaptationNarrative, generateDecisionFlow, generateImpactReport, generateImpactReportFromFile, getActiveWorldName, getPlanProgress, govern, handleCreateCapsule, handleHealthCheck, handleListPresets, handleReasonRequest, improveWorld, listWorlds, loadWorld, loadWorldFromDirectory, normalizeWorldMarkdown, parseGuardDescription, parsePlanMarkdown, parseWorldMarkdown, readAuditLog, renderDecisionFlow, renderExplainText, renderImpactReport, renderImproveText, renderSimulateText, resolveProvider, resolveWorldPath, runInteractiveMode, runPipeMode, setActiveWorld, simulateWorld, summarizeAuditEvents, tickAgentStates, validateWorld, verdictToAuditEvent, writeTempWorld };