@neuroverseos/governance 0.1.5 → 0.2.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as GuardEvent, W as WorldDefinition, b as GuardEngineOptions, G as GuardVerdict, V as ViabilityStatus } from './guard-contract-D_RQz9kt.js';
-export { E as EvaluationTrace, c as GUARD_EXIT_CODES, d as GuardCheck, e as GuardExitCode, f as GuardStatus, I as InvariantCheck, K as KernelRuleCheck, L as LevelCheck, P as PrecedenceResolution, R as RoleCheck, S as SafetyCheck, g as VerdictEvidence } from './guard-contract-D_RQz9kt.js';
+import { a as GuardEvent, W as WorldDefinition, c as GuardEngineOptions, G as GuardVerdict, P as PlanDefinition, d as PlanVerdict, e as PlanCheck, b as PlanProgress, V as ViabilityStatus } from './guard-contract-D-2LQInm.js';
+export { E as EvaluationTrace, f as GUARD_EXIT_CODES, g as GuardCheck, h as GuardExitCode, i as GuardStatus, I as InvariantCheck, K as KernelRuleCheck, L as LevelCheck, j as PLAN_EXIT_CODES, k as PlanConstraint, l as PlanExitCode, m as PlanStatus, n as PlanStep, o as PrecedenceResolution, R as RoleCheck, S as SafetyCheck, p as VerdictEvidence } from './guard-contract-D-2LQInm.js';
 
 /**
  * Guard Engine — Deterministic Governance Evaluator
@@ -10,12 +10,13 @@ export { E as EvaluationTrace, c as GUARD_EXIT_CODES, d as GuardCheck, e as Guar
  * a GuardVerdict with evidence and optional evaluation trace.
  *
  * Evaluation chain (first-match-wins on BLOCK/PAUSE):
- *   1. Safety checks (prompt injection, scope escape)    → 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
+ *   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.
@@ -49,6 +50,363 @@ declare function evaluateGuard(event: GuardEvent, world: WorldDefinition, option
  */
 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, 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.
+ */
+declare function advancePlan(plan: PlanDefinition, stepId: string): PlanDefinition;
+/**
+ * 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;
+}
+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;
+    /**
+     * 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
  *
@@ -375,6 +733,54 @@ declare function loadWorldFromDirectory(dirPath: string): Promise<WorldDefinitio
  */
 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
  *
@@ -427,6 +833,18 @@ declare function evaluateCondition(condition: Condition, event: GuardEvent): Con
  *   - 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';
 /**
@@ -464,6 +882,35 @@ interface ValidateSummary {
     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.
@@ -485,6 +932,8 @@ interface ValidateReport {
     durationMs: number;
     /** High-level summary */
     summary: ValidateSummary;
+    /** Validation mode used */
+    validationMode: ValidationMode;
     /** All findings, ordered by severity (errors first) */
     findings: ValidateFinding[];
 }
