@thehoneyjar/sigil-anchor 4.3.1

package/dist/index.d.ts

@@ -0,0 +1,1230 @@
+import { EventEmitter } from 'eventemitter3';
+import { z } from 'zod';
+
+/**
+ * Anchor Core Types
+ *
+ * Type definitions for the Anchor ground truth enforcement layer.
+ */
+
+/** Network configuration for forking */
+interface NetworkConfig {
+    /** Network name (e.g., 'mainnet', 'sepolia') */
+    name: string;
+    /** Chain ID */
+    chainId: number;
+    /** RPC URL to fork from */
+    rpcUrl: string;
+}
+/** Fork configuration */
+interface ForkConfig {
+    /** Network to fork */
+    network: NetworkConfig;
+    /** Block number to fork at (optional, defaults to latest) */
+    blockNumber?: number;
+    /** Local RPC port (optional, auto-assigned if not specified) */
+    port?: number;
+    /** Session ID this fork belongs to */
+    sessionId?: string;
+}
+/** Active fork instance */
+interface Fork {
+    /** Unique fork identifier */
+    id: string;
+    /** Network configuration */
+    network: NetworkConfig;
+    /** Block number fork was created at */
+    blockNumber: number;
+    /** Local RPC URL */
+    rpcUrl: string;
+    /** Local RPC port */
+    port: number;
+    /** Process ID */
+    pid: number;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Session ID this fork belongs to */
+    sessionId?: string;
+}
+/** Fork registry schema for persistence */
+declare const ForkSchema: z.ZodObject<{
+    id: z.ZodString;
+    network: z.ZodObject<{
+        name: z.ZodString;
+        chainId: z.ZodNumber;
+        rpcUrl: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        chainId: number;
+        rpcUrl: string;
+    }, {
+        name: string;
+        chainId: number;
+        rpcUrl: string;
+    }>;
+    blockNumber: z.ZodNumber;
+    rpcUrl: z.ZodString;
+    port: z.ZodNumber;
+    pid: z.ZodNumber;
+    createdAt: z.ZodEffects<z.ZodString, Date, string>;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    network: {
+        name: string;
+        chainId: number;
+        rpcUrl: string;
+    };
+    rpcUrl: string;
+    blockNumber: number;
+    port: number;
+    pid: number;
+    createdAt: Date;
+    sessionId?: string | undefined;
+}, {
+    id: string;
+    network: {
+        name: string;
+        chainId: number;
+        rpcUrl: string;
+    };
+    rpcUrl: string;
+    blockNumber: number;
+    port: number;
+    pid: number;
+    createdAt: string;
+    sessionId?: string | undefined;
+}>;
+declare const ForkRegistrySchema: z.ZodObject<{
+    forks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        network: z.ZodObject<{
+            name: z.ZodString;
+            chainId: z.ZodNumber;
+            rpcUrl: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            chainId: number;
+            rpcUrl: string;
+        }, {
+            name: string;
+            chainId: number;
+            rpcUrl: string;
+        }>;
+        blockNumber: z.ZodNumber;
+        rpcUrl: z.ZodString;
+        port: z.ZodNumber;
+        pid: z.ZodNumber;
+        createdAt: z.ZodEffects<z.ZodString, Date, string>;
+        sessionId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        network: {
+            name: string;
+            chainId: number;
+            rpcUrl: string;
+        };
+        rpcUrl: string;
+        blockNumber: number;
+        port: number;
+        pid: number;
+        createdAt: Date;
+        sessionId?: string | undefined;
+    }, {
+        id: string;
+        network: {
+            name: string;
+            chainId: number;
+            rpcUrl: string;
+        };
+        rpcUrl: string;
+        blockNumber: number;
+        port: number;
+        pid: number;
+        createdAt: string;
+        sessionId?: string | undefined;
+    }>, "many">;
+    lastUpdated: z.ZodEffects<z.ZodString, Date, string>;
+}, "strip", z.ZodTypeAny, {
+    forks: {
+        id: string;
+        network: {
+            name: string;
+            chainId: number;
+            rpcUrl: string;
+        };
+        rpcUrl: string;
+        blockNumber: number;
+        port: number;
+        pid: number;
+        createdAt: Date;
+        sessionId?: string | undefined;
+    }[];
+    lastUpdated: Date;
+}, {
+    forks: {
+        id: string;
+        network: {
+            name: string;
+            chainId: number;
+            rpcUrl: string;
+        };
+        rpcUrl: string;
+        blockNumber: number;
+        port: number;
+        pid: number;
+        createdAt: string;
+        sessionId?: string | undefined;
+    }[];
+    lastUpdated: string;
+}>;
+type ForkRegistry = z.infer<typeof ForkRegistrySchema>;
+/** Snapshot metadata */
+interface SnapshotMetadata {
+    /** Snapshot ID (from Anvil) */
+    id: string;
+    /** Fork ID this snapshot belongs to */
+    forkId: string;
+    /** Session ID */
+    sessionId: string;
+    /** Task ID that created this snapshot */
+    taskId?: string;
+    /** Block number at snapshot time */
+    blockNumber: number;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Description */
+    description?: string;
+}
+/** Snapshot configuration */
+interface SnapshotConfig {
+    /** Fork ID to snapshot */
+    forkId: string;
+    /** Session ID */
+    sessionId: string;
+    /** Task ID */
+    taskId?: string;
+    /** Description */
+    description?: string;
+}
+/** Checkpoint metadata */
+interface CheckpointMetadata {
+    /** Checkpoint ID */
+    id: string;
+    /** Session ID */
+    sessionId: string;
+    /** Fork ID this checkpoint was created from */
+    forkId: string;
+    /** Snapshot range covered by this checkpoint */
+    snapshotRange: {
+        first: string;
+        last: string;
+    };
+    /** Block number at checkpoint time */
+    blockNumber: number;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Number of snapshots since last checkpoint */
+    snapshotCount: number;
+}
+/** Checkpoint configuration */
+interface CheckpointConfig {
+    /** Session ID */
+    sessionId: string;
+    /** Fork ID */
+    forkId: string;
+    /** Snapshot interval before checkpointing */
+    interval?: number;
+}
+/** Task types in the Anchor pipeline */
+type TaskType = 'fork' | 'ground' | 'warden' | 'generate' | 'validate' | 'write';
+/** Task status */
+type TaskStatus = 'pending' | 'running' | 'complete' | 'blocked' | 'failed';
+/** Task in the state-pinned graph */
+interface Task {
+    /** Unique task ID */
+    id: string;
+    /** Task type */
+    type: TaskType;
+    /** Current status */
+    status: TaskStatus;
+    /** Snapshot ID binding this task to EVM state */
+    snapshotId?: string;
+    /** Checkpoint ID for recovery */
+    checkpointId?: string;
+    /** IDs of tasks this depends on */
+    dependencies: string[];
+    /** Task input data */
+    input: unknown;
+    /** Task output data */
+    output?: unknown;
+    /** Error if failed */
+    error?: string;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Completion timestamp */
+    completedAt?: Date;
+}
+/** Task graph data for persistence */
+interface TaskGraphData {
+    /** Session ID */
+    sessionId: string;
+    /** All tasks */
+    tasks: Task[];
+    /** Current head task ID */
+    headTaskId?: string;
+    /** Last updated timestamp */
+    lastUpdated: Date;
+}
+/** Zone hierarchy for physics validation */
+type Zone = 'critical' | 'elevated' | 'standard' | 'local';
+/** Zone hierarchy order (most restrictive first) */
+declare const ZONE_HIERARCHY: Zone[];
+/** Warden validation input */
+interface WardenInput {
+    /** Component or action being validated */
+    component: string;
+    /** Cited zone in grounding statement */
+    citedZone: Zone | null;
+    /** Keywords detected in the component */
+    keywords: string[];
+    /** Grounding statement from agent */
+    groundingStatement: string;
+    /** Physics rules being applied */
+    appliedPhysics?: {
+        sync?: string;
+        timing?: string;
+        confirmation?: string;
+    };
+}
+/** Individual check result */
+interface CheckResult {
+    /** Whether the check passed */
+    passed: boolean;
+    /** Reason for pass/fail */
+    reason: string;
+}
+/** Warden validation result */
+interface WardenResult {
+    /** Overall validation status */
+    status: 'VALID' | 'DRIFT' | 'DECEPTIVE';
+    /** Individual check results */
+    checks: {
+        relevance: CheckResult;
+        hierarchy: CheckResult;
+        rules: CheckResult;
+    };
+    /** Required zone based on analysis */
+    requiredZone: Zone;
+    /** Zone cited by agent */
+    citedZone: Zone | null;
+    /** Correction message if needed */
+    correction?: string;
+}
+/** Anchor exit codes */
+declare const ExitCode: {
+    readonly PASS: 0;
+    readonly DRIFT: 1;
+    readonly DECEPTIVE: 2;
+    readonly VIOLATION: 3;
+    readonly REVERT: 4;
+    readonly CORRUPT: 5;
+    readonly SCHEMA: 6;
+};
+type ExitCodeValue = (typeof ExitCode)[keyof typeof ExitCode];
+
+/**
+ * ForkManager - Anvil fork lifecycle management
+ *
+ * Manages spawning, tracking, and killing Anvil fork processes.
+ * Persists fork registry to grimoires/anchor/forks.json.
+ */
+
+/** ForkManager events */
+interface ForkManagerEvents {
+    'fork:created': (fork: Fork) => void;
+    'fork:exit': (forkId: string, code: number | null) => void;
+    'fork:error': (forkId: string, error: Error) => void;
+}
+/**
+ * ForkManager class for managing Anvil fork lifecycle
+ */
+declare class ForkManager extends EventEmitter<ForkManagerEvents> {
+    private forks;
+    private processes;
+    private usedPorts;
+    private registryPath;
+    constructor(options?: {
+        registryPath?: string;
+    });
+    /**
+     * Initialize the ForkManager by loading persisted registry
+     */
+    init(): Promise<void>;
+    /**
+     * Spawn a new Anvil fork
+     *
+     * @param config - Fork configuration
+     * @returns Promise resolving to the created Fork
+     */
+    fork(config: ForkConfig): Promise<Fork>;
+    /**
+     * Wait for a fork to be ready
+     *
+     * @param forkId - Fork ID to wait for
+     * @param timeoutMs - Timeout in milliseconds
+     */
+    waitForReady(forkId: string, timeoutMs?: number): Promise<void>;
+    /**
+     * Kill a specific fork
+     *
+     * @param forkId - Fork ID to kill
+     */
+    kill(forkId: string): Promise<void>;
+    /**
+     * Kill all forks
+     */
+    killAll(): Promise<void>;
+    /**
+     * List all active forks
+     *
+     * @returns Array of active forks
+     */
+    list(): Fork[];
+    /**
+     * Get a fork by ID
+     *
+     * @param forkId - Fork ID
+     * @returns Fork if found, undefined otherwise
+     */
+    get(forkId: string): Fork | undefined;
+    /**
+     * Export environment variables for a fork
+     *
+     * @param forkId - Fork ID
+     * @returns Environment variables object
+     */
+    exportEnv(forkId: string): Record<string, string>;
+    /**
+     * Load fork registry from disk
+     */
+    private loadRegistry;
+    /**
+     * Save fork registry to disk
+     */
+    private saveRegistry;
+    /**
+     * Check if a fork is still healthy
+     */
+    private checkForkHealth;
+    /**
+     * Handle process exit
+     */
+    private handleProcessExit;
+    /**
+     * Find an available port
+     */
+    private findAvailablePort;
+    /**
+     * Generate a unique fork ID
+     */
+    private generateForkId;
+}
+/**
+ * Get the default ForkManager instance
+ */
+declare function getForkManager(): ForkManager;
+/**
+ * Reset the default ForkManager (for testing)
+ */
+declare function resetForkManager(): void;
+
+/**
+ * SnapshotManager - Anvil snapshot lifecycle management
+ *
+ * Manages creating, reverting, and tracking EVM snapshots.
+ * Persists snapshot metadata to grimoires/anchor/sessions/{sessionId}/snapshots/
+ */
+
+/** Snapshot manager configuration */
+interface SnapshotManagerConfig {
+    /** Base path for session data */
+    basePath?: string;
+}
+/**
+ * SnapshotManager class for managing Anvil snapshots
+ */
+declare class SnapshotManager {
+    private snapshots;
+    private taskToSnapshot;
+    private basePath;
+    private sessionId;
+    constructor(config?: SnapshotManagerConfig);
+    /**
+     * Initialize the manager for a session
+     *
+     * @param sessionId - Session ID to manage snapshots for
+     */
+    init(sessionId: string): Promise<void>;
+    /**
+     * Create a new snapshot
+     *
+     * @param config - Snapshot configuration
+     * @param rpcUrl - RPC URL of the fork
+     * @returns Promise resolving to snapshot metadata
+     */
+    create(config: SnapshotConfig, rpcUrl: string): Promise<SnapshotMetadata>;
+    /**
+     * Revert to a snapshot
+     *
+     * @param rpcUrl - RPC URL of the fork
+     * @param snapshotId - Snapshot ID to revert to
+     * @returns Promise resolving to true if successful
+     */
+    revert(rpcUrl: string, snapshotId: string): Promise<boolean>;
+    /**
+     * Get snapshot metadata by ID
+     *
+     * @param snapshotId - Snapshot ID
+     * @returns Snapshot metadata if found
+     */
+    get(snapshotId: string): SnapshotMetadata | undefined;
+    /**
+     * List all snapshots sorted by creation time
+     *
+     * @returns Array of snapshot metadata
+     */
+    list(): SnapshotMetadata[];
+    /**
+     * Get snapshot for a specific task
+     *
+     * @param taskId - Task ID
+     * @returns Snapshot metadata if found
+     */
+    getForTask(taskId: string): SnapshotMetadata | undefined;
+    /**
+     * Get the count of snapshots
+     *
+     * @returns Number of snapshots
+     */
+    count(): number;
+    /**
+     * Cleanup old snapshots, keeping the most recent
+     *
+     * @param keepLast - Number of recent snapshots to keep
+     */
+    cleanup(keepLast: number): Promise<void>;
+    /**
+     * Get snapshot directory path for current session
+     */
+    private getSnapshotDir;
+    /**
+     * Get file path for a snapshot
+     */
+    private getSnapshotPath;
+    /**
+     * Load existing snapshots from disk
+     */
+    private loadSnapshots;
+    /**
+     * Save snapshot metadata to disk
+     */
+    private saveSnapshot;
+    /**
+     * Delete a snapshot from memory and disk
+     */
+    private deleteSnapshot;
+}
+/**
+ * Get the default SnapshotManager instance
+ */
+declare function getSnapshotManager(): SnapshotManager;
+/**
+ * Reset the default SnapshotManager (for testing)
+ */
+declare function resetSnapshotManager(): void;
+
+/**
+ * CheckpointManager - Hard restart strategy for Anvil memory management
+ *
+ * Creates periodic checkpoints via anvil_dumpState to prevent memory bloat.
+ * Restores checkpoints via anvil_loadState for crash recovery.
+ */
+
+/** Checkpoint manager configuration */
+interface CheckpointManagerConfig {
+    /** Base path for checkpoint data */
+    basePath?: string;
+    /** Snapshot interval before creating checkpoint */
+    snapshotInterval?: number;
+    /** Maximum checkpoints to retain */
+    maxCheckpoints?: number;
+}
+/**
+ * CheckpointManager class for hard restart strategy
+ */
+declare class CheckpointManager {
+    private checkpoints;
+    private snapshotCount;
+    private firstSnapshotId;
+    private lastSnapshotId;
+    private basePath;
+    private snapshotInterval;
+    private maxCheckpoints;
+    private sessionId;
+    private forkId;
+    constructor(config?: CheckpointManagerConfig);
+    /**
+     * Initialize the manager for a session
+     *
+     * @param sessionId - Session ID
+     * @param forkId - Fork ID
+     */
+    init(sessionId: string, forkId: string): Promise<void>;
+    /**
+     * Called when a snapshot is created. May trigger checkpoint.
+     *
+     * @param snapshotId - ID of the created snapshot
+     * @param rpcUrl - RPC URL of the fork
+     * @returns True if checkpoint was created
+     */
+    onSnapshot(snapshotId: string, rpcUrl: string): Promise<boolean>;
+    /**
+     * Create a checkpoint by exporting state
+     *
+     * @param rpcUrl - RPC URL of the fork
+     * @returns Checkpoint metadata
+     */
+    create(rpcUrl: string): Promise<CheckpointMetadata>;
+    /**
+     * Restore from a checkpoint
+     *
+     * @param checkpointId - Checkpoint ID to restore
+     * @param forkManager - ForkManager instance
+     * @param network - Network configuration
+     * @returns New fork with restored state
+     */
+    restore(checkpointId: string, forkManager: ForkManager, network: NetworkConfig): Promise<Fork>;
+    /**
+     * Find the checkpoint containing a specific snapshot
+     *
+     * @param snapshotId - Snapshot ID to find
+     * @returns Checkpoint metadata if found
+     */
+    findCheckpointForSnapshot(snapshotId: string): CheckpointMetadata | undefined;
+    /**
+     * Get checkpoint by ID
+     *
+     * @param checkpointId - Checkpoint ID
+     * @returns Checkpoint metadata if found
+     */
+    get(checkpointId: string): CheckpointMetadata | undefined;
+    /**
+     * List all checkpoints sorted by time
+     *
+     * @returns Array of checkpoint metadata
+     */
+    list(): CheckpointMetadata[];
+    /**
+     * Get the latest checkpoint
+     *
+     * @returns Latest checkpoint metadata
+     */
+    latest(): CheckpointMetadata | undefined;
+    /**
+     * Cleanup old checkpoints, keeping only the most recent
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Get session directory path
+     */
+    private getSessionDir;
+    /**
+     * Get checkpoint directory path
+     */
+    private getCheckpointDir;
+    /**
+     * Get state file path
+     */
+    private getStatePath;
+    /**
+     * Get metadata file path
+     */
+    private getMetaPath;
+    /**
+     * Load checkpoints from disk
+     */
+    private loadCheckpoints;
+    /**
+     * Save checkpoint to disk
+     */
+    private saveCheckpoint;
+    /**
+     * Delete a checkpoint from disk
+     */
+    private deleteCheckpoint;
+    /**
+     * Generate a unique checkpoint ID
+     */
+    private generateCheckpointId;
+}
+/**
+ * Get the default CheckpointManager instance
+ */
+declare function getCheckpointManager(): CheckpointManager;
+/**
+ * Reset the default CheckpointManager (for testing)
+ */
+declare function resetCheckpointManager(): void;
+
+/**
+ * TaskGraph - State-pinned DAG for task management
+ *
+ * Manages task dependencies, status tracking, and snapshot binding.
+ * Persists graph state to grimoires/anchor/sessions/{sessionId}/graph.json
+ */
+
+/** Task graph configuration */
+interface TaskGraphConfig {
+    /** Session ID */
+    sessionId: string;
+    /** Base path for session data */
+    basePath?: string;
+    /** Auto-save on changes */
+    autoSave?: boolean;
+}
+/**
+ * Generate a unique task ID
+ */
+declare function generateTaskId(type: TaskType): string;
+/**
+ * Reset the task counter (for testing)
+ */
+declare function resetTaskCounter(): void;
+/**
+ * TaskGraph class for managing state-pinned task DAG
+ */
+declare class TaskGraph {
+    private tasks;
+    private dependents;
+    private sessionId;
+    private basePath;
+    private autoSave;
+    private headTaskId;
+    constructor(config: TaskGraphConfig);
+    /**
+     * Initialize the graph by loading persisted state
+     */
+    init(): Promise<void>;
+    /**
+     * Add a task to the graph
+     *
+     * @param task - Task to add
+     */
+    addTask(task: Task): Promise<void>;
+    /**
+     * Update task status
+     *
+     * @param taskId - Task ID
+     * @param status - New status
+     */
+    updateStatus(taskId: string, status: TaskStatus): Promise<void>;
+    /**
+     * Set the snapshot binding for a task
+     *
+     * @param taskId - Task ID
+     * @param snapshotId - Snapshot ID
+     */
+    setSnapshot(taskId: string, snapshotId: string): Promise<void>;
+    /**
+     * Set the checkpoint binding for a task
+     *
+     * @param taskId - Task ID
+     * @param checkpointId - Checkpoint ID
+     */
+    setCheckpoint(taskId: string, checkpointId: string): Promise<void>;
+    /**
+     * Set task output
+     *
+     * @param taskId - Task ID
+     * @param output - Task output
+     */
+    setOutput(taskId: string, output: unknown): Promise<void>;
+    /**
+     * Set task error
+     *
+     * @param taskId - Task ID
+     * @param error - Error message
+     */
+    setError(taskId: string, error: string): Promise<void>;
+    /**
+     * Get a task by ID
+     *
+     * @param taskId - Task ID
+     * @returns Task if found
+     */
+    getTask(taskId: string): Task | undefined;
+    /**
+     * Get all tasks
+     *
+     * @returns Array of all tasks
+     */
+    getAllTasks(): Task[];
+    /**
+     * Get tasks by status
+     *
+     * @param status - Status to filter by
+     * @returns Array of matching tasks
+     */
+    getTasksByStatus(status: TaskStatus): Task[];
+    /**
+     * Check if a task can run (all dependencies complete)
+     *
+     * @param taskId - Task ID
+     * @returns True if all dependencies are complete
+     */
+    canRun(taskId: string): boolean;
+    /**
+     * Get the next runnable task (pending with all deps complete)
+     *
+     * @returns Next runnable task or undefined
+     */
+    getNextRunnable(): Task | undefined;
+    /**
+     * Propagate blocked status to all dependents of a failed task
+     *
+     * @param taskId - ID of the failed task
+     */
+    propagateBlocked(taskId: string): Promise<void>;
+    /**
+     * Find the recovery point for a failed task
+     *
+     * @param taskId - ID of the task needing recovery
+     * @returns Last complete task with snapshot, or undefined
+     */
+    findRecoveryPoint(taskId: string): Task | undefined;
+    /**
+     * Check if there are any blocked tasks
+     *
+     * @returns True if any tasks are blocked
+     */
+    hasBlocked(): boolean;
+    /**
+     * Check if all tasks are complete
+     *
+     * @returns True if all tasks are complete
+     */
+    isComplete(): boolean;
+    /**
+     * Get the graph file path
+     */
+    private getGraphPath;
+    /**
+     * Export graph data as JSON-serializable object
+     *
+     * @returns Task graph data
+     */
+    toJSON(): TaskGraphData;
+    /**
+     * Save the graph to disk
+     */
+    save(): Promise<void>;
+    /**
+     * Load the graph from disk
+     */
+    load(): Promise<void>;
+    /**
+     * Validate that adding a task doesn't create a cycle
+     */
+    private validateNoCycle;
+}
+
+/**
+ * SessionManager - Session lifecycle management
+ *
+ * Manages session creation, persistence, and recovery.
+ * Coordinates ForkManager, SnapshotManager, CheckpointManager, and TaskGraph.
+ */
+
+/** Session metadata */
+interface SessionMetadata {
+    /** Session ID */
+    id: string;
+    /** Network configuration */
+    network: NetworkConfig;
+    /** Current fork ID */
+    forkId: string;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Last activity timestamp */
+    lastActivity: Date;
+    /** Session status */
+    status: 'active' | 'suspended' | 'complete' | 'failed';
+    /** Initial block number */
+    initialBlock: number;
+}
+/** Session manager configuration */
+interface SessionManagerConfig {
+    /** Base path for session data */
+    basePath?: string;
+}
+/** Session state with all managers */
+interface Session {
+    metadata: SessionMetadata;
+    fork: Fork;
+    forkManager: ForkManager;
+    snapshotManager: SnapshotManager;
+    checkpointManager: CheckpointManager;
+    taskGraph: TaskGraph;
+}
+/**
+ * SessionManager class for session lifecycle
+ */
+declare class SessionManager {
+    private sessions;
+    private currentSession;
+    private basePath;
+    constructor(config?: SessionManagerConfig);
+    /**
+     * Initialize the manager by loading session index
+     */
+    init(): Promise<void>;
+    /**
+     * Create a new session
+     *
+     * @param network - Network to fork
+     * @param options - Session options
+     * @returns Created session
+     */
+    create(network: NetworkConfig, options?: {
+        blockNumber?: number;
+    }): Promise<Session>;
+    /**
+     * Resume an existing session
+     *
+     * @param sessionId - Session ID to resume
+     * @returns Resumed session
+     */
+    resume(sessionId: string): Promise<Session>;
+    /**
+     * Recover a session from checkpoint or snapshot
+     */
+    private recover;
+    /**
+     * Get current session
+     *
+     * @returns Current session or null
+     */
+    current(): Session | null;
+    /**
+     * List all sessions
+     *
+     * @param filter - Optional filter for status
+     * @returns Array of session metadata
+     */
+    list(filter?: {
+        status?: SessionMetadata['status'];
+        blocked?: boolean;
+    }): SessionMetadata[];
+    /**
+     * Get session by ID
+     *
+     * @param sessionId - Session ID
+     * @returns Session metadata if found
+     */
+    get(sessionId: string): SessionMetadata | undefined;
+    /**
+     * Update session status
+     *
+     * @param sessionId - Session ID
+     * @param status - New status
+     */
+    updateStatus(sessionId: string, status: SessionMetadata['status']): Promise<void>;
+    /**
+     * Get session directory path
+     */
+    private getSessionDir;
+    /**
+     * Get session metadata path
+     */
+    private getSessionPath;
+    /**
+     * Load session index
+     */
+    private loadSessionIndex;
+    /**
+     * Save session index
+     */
+    private saveSessionIndex;
+    /**
+     * Save session metadata
+     */
+    private saveSession;
+    /**
+     * Generate unique session ID
+     */
+    private generateSessionId;
+}
+/**
+ * Get the default SessionManager instance
+ */
+declare function getSessionManager(): SessionManager;
+/**
+ * Reset the default SessionManager (for testing)
+ */
+declare function resetSessionManager(): void;
+
+/**
+ * Warden Types
+ *
+ * Type definitions for the Warden ground truth enforcement system.
+ */
+
+/** Sync strategy from physics table */
+type SyncStrategy = 'pessimistic' | 'optimistic' | 'immediate';
+/** Confirmation requirement */
+type ConfirmationType = 'required' | 'toast_undo' | 'none';
+/** Effect type from physics/lexicon */
+type EffectType = 'financial' | 'destructive' | 'soft_delete' | 'standard' | 'navigation' | 'query' | 'local' | 'high_freq';
+/** Physics rule for an effect type */
+interface PhysicsRule {
+    /** Effect type */
+    effect: EffectType;
+    /** Sync strategy */
+    sync: SyncStrategy;
+    /** Timing in milliseconds */
+    timing: number;
+    /** Confirmation requirement */
+    confirmation: ConfirmationType;
+    /** Rationale for this physics */
+    rationale: string;
+}
+/** Physics table mapping effect to rules */
+type PhysicsTable = Map<EffectType, PhysicsRule>;
+/** Vocabulary entry linking keywords to effects */
+interface VocabularyEntry {
+    /** Keywords that trigger this effect */
+    keywords: string[];
+    /** Associated effect type */
+    effect: EffectType;
+    /** Category (primary, extended, web3, etc.) */
+    category: string;
+}
+/** Full vocabulary mapping */
+interface Vocabulary {
+    /** Effect keywords grouped by effect type */
+    effects: Map<EffectType, VocabularyEntry>;
+    /** Type overrides that force specific effects */
+    typeOverrides: Map<string, EffectType>;
+    /** Domain context defaults */
+    domainDefaults: Map<string, EffectType>;
+}
+/** Grounding statement parsed from agent output */
+interface GroundingStatement {
+    /** Component or action being described */
+    component: string;
+    /** Zone cited by agent (if any) */
+    citedZone: Zone | null;
+    /** Keywords detected in the statement */
+    detectedKeywords: string[];
+    /** Effect inferred from keywords */
+    inferredEffect: EffectType | null;
+    /** Physics rules claimed to be applied */
+    claimedPhysics: {
+        sync?: SyncStrategy;
+        timing?: number;
+        confirmation?: ConfirmationType;
+    };
+    /** Raw statement text */
+    raw: string;
+}
+/** Validation check names */
+type CheckName = 'relevance' | 'hierarchy' | 'rules';
+/** Extended check result with details */
+interface ExtendedCheckResult extends CheckResult {
+    /** Check name */
+    name: CheckName;
+    /** Expected value (if applicable) */
+    expected?: string;
+    /** Actual value (if applicable) */
+    actual?: string;
+}
+/** Warden validation context */
+interface ValidationContext {
+    /** Parsed grounding statement */
+    statement: GroundingStatement;
+    /** Physics table */
+    physics: PhysicsTable;
+    /** Vocabulary */
+    vocabulary: Vocabulary;
+    /** Required zone based on keywords */
+    requiredZone: Zone;
+}
+
+/**
+ * PhysicsLoader - Load Sigil physics rules from markdown
+ *
+ * Parses .claude/rules/01-sigil-physics.md to extract the physics table.
+ */
+
+/**
+ * Get default physics table (fallback when file not found)
+ */
+declare function getDefaultPhysics(): PhysicsTable;
+/**
+ * Load physics from file
+ *
+ * @param path - Path to physics markdown file (default: .claude/rules/01-sigil-physics.md)
+ * @returns Parsed physics table
+ */
+declare function loadPhysics(path?: string): Promise<PhysicsTable>;
+/**
+ * Get physics rule for an effect type
+ *
+ * @param effect - Effect type to look up
+ * @param physics - Physics table (will load if not provided)
+ * @returns Physics rule or undefined
+ */
+declare function getPhysicsRule(effect: EffectType, physics?: PhysicsTable): Promise<PhysicsRule | undefined>;
+/**
+ * Clear physics cache (for testing)
+ */
+declare function clearPhysicsCache(): void;
+/**
+ * Check if physics are cached
+ */
+declare function isPhysicsCached(): boolean;
+
+/**
+ * VocabularyLoader - Load Sigil vocabulary from markdown
+ *
+ * Parses .claude/rules/08-sigil-lexicon.md to extract keyword → effect mappings.
+ */
+
+/**
+ * Get default vocabulary (fallback)
+ */
+declare function getDefaultVocabulary(): Vocabulary;
+/**
+ * Load vocabulary from file
+ *
+ * @param path - Path to vocabulary markdown file
+ * @returns Parsed vocabulary
+ */
+declare function loadVocabulary(path?: string): Promise<Vocabulary>;
+/**
+ * Resolve effect from keywords
+ *
+ * @param keywords - Keywords to look up
+ * @param vocabulary - Vocabulary (will load if not provided)
+ * @returns Most specific effect type found, or null
+ */
+declare function resolveEffectFromKeywords(keywords: string[], vocabulary?: Vocabulary): Promise<EffectType | null>;
+/**
+ * Clear vocabulary cache (for testing)
+ */
+declare function clearVocabularyCache(): void;
+/**
+ * Check if vocabulary is cached
+ */
+declare function isVocabularyCached(): boolean;
+
+/**
+ * GroundingGate - Validate agent grounding statements
+ *
+ * Parses agent output for grounding statements and validates them
+ * against Sigil physics rules.
+ */
+
+/**
+ * Parse grounding statement from text
+ *
+ * Looks for patterns like:
+ * - "Zone: critical"
+ * - "Effect: Financial"
+ * - "Sync: pessimistic"
+ * - "Timing: 800ms"
+ * - Physics analysis boxes
+ */
+declare function parseGroundingStatement(text: string): GroundingStatement;
+/**
+ * Validate a grounding statement
+ *
+ * @param input - Raw text or parsed statement
+ * @param options - Validation options
+ * @returns Warden validation result
+ */
+declare function validateGrounding(input: string | GroundingStatement, options?: {
+    physicsPath?: string;
+    vocabularyPath?: string;
+}): Promise<WardenResult>;
+/**
+ * Quick validation check - returns true if valid
+ */
+declare function isGroundingValid(input: string | GroundingStatement, options?: {
+    physicsPath?: string;
+    vocabularyPath?: string;
+}): Promise<boolean>;
+/**
+ * Get exit code for validation result
+ */
+declare function getExitCode(result: WardenResult): number;
+
+/**
+ * JSON-RPC helper for Anvil communication
+ *
+ * Provides type-safe RPC calls with timeout handling and error management.
+ */
+
+/** RPC error with code and message */
+declare class RpcError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+/** RPC timeout error */
+declare class RpcTimeoutError extends Error {
+    readonly method: string;
+    readonly timeoutMs: number;
+    constructor(method: string, timeoutMs: number);
+}
+/**
+ * Make a JSON-RPC call to an Anvil node
+ *
+ * @param url - RPC endpoint URL
+ * @param method - RPC method name (e.g., 'eth_blockNumber', 'evm_snapshot')
+ * @param params - Optional method parameters
+ * @param timeoutMs - Timeout in milliseconds (default: 30000)
+ * @returns Promise resolving to the result
+ * @throws {RpcError} If the RPC returns an error
+ * @throws {RpcTimeoutError} If the request times out
+ */
+declare function rpcCall<T>(url: string, method: string, params?: unknown[], timeoutMs?: number): Promise<T>;
+/**
+ * Check if an RPC endpoint is ready by calling eth_chainId
+ *
+ * @param url - RPC endpoint URL
+ * @param timeoutMs - Timeout for the check
+ * @returns Promise resolving to true if ready, false otherwise
+ */
+declare function isRpcReady(url: string, timeoutMs?: number): Promise<boolean>;
+/**
+ * Poll until RPC is ready
+ *
+ * @param url - RPC endpoint URL
+ * @param maxAttempts - Maximum number of polling attempts
+ * @param intervalMs - Interval between attempts in ms
+ * @returns Promise resolving when ready
+ * @throws Error if max attempts exceeded
+ */
+declare function waitForRpc(url: string, maxAttempts?: number, intervalMs?: number): Promise<void>;
+
+/**
+ * Anchor v4.3.1 - Ground Truth Enforcement
+ *
+ * Sigil marks intent. Anchor grounds it, enforces it, and catches every lie.
+ */
+
+declare const VERSION = "4.3.1";
+
+export { type CheckName, type CheckResult, type CheckpointConfig, CheckpointManager, type CheckpointMetadata, type ConfirmationType, type EffectType, ExitCode, type ExitCodeValue, type ExtendedCheckResult, type Fork, type ForkConfig, ForkManager, type ForkRegistry, ForkRegistrySchema, ForkSchema, type GroundingStatement, type NetworkConfig, type PhysicsRule, type PhysicsTable, RpcError, RpcTimeoutError, type Session, SessionManager, type SessionManagerConfig, type SessionMetadata, type SnapshotConfig, SnapshotManager, type SnapshotMetadata, type SyncStrategy, type Task, TaskGraph, type TaskGraphData, type TaskStatus, type TaskType, VERSION, type ValidationContext, type Vocabulary, type VocabularyEntry, type WardenInput, type WardenResult, ZONE_HIERARCHY, type Zone, clearPhysicsCache, clearVocabularyCache, generateTaskId, getCheckpointManager, getDefaultPhysics, getDefaultVocabulary, getExitCode, getForkManager, getPhysicsRule, getSessionManager, getSnapshotManager, isGroundingValid, isPhysicsCached, isRpcReady, isVocabularyCached, loadPhysics, loadVocabulary, parseGroundingStatement, resetCheckpointManager, resetForkManager, resetSessionManager, resetSnapshotManager, resetTaskCounter, resolveEffectFromKeywords, rpcCall, validateGrounding, waitForRpc };