@@ -505,9 +954,14 @@ type ValidateExitCode = (typeof VALIDATE_EXIT_CODES)[keyof typeof VALIDATE_EXIT_
  *   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. Orphan detection — unused variables, unreachable rules
- *   6. Schema validation — values within declared ranges
+ *   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.
@@ -520,7 +974,7 @@ type ValidateExitCode = (typeof VALIDATE_EXIT_CODES)[keyof typeof VALIDATE_EXIT_
  *
  * This is the entire validate engine. One function. Deterministic.
  */
-declare function validateWorld(world: WorldDefinition): ValidateReport;
+declare function validateWorld(world: WorldDefinition, mode?: ValidationMode): ValidateReport;
 
 /**
  * Bootstrap Contract — Markdown → WorldDefinition Compilation Types
@@ -1144,4 +1598,4 @@ interface ImprovementReport {
 declare function improveWorld(world: WorldDefinition): ImprovementReport;
 declare function renderImproveText(report: ImprovementReport): string;
 
-export { type AIProvider, type AIProviderConfig, type AppliedEffect, type AuditEvent, type AuditLogger, type AuditSummary, BOOTSTRAP_EXIT_CODES, type BootstrapExitCode, type BootstrapResult, CONFIGURE_AI_EXIT_CODES, type CollectedSource, CompositeAuditLogger, type Condition, type ConditionOperator, type ConditionResult, ConsoleAuditLogger, DERIVE_EXIT_CODES, type DeriveExitCode, type DeriveFinding, type DeriveResult, type ExplainOutput, FileAuditLogger, type FindingCategory, type FindingSeverity, type FormatVerdictOptions, type GovernanceEngineOptions, GuardEngineOptions, GuardEvent, GuardVerdict, type ImpactReport, type ImprovementReport, type NormalizationSummary, type ParseIssue, type ParsedAssumptionProfile, type ParsedEffect, type ParsedFrontmatter, type ParsedGate, type ParsedInvariant, type ParsedOutcome, type ParsedRule, type ParsedStateVariable, type ParsedTrigger, type ParsedWorld, type PreventionCategory, type RuleEvaluation, type SimulateOptions, type SimulationResult, type SimulationStep, type Suggestion, type SuggestionCategory, type SuggestionPriority, VALIDATE_EXIT_CODES, type ValidateExitCode, type ValidateFinding, type ValidateReport, type ValidateSummary, createGovernanceEngine, deriveWorld, emitWorldDefinition, evaluateCondition, evaluateGuard, eventToAllowlistKey, explainWorld, extractWorldMarkdown, formatVerdict, formatVerdictOneLine, generateImpactReport, generateImpactReportFromFile, improveWorld, loadWorld, loadWorldFromDirectory, normalizeWorldMarkdown, parseWorldMarkdown, readAuditLog, renderExplainText, renderImpactReport, renderImproveText, renderSimulateText, simulateWorld, summarizeAuditEvents, validateWorld, verdictToAuditEvent };
+export { type AIProvider, type AIProviderConfig, type AppliedEffect, type AuditEvent, type AuditLogger, type AuditSummary, BOOTSTRAP_EXIT_CODES, type BootstrapExitCode, type BootstrapResult, CONFIGURE_AI_EXIT_CODES, type ChatMessage, type CollectedSource, CompositeAuditLogger, type Condition, type ConditionOperator, type ConditionResult, ConsoleAuditLogger, DERIVE_EXIT_CODES, type DeriveExitCode, type DeriveFinding, type DeriveResult, type ExplainOutput, FileAuditLogger, type FindingCategory, type FindingSeverity, type FormatVerdictOptions, type GovernanceEngineOptions, type GovernanceHealth, GuardEngineOptions, GuardEvent, GuardVerdict, type ImpactReport, type ImprovementReport, McpGovernanceServer, type McpServerConfig, ModelAdapter, type ModelConfig, type ModelResponse, type NormalizationSummary, 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, type RuleEvaluation, type SessionConfig, SessionManager, type SessionState, type SimulateOptions, type SimulationResult, type SimulationStep, 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, advancePlan, buildPlanCheck, createGovernanceEngine, deriveWorld, describeActiveWorld, emitWorldDefinition, evaluateCondition, evaluateGuard, evaluatePlan, eventToAllowlistKey, explainWorld, extractWorldMarkdown, formatVerdict, formatVerdictOneLine, generateImpactReport, generateImpactReportFromFile, getActiveWorldName, getPlanProgress, improveWorld, listWorlds, loadWorld, loadWorldFromDirectory, normalizeWorldMarkdown, parsePlanMarkdown, parseWorldMarkdown, readAuditLog, renderExplainText, renderImpactReport, renderImproveText, renderSimulateText, resolveProvider, resolveWorldPath, runInteractiveMode, runPipeMode, setActiveWorld, simulateWorld, summarizeAuditEvents, validateWorld, verdictToAuditEvent };

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   generateImpactReport,
   generateImpactReportFromFile,
   renderImpactReport
-} from "./chunk-ITJ3LCPG.js";
+} from "./chunk-ADV7Q2LJ.js";
 import {
   CompositeAuditLogger,
   ConsoleAuditLogger,
@@ -11,16 +11,7 @@ import {
   readAuditLog,
   summarizeAuditEvents,
   verdictToAuditEvent
-} from "./chunk-FYPYZFV5.js";
-import {
-  deriveWorld,
-  extractWorldMarkdown,
-  normalizeWorldMarkdown
-} from "./chunk-D7BGWV2J.js";
-import {
-  CONFIGURE_AI_EXIT_CODES,
-  DERIVE_EXIT_CODES
-} from "./chunk-T4X42QXC.js";
+} from "./chunk-2JQJ5U5X.js";
 import {
   explainWorld,
   renderExplainText
@@ -28,7 +19,7 @@ import {
 import {
   improveWorld,
   renderImproveText
-} from "./chunk-EIUHJXBB.js";
+} from "./chunk-GR6DGCZ2.js";
 import {
   renderSimulateText,
   simulateWorld
@@ -36,27 +27,68 @@ import {
 import {
   BOOTSTRAP_EXIT_CODES
 } from "./chunk-4NGDRRQH.js";
-import {
-  emitWorldDefinition,
-  parseWorldMarkdown
-} from "./chunk-XPDMYECO.js";
 import {
   VALIDATE_EXIT_CODES
 } from "./chunk-I3RRAYK2.js";
 import {
   GUARD_EXIT_CODES
 } from "./chunk-MWDQ4MJB.js";
+import {
+  SessionManager,
+  runInteractiveMode,
+  runPipeMode
+} from "./chunk-5EDDNJU6.js";
+import {
+  ModelAdapter,
+  PROVIDERS,
+  resolveProvider
+} from "./chunk-A5W4GNQO.js";
+import {
+  McpGovernanceServer
+} from "./chunk-PAX2P6ZP.js";
+import {
+  describeActiveWorld,
+  getActiveWorldName,
+  listWorlds,
+  resolveWorldPath,
+  setActiveWorld
+} from "./chunk-AKW5YVCE.js";
+import {
+  deriveWorld,
+  extractWorldMarkdown,
+  normalizeWorldMarkdown
+} from "./chunk-NF5POFCI.js";
+import {
+  CONFIGURE_AI_EXIT_CODES,
+  DERIVE_EXIT_CODES
+} from "./chunk-Q6O7ZLO2.js";
+import "./chunk-OT6PXH54.js";
+import {
+  emitWorldDefinition,
+  parseWorldMarkdown
+} from "./chunk-XPDMYECO.js";
+import {
+  validateWorld
+} from "./chunk-7P3S7MAY.js";
 import {
   evaluateGuard,
   eventToAllowlistKey
-} from "./chunk-B4NF3OLW.js";
+} from "./chunk-PQBJBVSW.js";
 import {
   loadWorld,
   loadWorldFromDirectory
-} from "./chunk-M3TZFGHO.js";
+} from "./chunk-JZPQGIKR.js";
 import {
-  validateWorld
-} from "./chunk-O5OMJMIE.js";
+  PLAN_EXIT_CODES,
+  parsePlanMarkdown
+} from "./chunk-37JG24WH.js";
+import {
+  advancePlan,
+  buildPlanCheck,
+  evaluatePlan,
+  getPlanProgress
+} from "./chunk-P74Y66ZV.js";
+import "./chunk-YZFATT7X.js";
 
 // src/engine/verdict-formatter.ts
 var ANSI = {
@@ -299,12 +331,21 @@ export {
   DERIVE_EXIT_CODES,
   FileAuditLogger,
   GUARD_EXIT_CODES,
+  McpGovernanceServer,
+  ModelAdapter,
+  PLAN_EXIT_CODES,
+  PROVIDERS,
+  SessionManager,
   VALIDATE_EXIT_CODES,
+  advancePlan,
+  buildPlanCheck,
   createGovernanceEngine,
   deriveWorld,
+  describeActiveWorld,
   emitWorldDefinition,
   evaluateCondition,
   evaluateGuard,
+  evaluatePlan,
   eventToAllowlistKey,
   explainWorld,
   extractWorldMarkdown,
@@ -312,16 +353,25 @@ export {
   formatVerdictOneLine,
   generateImpactReport,
   generateImpactReportFromFile,
+  getActiveWorldName,
+  getPlanProgress,
   improveWorld,
+  listWorlds,
   loadWorld,
   loadWorldFromDirectory,
   normalizeWorldMarkdown,
+  parsePlanMarkdown,
   parseWorldMarkdown,
   readAuditLog,
   renderExplainText,
   renderImpactReport,
   renderImproveText,
   renderSimulateText,
+  resolveProvider,
+  resolveWorldPath,
+  runInteractiveMode,
+  runPipeMode,
+  setActiveWorld,
   simulateWorld,
   summarizeAuditEvents,
   validateWorld,