@thehoneyjar/sigil-anchor 4.3.1

package/dist/index.js

@@ -0,0 +1,2449 @@
+import { spawn } from 'node:child_process';
+import { readFile, mkdir, writeFile, readdir, unlink, rm } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { EventEmitter } from 'eventemitter3';
+import { z } from 'zod';
+
+// src/lifecycle/fork-manager.ts
+var RpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "RpcError";
+  }
+};
+var RpcTimeoutError = class extends Error {
+  constructor(method, timeoutMs) {
+    super(`RPC call '${method}' timed out after ${timeoutMs}ms`);
+    this.method = method;
+    this.timeoutMs = timeoutMs;
+    this.name = "RpcTimeoutError";
+  }
+};
+var DEFAULT_TIMEOUT_MS = 3e4;
+var requestId = 0;
+async function rpcCall(url, method, params = [], timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  const request = {
+    jsonrpc: "2.0",
+    id: ++requestId,
+    method,
+    params
+  };
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(request),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new RpcError(-32e3, `HTTP error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new RpcError(data.error.code, data.error.message, data.error.data);
+    }
+    if (data.result === void 0) {
+      throw new RpcError(-32e3, "RPC response missing result");
+    }
+    return data.result;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new RpcTimeoutError(method, timeoutMs);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function isRpcReady(url, timeoutMs = 5e3) {
+  try {
+    await rpcCall(url, "eth_chainId", [], timeoutMs);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForRpc(url, maxAttempts = 30, intervalMs = 1e3) {
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (await isRpcReady(url)) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  throw new Error(`RPC at ${url} not ready after ${maxAttempts} attempts`);
+}
+var hexStringSchema = z.string().regex(/^0x[0-9a-fA-F]*$/);
+z.union([hexStringSchema, z.literal("latest"), z.literal("pending"), z.literal("earliest")]);
+var ForkSchema = z.object({
+  id: z.string(),
+  network: z.object({
+    name: z.string(),
+    chainId: z.number(),
+    rpcUrl: z.string()
+  }),
+  blockNumber: z.number(),
+  rpcUrl: z.string(),
+  port: z.number(),
+  pid: z.number(),
+  createdAt: z.string().transform((s) => new Date(s)),
+  sessionId: z.string().optional()
+});
+var ForkRegistrySchema = z.object({
+  forks: z.array(ForkSchema),
+  lastUpdated: z.string().transform((s) => new Date(s))
+});
+var ZONE_HIERARCHY = ["critical", "elevated", "standard", "local"];
+var ExitCode = {
+  PASS: 0,
+  DRIFT: 1,
+  DECEPTIVE: 2,
+  VIOLATION: 3,
+  REVERT: 4,
+  CORRUPT: 5,
+  SCHEMA: 6
+};
+z.object({
+  impersonatedAddress: z.string(),
+  realAddress: z.string().optional(),
+  component: z.string(),
+  observedValue: z.string().optional(),
+  onChainValue: z.string().optional(),
+  indexedValue: z.string().optional(),
+  dataSource: z.enum(["on-chain", "indexed", "mixed", "unknown"]).optional()
+});
+z.object({
+  type: z.enum(["data_source_mismatch", "stale_indexed_data", "lens_financial_check", "impersonation_leak"]),
+  severity: z.enum(["error", "warning", "info"]),
+  message: z.string(),
+  component: z.string(),
+  zone: z.enum(["critical", "elevated", "standard", "local"]).optional(),
+  expected: z.string().optional(),
+  actual: z.string().optional(),
+  suggestion: z.string().optional()
+});
+({
+  ...ExitCode});
+
+// src/lifecycle/fork-manager.ts
+var DEFAULT_PORT_START = 8545;
+var DEFAULT_PORT_END = 8600;
+var DEFAULT_REGISTRY_PATH = "grimoires/anchor/forks.json";
+var ForkManager = class extends EventEmitter {
+  forks = /* @__PURE__ */ new Map();
+  processes = /* @__PURE__ */ new Map();
+  usedPorts = /* @__PURE__ */ new Set();
+  registryPath;
+  constructor(options) {
+    super();
+    this.registryPath = options?.registryPath ?? DEFAULT_REGISTRY_PATH;
+  }
+  /**
+   * Initialize the ForkManager by loading persisted registry
+   */
+  async init() {
+    await this.loadRegistry();
+  }
+  /**
+   * Spawn a new Anvil fork
+   *
+   * @param config - Fork configuration
+   * @returns Promise resolving to the created Fork
+   */
+  async fork(config) {
+    const port = config.port ?? this.findAvailablePort();
+    const forkId = this.generateForkId();
+    const args = [
+      "--fork-url",
+      config.network.rpcUrl,
+      "--port",
+      port.toString(),
+      "--chain-id",
+      config.network.chainId.toString()
+    ];
+    if (config.blockNumber !== void 0) {
+      args.push("--fork-block-number", config.blockNumber.toString());
+    }
+    const process2 = spawn("anvil", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false
+    });
+    const pid = process2.pid;
+    if (!pid) {
+      throw new Error("Failed to spawn Anvil process");
+    }
+    const rpcUrl = `http://127.0.0.1:${port}`;
+    try {
+      await waitForRpc(rpcUrl, 30, 500);
+    } catch {
+      process2.kill();
+      throw new Error(`Anvil fork failed to become ready at ${rpcUrl}`);
+    }
+    const blockNumberHex = await rpcCall(rpcUrl, "eth_blockNumber");
+    const blockNumber = config.blockNumber ?? parseInt(blockNumberHex, 16);
+    const fork = {
+      id: forkId,
+      network: config.network,
+      blockNumber,
+      rpcUrl,
+      port,
+      pid,
+      createdAt: /* @__PURE__ */ new Date(),
+      ...config.sessionId !== void 0 && { sessionId: config.sessionId }
+    };
+    this.forks.set(forkId, fork);
+    this.processes.set(forkId, process2);
+    this.usedPorts.add(port);
+    process2.on("exit", (code) => {
+      this.handleProcessExit(forkId, code);
+    });
+    process2.on("error", (error) => {
+      this.emit("fork:error", forkId, error);
+    });
+    await this.saveRegistry();
+    this.emit("fork:created", fork);
+    return fork;
+  }
+  /**
+   * Wait for a fork to be ready
+   *
+   * @param forkId - Fork ID to wait for
+   * @param timeoutMs - Timeout in milliseconds
+   */
+  async waitForReady(forkId, timeoutMs = 3e4) {
+    const fork = this.forks.get(forkId);
+    if (!fork) {
+      throw new Error(`Fork ${forkId} not found`);
+    }
+    await waitForRpc(fork.rpcUrl, Math.ceil(timeoutMs / 500), 500);
+  }
+  /**
+   * Kill a specific fork
+   *
+   * @param forkId - Fork ID to kill
+   */
+  async kill(forkId) {
+    const process2 = this.processes.get(forkId);
+    const fork = this.forks.get(forkId);
+    if (process2) {
+      process2.kill("SIGTERM");
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      if (!process2.killed) {
+        process2.kill("SIGKILL");
+      }
+    }
+    if (fork) {
+      this.usedPorts.delete(fork.port);
+    }
+    this.forks.delete(forkId);
+    this.processes.delete(forkId);
+    await this.saveRegistry();
+  }
+  /**
+   * Kill all forks
+   */
+  async killAll() {
+    const forkIds = Array.from(this.forks.keys());
+    await Promise.all(forkIds.map((id) => this.kill(id)));
+  }
+  /**
+   * List all active forks
+   *
+   * @returns Array of active forks
+   */
+  list() {
+    return Array.from(this.forks.values());
+  }
+  /**
+   * Get a fork by ID
+   *
+   * @param forkId - Fork ID
+   * @returns Fork if found, undefined otherwise
+   */
+  get(forkId) {
+    return this.forks.get(forkId);
+  }
+  /**
+   * Export environment variables for a fork
+   *
+   * @param forkId - Fork ID
+   * @returns Environment variables object
+   */
+  exportEnv(forkId) {
+    const fork = this.forks.get(forkId);
+    if (!fork) {
+      throw new Error(`Fork ${forkId} not found`);
+    }
+    return {
+      RPC_URL: fork.rpcUrl,
+      CHAIN_ID: fork.network.chainId.toString(),
+      FORK_BLOCK: fork.blockNumber.toString(),
+      FORK_ID: fork.id
+    };
+  }
+  /**
+   * Load fork registry from disk
+   */
+  async loadRegistry() {
+    try {
+      if (!existsSync(this.registryPath)) {
+        return;
+      }
+      const content = await readFile(this.registryPath, "utf-8");
+      const data = JSON.parse(content);
+      const registry = ForkRegistrySchema.parse(data);
+      for (const registryFork of registry.forks) {
+        try {
+          process.kill(registryFork.pid, 0);
+          const fork = {
+            id: registryFork.id,
+            network: registryFork.network,
+            blockNumber: registryFork.blockNumber,
+            rpcUrl: registryFork.rpcUrl,
+            port: registryFork.port,
+            pid: registryFork.pid,
+            createdAt: registryFork.createdAt,
+            ...registryFork.sessionId !== void 0 && { sessionId: registryFork.sessionId }
+          };
+          const ready = await this.checkForkHealth(fork);
+          if (ready) {
+            this.forks.set(fork.id, fork);
+            this.usedPorts.add(fork.port);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Save fork registry to disk
+   */
+  async saveRegistry() {
+    const registry = {
+      forks: Array.from(this.forks.values()).map((fork) => ({
+        ...fork,
+        createdAt: fork.createdAt.toISOString()
+      })),
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const dir = dirname(this.registryPath);
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    await writeFile(this.registryPath, JSON.stringify(registry, null, 2));
+  }
+  /**
+   * Check if a fork is still healthy
+   */
+  async checkForkHealth(fork) {
+    try {
+      await rpcCall(fork.rpcUrl, "eth_chainId", [], 2e3);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Handle process exit
+   */
+  handleProcessExit(forkId, code) {
+    const fork = this.forks.get(forkId);
+    if (fork) {
+      this.usedPorts.delete(fork.port);
+    }
+    this.forks.delete(forkId);
+    this.processes.delete(forkId);
+    this.emit("fork:exit", forkId, code);
+    void this.saveRegistry();
+  }
+  /**
+   * Find an available port
+   */
+  findAvailablePort() {
+    for (let port = DEFAULT_PORT_START; port <= DEFAULT_PORT_END; port++) {
+      if (!this.usedPorts.has(port)) {
+        return port;
+      }
+    }
+    throw new Error("No available ports in range");
+  }
+  /**
+   * Generate a unique fork ID
+   */
+  generateForkId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `fork-${timestamp}-${random}`;
+  }
+};
+var defaultManager = null;
+function getForkManager() {
+  if (!defaultManager) {
+    defaultManager = new ForkManager();
+  }
+  return defaultManager;
+}
+function resetForkManager() {
+  defaultManager = null;
+}
+var DEFAULT_BASE_PATH = "grimoires/anchor/sessions";
+var SnapshotManager = class {
+  snapshots = /* @__PURE__ */ new Map();
+  taskToSnapshot = /* @__PURE__ */ new Map();
+  basePath;
+  sessionId = null;
+  constructor(config) {
+    this.basePath = config?.basePath ?? DEFAULT_BASE_PATH;
+  }
+  /**
+   * Initialize the manager for a session
+   *
+   * @param sessionId - Session ID to manage snapshots for
+   */
+  async init(sessionId) {
+    this.sessionId = sessionId;
+    await this.loadSnapshots();
+  }
+  /**
+   * Create a new snapshot
+   *
+   * @param config - Snapshot configuration
+   * @param rpcUrl - RPC URL of the fork
+   * @returns Promise resolving to snapshot metadata
+   */
+  async create(config, rpcUrl) {
+    const snapshotId = await rpcCall(rpcUrl, "evm_snapshot");
+    const blockNumberHex = await rpcCall(rpcUrl, "eth_blockNumber");
+    const blockNumber = parseInt(blockNumberHex, 16);
+    const metadata = {
+      id: snapshotId,
+      forkId: config.forkId,
+      sessionId: config.sessionId,
+      blockNumber,
+      createdAt: /* @__PURE__ */ new Date(),
+      ...config.taskId !== void 0 && { taskId: config.taskId },
+      ...config.description !== void 0 && { description: config.description }
+    };
+    this.snapshots.set(snapshotId, metadata);
+    if (config.taskId) {
+      this.taskToSnapshot.set(config.taskId, snapshotId);
+    }
+    await this.saveSnapshot(metadata);
+    return metadata;
+  }
+  /**
+   * 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
+   */
+  async revert(rpcUrl, snapshotId) {
+    const result = await rpcCall(rpcUrl, "evm_revert", [snapshotId]);
+    return result;
+  }
+  /**
+   * Get snapshot metadata by ID
+   *
+   * @param snapshotId - Snapshot ID
+   * @returns Snapshot metadata if found
+   */
+  get(snapshotId) {
+    return this.snapshots.get(snapshotId);
+  }
+  /**
+   * List all snapshots sorted by creation time
+   *
+   * @returns Array of snapshot metadata
+   */
+  list() {
+    return Array.from(this.snapshots.values()).sort(
+      (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
+    );
+  }
+  /**
+   * Get snapshot for a specific task
+   *
+   * @param taskId - Task ID
+   * @returns Snapshot metadata if found
+   */
+  getForTask(taskId) {
+    const snapshotId = this.taskToSnapshot.get(taskId);
+    if (!snapshotId)
+      return void 0;
+    return this.snapshots.get(snapshotId);
+  }
+  /**
+   * Get the count of snapshots
+   *
+   * @returns Number of snapshots
+   */
+  count() {
+    return this.snapshots.size;
+  }
+  /**
+   * Cleanup old snapshots, keeping the most recent
+   *
+   * @param keepLast - Number of recent snapshots to keep
+   */
+  async cleanup(keepLast) {
+    const sorted = this.list();
+    const toDelete = sorted.slice(0, -keepLast);
+    for (const snapshot of toDelete) {
+      await this.deleteSnapshot(snapshot.id);
+    }
+  }
+  /**
+   * Get snapshot directory path for current session
+   */
+  getSnapshotDir() {
+    if (!this.sessionId) {
+      throw new Error("SnapshotManager not initialized with session ID");
+    }
+    return join(this.basePath, this.sessionId, "snapshots");
+  }
+  /**
+   * Get file path for a snapshot
+   */
+  getSnapshotPath(snapshotId) {
+    return join(this.getSnapshotDir(), `${snapshotId}.json`);
+  }
+  /**
+   * Load existing snapshots from disk
+   */
+  async loadSnapshots() {
+    const dir = this.getSnapshotDir();
+    if (!existsSync(dir)) {
+      return;
+    }
+    try {
+      const files = await readdir(dir);
+      for (const file of files) {
+        if (!file.endsWith(".json"))
+          continue;
+        try {
+          const content = await readFile(join(dir, file), "utf-8");
+          const data = JSON.parse(content);
+          data.createdAt = new Date(data.createdAt);
+          this.snapshots.set(data.id, data);
+          if (data.taskId) {
+            this.taskToSnapshot.set(data.taskId, data.id);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Save snapshot metadata to disk
+   */
+  async saveSnapshot(metadata) {
+    const dir = this.getSnapshotDir();
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    await writeFile(
+      this.getSnapshotPath(metadata.id),
+      JSON.stringify(metadata, null, 2)
+    );
+  }
+  /**
+   * Delete a snapshot from memory and disk
+   */
+  async deleteSnapshot(snapshotId) {
+    const metadata = this.snapshots.get(snapshotId);
+    this.snapshots.delete(snapshotId);
+    if (metadata?.taskId) {
+      this.taskToSnapshot.delete(metadata.taskId);
+    }
+    try {
+      await unlink(this.getSnapshotPath(snapshotId));
+    } catch {
+    }
+  }
+};
+var defaultManager2 = null;
+function getSnapshotManager() {
+  if (!defaultManager2) {
+    defaultManager2 = new SnapshotManager();
+  }
+  return defaultManager2;
+}
+function resetSnapshotManager() {
+  defaultManager2 = null;
+}
+var DEFAULT_BASE_PATH2 = "grimoires/anchor/checkpoints";
+var DEFAULT_SNAPSHOT_INTERVAL = 10;
+var DEFAULT_MAX_CHECKPOINTS = 5;
+var CheckpointManager = class {
+  checkpoints = /* @__PURE__ */ new Map();
+  snapshotCount = 0;
+  firstSnapshotId = null;
+  lastSnapshotId = null;
+  basePath;
+  snapshotInterval;
+  maxCheckpoints;
+  sessionId = null;
+  forkId = null;
+  constructor(config) {
+    this.basePath = config?.basePath ?? DEFAULT_BASE_PATH2;
+    this.snapshotInterval = config?.snapshotInterval ?? DEFAULT_SNAPSHOT_INTERVAL;
+    this.maxCheckpoints = config?.maxCheckpoints ?? DEFAULT_MAX_CHECKPOINTS;
+  }
+  /**
+   * Initialize the manager for a session
+   *
+   * @param sessionId - Session ID
+   * @param forkId - Fork ID
+   */
+  async init(sessionId, forkId) {
+    this.sessionId = sessionId;
+    this.forkId = forkId;
+    await this.loadCheckpoints();
+  }
+  /**
+   * 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
+   */
+  async onSnapshot(snapshotId, rpcUrl) {
+    this.snapshotCount++;
+    if (!this.firstSnapshotId) {
+      this.firstSnapshotId = snapshotId;
+    }
+    this.lastSnapshotId = snapshotId;
+    if (this.snapshotCount >= this.snapshotInterval) {
+      await this.create(rpcUrl);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Create a checkpoint by exporting state
+   *
+   * @param rpcUrl - RPC URL of the fork
+   * @returns Checkpoint metadata
+   */
+  async create(rpcUrl) {
+    if (!this.sessionId || !this.forkId) {
+      throw new Error("CheckpointManager not initialized");
+    }
+    const state = await rpcCall(rpcUrl, "anvil_dumpState");
+    const blockNumberHex = await rpcCall(rpcUrl, "eth_blockNumber");
+    const blockNumber = parseInt(blockNumberHex, 16);
+    const checkpointId = this.generateCheckpointId();
+    const metadata = {
+      id: checkpointId,
+      sessionId: this.sessionId,
+      forkId: this.forkId,
+      snapshotRange: {
+        first: this.firstSnapshotId ?? "",
+        last: this.lastSnapshotId ?? ""
+      },
+      blockNumber,
+      createdAt: /* @__PURE__ */ new Date(),
+      snapshotCount: this.snapshotCount
+    };
+    await this.saveCheckpoint(checkpointId, state, metadata);
+    this.checkpoints.set(checkpointId, metadata);
+    this.snapshotCount = 0;
+    this.firstSnapshotId = null;
+    this.lastSnapshotId = null;
+    await this.cleanup();
+    return metadata;
+  }
+  /**
+   * Restore from a checkpoint
+   *
+   * @param checkpointId - Checkpoint ID to restore
+   * @param forkManager - ForkManager instance
+   * @param network - Network configuration
+   * @returns New fork with restored state
+   */
+  async restore(checkpointId, forkManager, network) {
+    if (!this.sessionId) {
+      throw new Error("CheckpointManager not initialized");
+    }
+    const checkpoint = this.checkpoints.get(checkpointId);
+    if (!checkpoint) {
+      throw new Error(`Checkpoint ${checkpointId} not found`);
+    }
+    const statePath = this.getStatePath(checkpointId);
+    const state = await readFile(statePath, "utf-8");
+    await forkManager.killAll();
+    const fork = await forkManager.fork({
+      network,
+      blockNumber: checkpoint.blockNumber,
+      sessionId: this.sessionId
+    });
+    await rpcCall(fork.rpcUrl, "anvil_loadState", [state]);
+    this.forkId = fork.id;
+    return fork;
+  }
+  /**
+   * Find the checkpoint containing a specific snapshot
+   *
+   * @param snapshotId - Snapshot ID to find
+   * @returns Checkpoint metadata if found
+   */
+  findCheckpointForSnapshot(snapshotId) {
+    const sorted = this.list().sort(
+      (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
+    );
+    for (const checkpoint of sorted) {
+      if (checkpoint.snapshotRange.first <= snapshotId && checkpoint.snapshotRange.last >= snapshotId) {
+        return checkpoint;
+      }
+    }
+    return sorted[0];
+  }
+  /**
+   * Get checkpoint by ID
+   *
+   * @param checkpointId - Checkpoint ID
+   * @returns Checkpoint metadata if found
+   */
+  get(checkpointId) {
+    return this.checkpoints.get(checkpointId);
+  }
+  /**
+   * List all checkpoints sorted by time
+   *
+   * @returns Array of checkpoint metadata
+   */
+  list() {
+    return Array.from(this.checkpoints.values()).sort(
+      (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
+    );
+  }
+  /**
+   * Get the latest checkpoint
+   *
+   * @returns Latest checkpoint metadata
+   */
+  latest() {
+    const sorted = this.list();
+    return sorted[sorted.length - 1];
+  }
+  /**
+   * Cleanup old checkpoints, keeping only the most recent
+   */
+  async cleanup() {
+    const sorted = this.list();
+    if (sorted.length <= this.maxCheckpoints) {
+      return;
+    }
+    const toDelete = sorted.slice(0, sorted.length - this.maxCheckpoints);
+    for (const checkpoint of toDelete) {
+      await this.deleteCheckpoint(checkpoint.id);
+    }
+  }
+  /**
+   * Get session directory path
+   */
+  getSessionDir() {
+    if (!this.sessionId) {
+      throw new Error("Session ID not set");
+    }
+    return join(this.basePath, this.sessionId);
+  }
+  /**
+   * Get checkpoint directory path
+   */
+  getCheckpointDir(checkpointId) {
+    return join(this.getSessionDir(), checkpointId);
+  }
+  /**
+   * Get state file path
+   */
+  getStatePath(checkpointId) {
+    return join(this.getCheckpointDir(checkpointId), "state.json");
+  }
+  /**
+   * Get metadata file path
+   */
+  getMetaPath(checkpointId) {
+    return join(this.getCheckpointDir(checkpointId), "meta.json");
+  }
+  /**
+   * Load checkpoints from disk
+   */
+  async loadCheckpoints() {
+    const dir = this.getSessionDir();
+    if (!existsSync(dir)) {
+      return;
+    }
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        const metaPath = this.getMetaPath(entry.name);
+        if (!existsSync(metaPath))
+          continue;
+        try {
+          const content = await readFile(metaPath, "utf-8");
+          const data = JSON.parse(content);
+          data.createdAt = new Date(data.createdAt);
+          this.checkpoints.set(data.id, data);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Save checkpoint to disk
+   */
+  async saveCheckpoint(checkpointId, state, metadata) {
+    const dir = this.getCheckpointDir(checkpointId);
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    await writeFile(this.getStatePath(checkpointId), state);
+    await writeFile(this.getMetaPath(checkpointId), JSON.stringify(metadata, null, 2));
+  }
+  /**
+   * Delete a checkpoint from disk
+   */
+  async deleteCheckpoint(checkpointId) {
+    this.checkpoints.delete(checkpointId);
+    const dir = this.getCheckpointDir(checkpointId);
+    if (existsSync(dir)) {
+      await rm(dir, { recursive: true });
+    }
+  }
+  /**
+   * Generate a unique checkpoint ID
+   */
+  generateCheckpointId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 6);
+    return `cp-${timestamp}-${random}`;
+  }
+};
+var defaultManager3 = null;
+function getCheckpointManager() {
+  if (!defaultManager3) {
+    defaultManager3 = new CheckpointManager();
+  }
+  return defaultManager3;
+}
+function resetCheckpointManager() {
+  defaultManager3 = null;
+}
+var TaskSchema = z.object({
+  id: z.string(),
+  type: z.enum(["fork", "ground", "warden", "generate", "validate", "write"]),
+  status: z.enum(["pending", "running", "complete", "blocked", "failed"]),
+  snapshotId: z.string().optional(),
+  checkpointId: z.string().optional(),
+  dependencies: z.array(z.string()),
+  input: z.unknown(),
+  output: z.unknown().optional(),
+  error: z.string().optional(),
+  createdAt: z.string().transform((s) => new Date(s)),
+  completedAt: z.string().transform((s) => new Date(s)).optional()
+});
+var TaskGraphDataSchema = z.object({
+  sessionId: z.string(),
+  tasks: z.array(TaskSchema),
+  headTaskId: z.string().optional(),
+  lastUpdated: z.string().transform((s) => new Date(s))
+});
+var DEFAULT_BASE_PATH3 = "grimoires/anchor/sessions";
+var taskCounter = 0;
+function generateTaskId(type) {
+  return `${type}-${Date.now().toString(36)}-${(++taskCounter).toString(36)}`;
+}
+function resetTaskCounter() {
+  taskCounter = 0;
+}
+var TaskGraph = class {
+  tasks = /* @__PURE__ */ new Map();
+  dependents = /* @__PURE__ */ new Map();
+  sessionId;
+  basePath;
+  autoSave;
+  headTaskId;
+  constructor(config) {
+    this.sessionId = config.sessionId;
+    this.basePath = config.basePath ?? DEFAULT_BASE_PATH3;
+    this.autoSave = config.autoSave ?? true;
+  }
+  /**
+   * Initialize the graph by loading persisted state
+   */
+  async init() {
+    await this.load();
+  }
+  /**
+   * Add a task to the graph
+   *
+   * @param task - Task to add
+   */
+  async addTask(task) {
+    this.validateNoCycle(task);
+    this.tasks.set(task.id, task);
+    for (const depId of task.dependencies) {
+      if (!this.dependents.has(depId)) {
+        this.dependents.set(depId, /* @__PURE__ */ new Set());
+      }
+      this.dependents.get(depId).add(task.id);
+    }
+    this.headTaskId = task.id;
+    if (this.autoSave) {
+      await this.save();
+    }
+  }
+  /**
+   * Update task status
+   *
+   * @param taskId - Task ID
+   * @param status - New status
+   */
+  async updateStatus(taskId, status) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    task.status = status;
+    if (status === "complete" || status === "failed") {
+      task.completedAt = /* @__PURE__ */ new Date();
+    }
+    if (this.autoSave) {
+      await this.save();
+    }
+  }
+  /**
+   * Set the snapshot binding for a task
+   *
+   * @param taskId - Task ID
+   * @param snapshotId - Snapshot ID
+   */
+  async setSnapshot(taskId, snapshotId) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    task.snapshotId = snapshotId;
+    if (this.autoSave) {
+      await this.save();
+    }
+  }
+  /**
+   * Set the checkpoint binding for a task
+   *
+   * @param taskId - Task ID
+   * @param checkpointId - Checkpoint ID
+   */
+  async setCheckpoint(taskId, checkpointId) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    task.checkpointId = checkpointId;
+    if (this.autoSave) {
+      await this.save();
+    }
+  }
+  /**
+   * Set task output
+   *
+   * @param taskId - Task ID
+   * @param output - Task output
+   */
+  async setOutput(taskId, output) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    task.output = output;
+    if (this.autoSave) {
+      await this.save();
+    }
+  }
+  /**
+   * Set task error
+   *
+   * @param taskId - Task ID
+   * @param error - Error message
+   */
+  async setError(taskId, error) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    task.error = error;
+    task.status = "failed";
+    if (this.autoSave) {
+      await this.save();
+    }
+  }
+  /**
+   * Get a task by ID
+   *
+   * @param taskId - Task ID
+   * @returns Task if found
+   */
+  getTask(taskId) {
+    return this.tasks.get(taskId);
+  }
+  /**
+   * Get all tasks
+   *
+   * @returns Array of all tasks
+   */
+  getAllTasks() {
+    return Array.from(this.tasks.values());
+  }
+  /**
+   * Get tasks by status
+   *
+   * @param status - Status to filter by
+   * @returns Array of matching tasks
+   */
+  getTasksByStatus(status) {
+    return Array.from(this.tasks.values()).filter((t) => t.status === status);
+  }
+  /**
+   * Check if a task can run (all dependencies complete)
+   *
+   * @param taskId - Task ID
+   * @returns True if all dependencies are complete
+   */
+  canRun(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task)
+      return false;
+    if (task.status !== "pending")
+      return false;
+    for (const depId of task.dependencies) {
+      const dep = this.tasks.get(depId);
+      if (!dep || dep.status !== "complete") {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Get the next runnable task (pending with all deps complete)
+   *
+   * @returns Next runnable task or undefined
+   */
+  getNextRunnable() {
+    for (const task of this.tasks.values()) {
+      if (this.canRun(task.id)) {
+        return task;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Propagate blocked status to all dependents of a failed task
+   *
+   * @param taskId - ID of the failed task
+   */
+  async propagateBlocked(taskId) {
+    const dependentIds = this.dependents.get(taskId);
+    if (!dependentIds)
+      return;
+    for (const depId of dependentIds) {
+      const task = this.tasks.get(depId);
+      if (task && task.status === "pending") {
+        task.status = "blocked";
+        await this.propagateBlocked(depId);
+      }
+    }
+    if (this.autoSave) {
+      await this.save();
+    }
+  }
+  /**
+   * 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) {
+    const task = this.tasks.get(taskId);
+    if (!task)
+      return void 0;
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [...task.dependencies];
+    let bestRecovery;
+    while (queue.length > 0) {
+      const id = queue.pop();
+      if (visited.has(id))
+        continue;
+      visited.add(id);
+      const dep = this.tasks.get(id);
+      if (!dep)
+        continue;
+      if (dep.status === "complete" && dep.snapshotId) {
+        if (!bestRecovery || dep.createdAt > bestRecovery.createdAt) {
+          bestRecovery = dep;
+        }
+      }
+      queue.push(...dep.dependencies);
+    }
+    return bestRecovery;
+  }
+  /**
+   * Check if there are any blocked tasks
+   *
+   * @returns True if any tasks are blocked
+   */
+  hasBlocked() {
+    for (const task of this.tasks.values()) {
+      if (task.status === "blocked") {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if all tasks are complete
+   *
+   * @returns True if all tasks are complete
+   */
+  isComplete() {
+    for (const task of this.tasks.values()) {
+      if (task.status !== "complete") {
+        return false;
+      }
+    }
+    return this.tasks.size > 0;
+  }
+  /**
+   * Get the graph file path
+   */
+  getGraphPath() {
+    return join(this.basePath, this.sessionId, "graph.json");
+  }
+  /**
+   * Export graph data as JSON-serializable object
+   *
+   * @returns Task graph data
+   */
+  toJSON() {
+    return {
+      sessionId: this.sessionId,
+      tasks: Array.from(this.tasks.values()),
+      lastUpdated: /* @__PURE__ */ new Date(),
+      ...this.headTaskId !== void 0 && { headTaskId: this.headTaskId }
+    };
+  }
+  /**
+   * Save the graph to disk
+   */
+  async save() {
+    const data = this.toJSON();
+    const path = this.getGraphPath();
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    await writeFile(path, JSON.stringify(data, null, 2));
+  }
+  /**
+   * Load the graph from disk
+   */
+  async load() {
+    const path = this.getGraphPath();
+    if (!existsSync(path)) {
+      return;
+    }
+    try {
+      const content = await readFile(path, "utf-8");
+      const raw = JSON.parse(content);
+      const data = TaskGraphDataSchema.parse(raw);
+      this.tasks.clear();
+      this.dependents.clear();
+      for (const task of data.tasks) {
+        this.tasks.set(task.id, task);
+        for (const depId of task.dependencies) {
+          if (!this.dependents.has(depId)) {
+            this.dependents.set(depId, /* @__PURE__ */ new Set());
+          }
+          this.dependents.get(depId).add(task.id);
+        }
+      }
+      this.headTaskId = data.headTaskId;
+    } catch {
+    }
+  }
+  /**
+   * Validate that adding a task doesn't create a cycle
+   */
+  validateNoCycle(newTask) {
+    const visited = /* @__PURE__ */ new Set();
+    const stack = /* @__PURE__ */ new Set();
+    const hasCycle = (taskId) => {
+      if (stack.has(taskId))
+        return true;
+      if (visited.has(taskId))
+        return false;
+      visited.add(taskId);
+      stack.add(taskId);
+      const task = taskId === newTask.id ? newTask : this.tasks.get(taskId);
+      if (task) {
+        for (const depId of task.dependencies) {
+          if (hasCycle(depId))
+            return true;
+        }
+      }
+      stack.delete(taskId);
+      return false;
+    };
+    if (hasCycle(newTask.id)) {
+      throw new Error(`Adding task ${newTask.id} would create a circular dependency`);
+    }
+  }
+};
+
+// src/lifecycle/session-manager.ts
+var DEFAULT_BASE_PATH4 = "grimoires/anchor/sessions";
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  currentSession = null;
+  basePath;
+  constructor(config) {
+    this.basePath = config?.basePath ?? DEFAULT_BASE_PATH4;
+  }
+  /**
+   * Initialize the manager by loading session index
+   */
+  async init() {
+    await this.loadSessionIndex();
+  }
+  /**
+   * Create a new session
+   *
+   * @param network - Network to fork
+   * @param options - Session options
+   * @returns Created session
+   */
+  async create(network, options) {
+    const sessionId = this.generateSessionId();
+    const forkManager = new ForkManager();
+    await forkManager.init();
+    const fork = await forkManager.fork({
+      network,
+      sessionId,
+      ...options?.blockNumber !== void 0 && { blockNumber: options.blockNumber }
+    });
+    const snapshotManager = new SnapshotManager();
+    await snapshotManager.init(sessionId);
+    const checkpointManager = new CheckpointManager();
+    await checkpointManager.init(sessionId, fork.id);
+    const taskGraph = new TaskGraph({
+      sessionId,
+      basePath: this.basePath,
+      autoSave: true
+    });
+    await taskGraph.init();
+    const initialSnapshot = await snapshotManager.create(
+      {
+        forkId: fork.id,
+        sessionId,
+        description: "Initial session snapshot"
+      },
+      fork.rpcUrl
+    );
+    const forkTask = {
+      id: `fork-${fork.id}`,
+      type: "fork",
+      status: "complete",
+      snapshotId: initialSnapshot.id,
+      dependencies: [],
+      input: { network, blockNumber: fork.blockNumber },
+      output: { forkId: fork.id, rpcUrl: fork.rpcUrl },
+      createdAt: /* @__PURE__ */ new Date(),
+      completedAt: /* @__PURE__ */ new Date()
+    };
+    await taskGraph.addTask(forkTask);
+    const metadata = {
+      id: sessionId,
+      network,
+      forkId: fork.id,
+      createdAt: /* @__PURE__ */ new Date(),
+      lastActivity: /* @__PURE__ */ new Date(),
+      status: "active",
+      initialBlock: fork.blockNumber
+    };
+    this.sessions.set(sessionId, metadata);
+    await this.saveSession(metadata);
+    await this.saveSessionIndex();
+    this.currentSession = {
+      metadata,
+      fork,
+      forkManager,
+      snapshotManager,
+      checkpointManager,
+      taskGraph
+    };
+    return this.currentSession;
+  }
+  /**
+   * Resume an existing session
+   *
+   * @param sessionId - Session ID to resume
+   * @returns Resumed session
+   */
+  async resume(sessionId) {
+    const metadata = this.sessions.get(sessionId);
+    if (!metadata) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    const forkManager = new ForkManager();
+    await forkManager.init();
+    const snapshotManager = new SnapshotManager();
+    await snapshotManager.init(sessionId);
+    const checkpointManager = new CheckpointManager();
+    const taskGraph = new TaskGraph({
+      sessionId,
+      basePath: this.basePath,
+      autoSave: true
+    });
+    await taskGraph.init();
+    let fork = forkManager.get(metadata.forkId);
+    if (!fork || taskGraph.hasBlocked()) {
+      fork = await this.recover(
+        sessionId,
+        metadata,
+        forkManager,
+        snapshotManager,
+        checkpointManager,
+        taskGraph
+      );
+    }
+    if (!fork) {
+      throw new Error(`Failed to restore fork for session ${sessionId}`);
+    }
+    await checkpointManager.init(sessionId, fork.id);
+    metadata.lastActivity = /* @__PURE__ */ new Date();
+    metadata.forkId = fork.id;
+    metadata.status = "active";
+    await this.saveSession(metadata);
+    this.currentSession = {
+      metadata,
+      fork,
+      forkManager,
+      snapshotManager,
+      checkpointManager,
+      taskGraph
+    };
+    return this.currentSession;
+  }
+  /**
+   * Recover a session from checkpoint or snapshot
+   */
+  async recover(sessionId, metadata, forkManager, snapshotManager, checkpointManager, taskGraph) {
+    const latestCheckpoint = checkpointManager.latest();
+    if (latestCheckpoint) {
+      console.log(`Recovering session ${sessionId} from checkpoint ${latestCheckpoint.id}`);
+      return await checkpointManager.restore(
+        latestCheckpoint.id,
+        forkManager,
+        metadata.network
+      );
+    }
+    const blockedTasks = taskGraph.getTasksByStatus("blocked");
+    const failedTasks = taskGraph.getTasksByStatus("failed");
+    const problematicTask = blockedTasks[0] ?? failedTasks[0];
+    if (problematicTask) {
+      const recoveryPoint = taskGraph.findRecoveryPoint(problematicTask.id);
+      if (recoveryPoint?.snapshotId) {
+        const fork = await forkManager.fork({
+          network: metadata.network,
+          blockNumber: metadata.initialBlock,
+          sessionId
+        });
+        const success = await snapshotManager.revert(fork.rpcUrl, recoveryPoint.snapshotId);
+        if (!success) {
+          throw new Error(`Failed to revert to snapshot ${recoveryPoint.snapshotId}`);
+        }
+        for (const task of [...blockedTasks, ...failedTasks]) {
+          await taskGraph.updateStatus(task.id, "pending");
+        }
+        return fork;
+      }
+    }
+    console.log(`No recovery point found, creating fresh fork for session ${sessionId}`);
+    return await forkManager.fork({
+      network: metadata.network,
+      blockNumber: metadata.initialBlock,
+      sessionId
+    });
+  }
+  /**
+   * Get current session
+   *
+   * @returns Current session or null
+   */
+  current() {
+    return this.currentSession;
+  }
+  /**
+   * List all sessions
+   *
+   * @param filter - Optional filter for status
+   * @returns Array of session metadata
+   */
+  list(filter) {
+    let sessions = Array.from(this.sessions.values());
+    if (filter?.status) {
+      sessions = sessions.filter((s) => s.status === filter.status);
+    }
+    return sessions.sort((a, b) => b.lastActivity.getTime() - a.lastActivity.getTime());
+  }
+  /**
+   * Get session by ID
+   *
+   * @param sessionId - Session ID
+   * @returns Session metadata if found
+   */
+  get(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  /**
+   * Update session status
+   *
+   * @param sessionId - Session ID
+   * @param status - New status
+   */
+  async updateStatus(sessionId, status) {
+    const metadata = this.sessions.get(sessionId);
+    if (!metadata) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+    metadata.status = status;
+    metadata.lastActivity = /* @__PURE__ */ new Date();
+    await this.saveSession(metadata);
+  }
+  /**
+   * Get session directory path
+   */
+  getSessionDir(sessionId) {
+    return join(this.basePath, sessionId);
+  }
+  /**
+   * Get session metadata path
+   */
+  getSessionPath(sessionId) {
+    return join(this.getSessionDir(sessionId), "session.json");
+  }
+  /**
+   * Load session index
+   */
+  async loadSessionIndex() {
+    if (!existsSync(this.basePath)) {
+      return;
+    }
+    try {
+      const entries = await readdir(this.basePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        const sessionPath = this.getSessionPath(entry.name);
+        if (!existsSync(sessionPath))
+          continue;
+        try {
+          const content = await readFile(sessionPath, "utf-8");
+          const data = JSON.parse(content);
+          data.createdAt = new Date(data.createdAt);
+          data.lastActivity = new Date(data.lastActivity);
+          this.sessions.set(data.id, data);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Save session index
+   */
+  async saveSessionIndex() {
+    if (!existsSync(this.basePath)) {
+      await mkdir(this.basePath, { recursive: true });
+    }
+    const index = Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      status: s.status,
+      lastActivity: s.lastActivity
+    }));
+    await writeFile(
+      join(this.basePath, "index.json"),
+      JSON.stringify(index, null, 2)
+    );
+  }
+  /**
+   * Save session metadata
+   */
+  async saveSession(metadata) {
+    const dir = this.getSessionDir(metadata.id);
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    await writeFile(this.getSessionPath(metadata.id), JSON.stringify(metadata, null, 2));
+  }
+  /**
+   * Generate unique session ID
+   */
+  generateSessionId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 6);
+    return `session-${timestamp}-${random}`;
+  }
+};
+var defaultManager4 = null;
+function getSessionManager() {
+  if (!defaultManager4) {
+    defaultManager4 = new SessionManager();
+  }
+  return defaultManager4;
+}
+function resetSessionManager() {
+  defaultManager4 = null;
+}
+var DEFAULT_PHYSICS_PATH = ".claude/rules/01-sigil-physics.md";
+var cachedPhysics = null;
+var cachedPath = null;
+function parseSyncStrategy(value) {
+  const normalized = value.toLowerCase().trim();
+  if (normalized === "pessimistic")
+    return "pessimistic";
+  if (normalized === "optimistic")
+    return "optimistic";
+  if (normalized === "immediate")
+    return "immediate";
+  return "optimistic";
+}
+function parseTiming(value) {
+  const match = value.match(/(\d+)\s*ms/i);
+  if (match && match[1]) {
+    return parseInt(match[1], 10);
+  }
+  const num = parseInt(value, 10);
+  return isNaN(num) ? 200 : num;
+}
+function parseConfirmation(value) {
+  const normalized = value.toLowerCase().trim();
+  if (normalized === "required" || normalized === "yes")
+    return "required";
+  if (normalized.includes("toast") || normalized.includes("undo"))
+    return "toast_undo";
+  if (normalized === "none" || normalized === "no")
+    return "none";
+  return "none";
+}
+function parseEffectType(value) {
+  const normalized = value.toLowerCase().replace(/[\s-]/g, "_").trim();
+  const mapping = {
+    financial: "financial",
+    destructive: "destructive",
+    soft_delete: "soft_delete",
+    "soft delete": "soft_delete",
+    standard: "standard",
+    navigation: "navigation",
+    query: "query",
+    local_state: "local",
+    "local state": "local",
+    local: "local",
+    high_freq: "high_freq",
+    "high-freq": "high_freq",
+    highfreq: "high_freq"
+  };
+  return mapping[normalized] ?? null;
+}
+function parsePhysicsTable(content) {
+  const physics = /* @__PURE__ */ new Map();
+  const tableMatch = content.match(
+    /<physics_table>[\s\S]*?\|[\s\S]*?<\/physics_table>/
+  );
+  if (!tableMatch) {
+    console.warn("Physics table not found in content");
+    return getDefaultPhysics();
+  }
+  const tableContent = tableMatch[0];
+  const lines = tableContent.split("\n");
+  for (const line of lines) {
+    if (!line.includes("|") || line.includes("---") || line.includes("Effect")) {
+      continue;
+    }
+    const cells = line.split("|").map((c) => c.trim()).filter((c) => c.length > 0);
+    if (cells.length < 4)
+      continue;
+    const effectStr = cells[0];
+    const syncStr = cells[1];
+    const timingStr = cells[2];
+    const confirmStr = cells[3];
+    const whyParts = cells.slice(4);
+    if (!effectStr || !syncStr || !timingStr || !confirmStr)
+      continue;
+    const effect = parseEffectType(effectStr);
+    if (!effect)
+      continue;
+    const rule = {
+      effect,
+      sync: parseSyncStrategy(syncStr),
+      timing: parseTiming(timingStr),
+      confirmation: parseConfirmation(confirmStr),
+      rationale: whyParts.join(" ").trim()
+    };
+    physics.set(effect, rule);
+  }
+  return physics;
+}
+function getDefaultPhysics() {
+  const physics = /* @__PURE__ */ new Map();
+  physics.set("financial", {
+    effect: "financial",
+    sync: "pessimistic",
+    timing: 800,
+    confirmation: "required",
+    rationale: "Money can't roll back. Users need time to verify."
+  });
+  physics.set("destructive", {
+    effect: "destructive",
+    sync: "pessimistic",
+    timing: 600,
+    confirmation: "required",
+    rationale: "Permanent actions need deliberation."
+  });
+  physics.set("soft_delete", {
+    effect: "soft_delete",
+    sync: "optimistic",
+    timing: 200,
+    confirmation: "toast_undo",
+    rationale: "Undo exists, so we can be fast."
+  });
+  physics.set("standard", {
+    effect: "standard",
+    sync: "optimistic",
+    timing: 200,
+    confirmation: "none",
+    rationale: "Low stakes = snappy feedback."
+  });
+  physics.set("navigation", {
+    effect: "navigation",
+    sync: "immediate",
+    timing: 150,
+    confirmation: "none",
+    rationale: "URL changes feel instant."
+  });
+  physics.set("query", {
+    effect: "query",
+    sync: "optimistic",
+    timing: 150,
+    confirmation: "none",
+    rationale: "Data retrieval, no state change."
+  });
+  physics.set("local", {
+    effect: "local",
+    sync: "immediate",
+    timing: 100,
+    confirmation: "none",
+    rationale: "No server = instant expected."
+  });
+  physics.set("high_freq", {
+    effect: "high_freq",
+    sync: "immediate",
+    timing: 0,
+    confirmation: "none",
+    rationale: "Animation becomes friction."
+  });
+  return physics;
+}
+async function loadPhysics(path) {
+  const physicsPath = path ?? DEFAULT_PHYSICS_PATH;
+  if (cachedPhysics && cachedPath === physicsPath) {
+    return cachedPhysics;
+  }
+  if (!existsSync(physicsPath)) {
+    console.warn(`Physics file not found at ${physicsPath}, using defaults`);
+    cachedPhysics = getDefaultPhysics();
+    cachedPath = physicsPath;
+    return cachedPhysics;
+  }
+  try {
+    const content = await readFile(physicsPath, "utf-8");
+    cachedPhysics = parsePhysicsTable(content);
+    cachedPath = physicsPath;
+    if (cachedPhysics.size === 0) {
+      console.warn("No physics rules parsed, using defaults");
+      cachedPhysics = getDefaultPhysics();
+    }
+    return cachedPhysics;
+  } catch (error) {
+    console.warn(`Error loading physics from ${physicsPath}:`, error);
+    cachedPhysics = getDefaultPhysics();
+    cachedPath = physicsPath;
+    return cachedPhysics;
+  }
+}
+async function getPhysicsRule(effect, physics) {
+  const table = physics ?? await loadPhysics();
+  return table.get(effect);
+}
+function clearPhysicsCache() {
+  cachedPhysics = null;
+  cachedPath = null;
+}
+function isPhysicsCached() {
+  return cachedPhysics !== null;
+}
+var DEFAULT_VOCABULARY_PATH = ".claude/rules/08-sigil-lexicon.md";
+var cachedVocabulary = null;
+var cachedPath2 = null;
+function parseKeywordsFromBlock(block) {
+  const keywords = [];
+  const lines = block.split("\n");
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    const content = colonIndex >= 0 ? line.slice(colonIndex + 1) : line;
+    const words = content.split(/[,\s]+/).map((w) => w.trim().toLowerCase()).filter((w) => w.length > 0 && !w.includes("```"));
+    keywords.push(...words);
+  }
+  return [...new Set(keywords)];
+}
+function parseEffectKeywords(content) {
+  const effects = /* @__PURE__ */ new Map();
+  const sectionMatch = content.match(
+    /<effect_keywords>[\s\S]*?<\/effect_keywords>/
+  );
+  if (!sectionMatch) {
+    return effects;
+  }
+  const section = sectionMatch[0];
+  const effectPatterns = [
+    {
+      effect: "financial",
+      pattern: /###\s*Financial[\s\S]*?```([\s\S]*?)```/i
+    },
+    {
+      effect: "destructive",
+      pattern: /###\s*Destructive[\s\S]*?```([\s\S]*?)```/i
+    },
+    {
+      effect: "soft_delete",
+      pattern: /###\s*Soft\s*Delete[\s\S]*?```([\s\S]*?)```/i
+    },
+    {
+      effect: "standard",
+      pattern: /###\s*Standard[\s\S]*?```([\s\S]*?)```/i
+    },
+    {
+      effect: "local",
+      pattern: /###\s*Local\s*State[\s\S]*?```([\s\S]*?)```/i
+    },
+    {
+      effect: "navigation",
+      pattern: /###\s*Navigation[\s\S]*?```([\s\S]*?)```/i
+    },
+    {
+      effect: "query",
+      pattern: /###\s*Query[\s\S]*?```([\s\S]*?)```/i
+    }
+  ];
+  for (const { effect, pattern } of effectPatterns) {
+    const match = section.match(pattern);
+    if (match && match[1]) {
+      const keywords = parseKeywordsFromBlock(match[1]);
+      if (keywords.length > 0) {
+        effects.set(effect, {
+          keywords,
+          effect,
+          category: "lexicon"
+        });
+      }
+    }
+  }
+  return effects;
+}
+function parseTypeOverrides(content) {
+  const overrides = /* @__PURE__ */ new Map();
+  const sectionMatch = content.match(
+    /<type_overrides>[\s\S]*?<\/type_overrides>/
+  );
+  if (!sectionMatch) {
+    return overrides;
+  }
+  const section = sectionMatch[0];
+  const lines = section.split("\n");
+  for (const line of lines) {
+    if (!line.includes("|") || line.includes("---") || line.includes("Type Pattern")) {
+      continue;
+    }
+    const cells = line.split("|").map((c) => c.trim()).filter((c) => c.length > 0);
+    if (cells.length < 2)
+      continue;
+    const typePattern = cells[0];
+    const forcedEffect = cells[1];
+    if (!typePattern || !forcedEffect)
+      continue;
+    const types = typePattern.replace(/`/g, "").split(",").map((t) => t.trim().toLowerCase()).filter((t) => t.length > 0);
+    const effect = mapEffectString(forcedEffect);
+    if (effect) {
+      for (const type of types) {
+        overrides.set(type, effect);
+      }
+    }
+  }
+  return overrides;
+}
+function parseDomainDefaults(content) {
+  const defaults = /* @__PURE__ */ new Map();
+  const sectionMatch = content.match(
+    /<domain_context>[\s\S]*?<\/domain_context>/
+  );
+  if (!sectionMatch) {
+    return defaults;
+  }
+  const section = sectionMatch[0];
+  const domainHeaderPattern = /###\s*([\w\/]+)\s*\n```([\s\S]*?)```/gi;
+  let match;
+  while ((match = domainHeaderPattern.exec(section)) !== null) {
+    const domainName = match[1];
+    const domainContent = match[2];
+    if (!domainName || !domainContent)
+      continue;
+    const defaultMatch = domainContent.match(/Default:\s*([\w\s()]+)/i);
+    if (defaultMatch && defaultMatch[1]) {
+      const effect = mapEffectString(defaultMatch[1]);
+      if (effect) {
+        const keywordMatch = domainContent.match(/Keywords:\s*([\w,\s]+)/i);
+        if (keywordMatch && keywordMatch[1]) {
+          const keywords = keywordMatch[1].split(",").map((k) => k.trim().toLowerCase()).filter((k) => k.length > 0);
+          for (const keyword of keywords) {
+            defaults.set(keyword, effect);
+          }
+        }
+        defaults.set(domainName.toLowerCase().replace("/", "_"), effect);
+      }
+    }
+  }
+  return defaults;
+}
+function mapEffectString(value) {
+  const normalized = value.toLowerCase().trim();
+  if (normalized.includes("financial"))
+    return "financial";
+  if (normalized.includes("destructive"))
+    return "destructive";
+  if (normalized.includes("soft") && normalized.includes("delete"))
+    return "soft_delete";
+  if (normalized.includes("standard"))
+    return "standard";
+  if (normalized.includes("local"))
+    return "local";
+  if (normalized.includes("navigation"))
+    return "navigation";
+  if (normalized.includes("query"))
+    return "query";
+  if (normalized.includes("immediate"))
+    return "local";
+  return null;
+}
+function getDefaultVocabulary() {
+  const effects = /* @__PURE__ */ new Map();
+  effects.set("financial", {
+    keywords: [
+      "claim",
+      "deposit",
+      "withdraw",
+      "transfer",
+      "swap",
+      "send",
+      "pay",
+      "purchase",
+      "mint",
+      "burn",
+      "stake",
+      "unstake",
+      "bridge",
+      "approve",
+      "redeem",
+      "harvest"
+    ],
+    effect: "financial",
+    category: "default"
+  });
+  effects.set("destructive", {
+    keywords: [
+      "delete",
+      "remove",
+      "destroy",
+      "revoke",
+      "terminate",
+      "purge",
+      "erase",
+      "wipe"
+    ],
+    effect: "destructive",
+    category: "default"
+  });
+  effects.set("soft_delete", {
+    keywords: ["archive", "hide", "trash", "dismiss", "snooze", "mute"],
+    effect: "soft_delete",
+    category: "default"
+  });
+  effects.set("standard", {
+    keywords: [
+      "save",
+      "update",
+      "edit",
+      "create",
+      "add",
+      "like",
+      "follow",
+      "bookmark"
+    ],
+    effect: "standard",
+    category: "default"
+  });
+  effects.set("local", {
+    keywords: ["toggle", "switch", "expand", "collapse", "select", "focus"],
+    effect: "local",
+    category: "default"
+  });
+  effects.set("navigation", {
+    keywords: ["navigate", "go", "back", "forward", "link", "route"],
+    effect: "navigation",
+    category: "default"
+  });
+  effects.set("query", {
+    keywords: ["fetch", "load", "get", "list", "search", "find"],
+    effect: "query",
+    category: "default"
+  });
+  const typeOverrides = /* @__PURE__ */ new Map([
+    ["currency", "financial"],
+    ["money", "financial"],
+    ["amount", "financial"],
+    ["wei", "financial"],
+    ["bigint", "financial"],
+    ["token", "financial"],
+    ["balance", "financial"],
+    ["price", "financial"],
+    ["fee", "financial"],
+    ["password", "destructive"],
+    ["secret", "destructive"],
+    ["key", "destructive"],
+    ["permission", "destructive"],
+    ["role", "destructive"],
+    ["access", "destructive"],
+    ["theme", "local"],
+    ["preference", "local"],
+    ["setting", "local"],
+    ["filter", "local"],
+    ["sort", "local"],
+    ["view", "local"]
+  ]);
+  const domainDefaults = /* @__PURE__ */ new Map([
+    ["wallet", "financial"],
+    ["token", "financial"],
+    ["nft", "financial"],
+    ["contract", "financial"],
+    ["chain", "financial"],
+    ["gas", "financial"],
+    ["cart", "standard"],
+    ["checkout", "financial"],
+    ["payment", "financial"]
+  ]);
+  return { effects, typeOverrides, domainDefaults };
+}
+async function loadVocabulary(path) {
+  const vocabPath = path ?? DEFAULT_VOCABULARY_PATH;
+  if (cachedVocabulary && cachedPath2 === vocabPath) {
+    return cachedVocabulary;
+  }
+  if (!existsSync(vocabPath)) {
+    console.warn(`Vocabulary file not found at ${vocabPath}, using defaults`);
+    cachedVocabulary = getDefaultVocabulary();
+    cachedPath2 = vocabPath;
+    return cachedVocabulary;
+  }
+  try {
+    const content = await readFile(vocabPath, "utf-8");
+    const effects = parseEffectKeywords(content);
+    const typeOverrides = parseTypeOverrides(content);
+    const domainDefaults = parseDomainDefaults(content);
+    if (effects.size === 0) {
+      console.warn("No vocabulary parsed, using defaults");
+      cachedVocabulary = getDefaultVocabulary();
+    } else {
+      cachedVocabulary = { effects, typeOverrides, domainDefaults };
+    }
+    cachedPath2 = vocabPath;
+    return cachedVocabulary;
+  } catch (error) {
+    console.warn(`Error loading vocabulary from ${vocabPath}:`, error);
+    cachedVocabulary = getDefaultVocabulary();
+    cachedPath2 = vocabPath;
+    return cachedVocabulary;
+  }
+}
+async function resolveEffectFromKeywords(keywords, vocabulary) {
+  const vocab = vocabulary ?? await loadVocabulary();
+  const normalizedKeywords = keywords.map((k) => k.toLowerCase().trim());
+  const priorityOrder = [
+    "financial",
+    "destructive",
+    "soft_delete",
+    "standard",
+    "local",
+    "navigation",
+    "query",
+    "high_freq"
+  ];
+  for (const effect of priorityOrder) {
+    const entry = vocab.effects.get(effect);
+    if (entry) {
+      for (const keyword of normalizedKeywords) {
+        if (entry.keywords.includes(keyword)) {
+          return effect;
+        }
+      }
+    }
+  }
+  for (const keyword of normalizedKeywords) {
+    const override = vocab.typeOverrides.get(keyword);
+    if (override) {
+      return override;
+    }
+  }
+  for (const keyword of normalizedKeywords) {
+    const domainDefault = vocab.domainDefaults.get(keyword);
+    if (domainDefault) {
+      return domainDefault;
+    }
+  }
+  return null;
+}
+function clearVocabularyCache() {
+  cachedVocabulary = null;
+  cachedPath2 = null;
+}
+function isVocabularyCached() {
+  return cachedVocabulary !== null;
+}
+
+// src/warden/grounding-gate.ts
+var ZONE_TO_EFFECT = {
+  critical: "financial",
+  elevated: "destructive",
+  standard: "standard",
+  local: "local"
+};
+var EFFECT_TO_ZONE = {
+  financial: "critical",
+  destructive: "elevated",
+  soft_delete: "standard",
+  standard: "standard",
+  navigation: "local",
+  query: "local",
+  local: "local",
+  high_freq: "local"
+};
+function parseZone(value) {
+  const normalized = value.toLowerCase().trim();
+  if (normalized === "critical")
+    return "critical";
+  if (normalized === "elevated")
+    return "elevated";
+  if (normalized === "standard")
+    return "standard";
+  if (normalized === "local")
+    return "local";
+  return null;
+}
+function parseSyncStrategy2(value) {
+  const normalized = value.toLowerCase().trim();
+  if (normalized.includes("pessimistic"))
+    return "pessimistic";
+  if (normalized.includes("optimistic"))
+    return "optimistic";
+  if (normalized.includes("immediate"))
+    return "immediate";
+  return void 0;
+}
+function parseTiming2(value) {
+  const match = value.match(/(\d+)\s*ms/i);
+  if (match && match[1]) {
+    return parseInt(match[1], 10);
+  }
+  return void 0;
+}
+function parseConfirmation2(value) {
+  const normalized = value.toLowerCase().trim();
+  if (normalized.includes("required") || normalized === "yes")
+    return "required";
+  if (normalized.includes("toast") || normalized.includes("undo"))
+    return "toast_undo";
+  if (normalized.includes("none") || normalized === "no")
+    return "none";
+  return void 0;
+}
+function extractKeywords(text) {
+  const cleanedText = text.replace(/Zone:\s*\w+/gi, "").replace(/Effect:\s*[\w\s]+/gi, "").replace(/Sync:\s*\w+/gi, "").replace(/Confirmation:\s*[\w\s+]+/gi, "");
+  const keywordPatterns = [
+    // Financial
+    "claim",
+    "deposit",
+    "withdraw",
+    "transfer",
+    "swap",
+    "send",
+    "pay",
+    "purchase",
+    "mint",
+    "burn",
+    "stake",
+    "unstake",
+    "bridge",
+    "approve",
+    "redeem",
+    "harvest",
+    // Destructive
+    "delete",
+    "remove",
+    "destroy",
+    "revoke",
+    "terminate",
+    "purge",
+    "erase",
+    "wipe",
+    // Soft delete
+    "archive",
+    "hide",
+    "trash",
+    "dismiss",
+    "snooze",
+    "mute",
+    // Standard
+    "save",
+    "update",
+    "edit",
+    "create",
+    "add",
+    "like",
+    "follow",
+    "bookmark",
+    // Local
+    "toggle",
+    "switch",
+    "expand",
+    "collapse",
+    "select",
+    "focus",
+    // Navigation
+    "navigate",
+    "go",
+    "back",
+    "forward",
+    "link",
+    "route",
+    // Query
+    "fetch",
+    "load",
+    "get",
+    "list",
+    "search",
+    "find",
+    // Domain/type hints
+    "wallet",
+    "token",
+    "nft",
+    "contract",
+    "chain",
+    "gas",
+    "currency",
+    "money",
+    "amount",
+    "balance",
+    "price",
+    "fee",
+    // Effect type names (for inline detection in prose)
+    "financial",
+    "destructive"
+  ];
+  const words = cleanedText.toLowerCase().split(/[\s,.:;!?()\[\]{}]+/);
+  const foundKeywords = [];
+  for (const word of words) {
+    if (keywordPatterns.includes(word)) {
+      foundKeywords.push(word);
+    }
+  }
+  return [...new Set(foundKeywords)];
+}
+function parseGroundingStatement(text) {
+  const statement = {
+    component: "",
+    citedZone: null,
+    detectedKeywords: [],
+    inferredEffect: null,
+    claimedPhysics: {},
+    raw: text
+  };
+  const componentMatch = text.match(/(?:Component|Button|Modal|Form|Dialog):\s*["']?([^\s"'│|]+)/i);
+  if (componentMatch && componentMatch[1]) {
+    statement.component = componentMatch[1].trim();
+  } else {
+    const buttonMatch = text.match(/["']?(\w+(?:Button|Modal|Form|Dialog|Card|Input))["']?/);
+    if (buttonMatch && buttonMatch[1]) {
+      statement.component = buttonMatch[1];
+    }
+  }
+  const zoneMatch = text.match(/Zone:\s*(\w+)/i);
+  if (zoneMatch && zoneMatch[1]) {
+    statement.citedZone = parseZone(zoneMatch[1]);
+  }
+  const effectMatch = text.match(/Effect:\s*(\w+(?:\s+\w+)?)/i);
+  if (effectMatch && effectMatch[1]) {
+    const effectStr = effectMatch[1].toLowerCase();
+    if (effectStr.includes("financial"))
+      statement.inferredEffect = "financial";
+    else if (effectStr.includes("destructive"))
+      statement.inferredEffect = "destructive";
+    else if (effectStr.includes("soft"))
+      statement.inferredEffect = "soft_delete";
+    else if (effectStr.includes("standard"))
+      statement.inferredEffect = "standard";
+    else if (effectStr.includes("local"))
+      statement.inferredEffect = "local";
+    else if (effectStr.includes("navigation"))
+      statement.inferredEffect = "navigation";
+    else if (effectStr.includes("query"))
+      statement.inferredEffect = "query";
+  }
+  const syncMatch = text.match(/Sync:\s*(\w+)/i);
+  if (syncMatch && syncMatch[1]) {
+    const parsed = parseSyncStrategy2(syncMatch[1]);
+    if (parsed)
+      statement.claimedPhysics.sync = parsed;
+  } else {
+    if (text.toLowerCase().includes("pessimistic")) {
+      statement.claimedPhysics.sync = "pessimistic";
+    } else if (text.toLowerCase().includes("optimistic")) {
+      statement.claimedPhysics.sync = "optimistic";
+    } else if (text.toLowerCase().includes("immediate")) {
+      statement.claimedPhysics.sync = "immediate";
+    }
+  }
+  const timingMatch = text.match(/Timing:\s*(\d+\s*ms)/i);
+  if (timingMatch && timingMatch[1]) {
+    const parsed = parseTiming2(timingMatch[1]);
+    if (parsed !== void 0)
+      statement.claimedPhysics.timing = parsed;
+  } else {
+    const inlineTiming = text.match(/(\d+)\s*ms/);
+    if (inlineTiming && inlineTiming[1]) {
+      statement.claimedPhysics.timing = parseInt(inlineTiming[1], 10);
+    }
+  }
+  const confirmMatch = text.match(/Confirm(?:ation)?:\s*(\w+(?:\s*\+\s*\w+)?)/i);
+  if (confirmMatch && confirmMatch[1]) {
+    const parsed = parseConfirmation2(confirmMatch[1]);
+    if (parsed)
+      statement.claimedPhysics.confirmation = parsed;
+  } else {
+    if (text.toLowerCase().includes("confirmation required")) {
+      statement.claimedPhysics.confirmation = "required";
+    } else if (text.toLowerCase().includes("toast") && text.toLowerCase().includes("undo")) {
+      statement.claimedPhysics.confirmation = "toast_undo";
+    }
+  }
+  statement.detectedKeywords = extractKeywords(text);
+  return statement;
+}
+function determineRequiredZone(keywords, effect, vocabulary) {
+  if (effect) {
+    return EFFECT_TO_ZONE[effect];
+  }
+  for (const keyword of keywords) {
+    const override = vocabulary.typeOverrides.get(keyword.toLowerCase());
+    if (override) {
+      return EFFECT_TO_ZONE[override];
+    }
+  }
+  const financialKeywords = vocabulary.effects.get("financial")?.keywords ?? [];
+  for (const keyword of keywords) {
+    if (financialKeywords.includes(keyword.toLowerCase())) {
+      return "critical";
+    }
+  }
+  const destructiveKeywords = vocabulary.effects.get("destructive")?.keywords ?? [];
+  for (const keyword of keywords) {
+    if (destructiveKeywords.includes(keyword.toLowerCase())) {
+      return "elevated";
+    }
+  }
+  return "standard";
+}
+function checkRelevance(statement, vocabulary) {
+  const { detectedKeywords, component } = statement;
+  if (detectedKeywords.length === 0) {
+    const componentLower = component.toLowerCase();
+    const allKeywords = [];
+    for (const entry of vocabulary.effects.values()) {
+      allKeywords.push(...entry.keywords);
+    }
+    const hasRelevantComponent = allKeywords.some((k) => componentLower.includes(k));
+    if (!hasRelevantComponent) {
+      return {
+        passed: false,
+        reason: "No relevant keywords detected in statement or component name"
+      };
+    }
+  }
+  return {
+    passed: true,
+    reason: `Keywords detected: ${detectedKeywords.join(", ") || "from component name"}`
+  };
+}
+function checkHierarchy(statement, requiredZone) {
+  const { citedZone } = statement;
+  if (!citedZone) {
+    return {
+      passed: false,
+      reason: "No zone cited in statement"
+    };
+  }
+  const requiredIndex = ZONE_HIERARCHY.indexOf(requiredZone);
+  const citedIndex = ZONE_HIERARCHY.indexOf(citedZone);
+  if (citedIndex > requiredIndex) {
+    return {
+      passed: false,
+      reason: `Zone "${citedZone}" is less restrictive than required "${requiredZone}"`
+    };
+  }
+  if (citedIndex < requiredIndex) {
+    return {
+      passed: true,
+      reason: `Zone "${citedZone}" is more restrictive than required "${requiredZone}" (OK)`
+    };
+  }
+  return {
+    passed: true,
+    reason: `Zone "${citedZone}" matches required zone`
+  };
+}
+async function checkRules(statement, requiredZone, physics) {
+  const { claimedPhysics } = statement;
+  const requiredEffect = ZONE_TO_EFFECT[requiredZone];
+  const rule = physics.get(requiredEffect);
+  if (!rule) {
+    return {
+      passed: false,
+      reason: `No physics rule found for effect "${requiredEffect}"`
+    };
+  }
+  const violations = [];
+  if (claimedPhysics.sync && claimedPhysics.sync !== rule.sync) {
+    if (claimedPhysics.sync !== "pessimistic") {
+      violations.push(`Sync: claimed "${claimedPhysics.sync}", required "${rule.sync}"`);
+    }
+  }
+  if (claimedPhysics.timing !== void 0) {
+    const timingDiff = Math.abs(claimedPhysics.timing - rule.timing);
+    if (timingDiff > 100 && claimedPhysics.timing < rule.timing) {
+      violations.push(
+        `Timing: claimed ${claimedPhysics.timing}ms, required minimum ${rule.timing}ms`
+      );
+    }
+  }
+  if (claimedPhysics.confirmation) {
+    if (rule.confirmation === "required" && claimedPhysics.confirmation !== "required") {
+      violations.push(
+        `Confirmation: claimed "${claimedPhysics.confirmation}", required "${rule.confirmation}"`
+      );
+    }
+  }
+  if (violations.length > 0) {
+    return {
+      passed: false,
+      reason: violations.join("; ")
+    };
+  }
+  return {
+    passed: true,
+    reason: "Physics rules validated"
+  };
+}
+async function validateGrounding(input, options) {
+  const physics = await loadPhysics(options?.physicsPath);
+  const vocabulary = await loadVocabulary(options?.vocabularyPath);
+  const statement = typeof input === "string" ? parseGroundingStatement(input) : input;
+  if (!statement.inferredEffect && statement.detectedKeywords.length > 0) {
+    statement.inferredEffect = await resolveEffectFromKeywords(
+      statement.detectedKeywords,
+      vocabulary
+    );
+  }
+  const requiredZone = determineRequiredZone(
+    statement.detectedKeywords,
+    statement.inferredEffect,
+    vocabulary
+  );
+  const relevanceCheck = checkRelevance(statement, vocabulary);
+  const hierarchyCheck = checkHierarchy(statement, requiredZone);
+  const rulesCheck = await checkRules(statement, requiredZone, physics);
+  let status = "VALID";
+  let correction;
+  if (!relevanceCheck.passed) {
+    status = "DRIFT";
+    correction = "Statement lacks relevant keywords for effect detection.";
+  } else if (!hierarchyCheck.passed) {
+    status = "DECEPTIVE";
+    correction = `Zone mismatch: cited "${statement.citedZone}", required "${requiredZone}".`;
+  } else if (!rulesCheck.passed) {
+    status = "DRIFT";
+    correction = `Physics violation: ${rulesCheck.reason}`;
+  }
+  return {
+    status,
+    checks: {
+      relevance: relevanceCheck,
+      hierarchy: hierarchyCheck,
+      rules: rulesCheck
+    },
+    requiredZone,
+    citedZone: statement.citedZone,
+    ...correction !== void 0 && { correction }
+  };
+}
+async function isGroundingValid(input, options) {
+  const result = await validateGrounding(input, options);
+  return result.status === "VALID";
+}
+function getExitCode(result) {
+  switch (result.status) {
+    case "VALID":
+      return 0;
+    case "DRIFT":
+      return 1;
+    case "DECEPTIVE":
+      return 2;
+    default:
+      return 3;
+  }
+}
+
+// src/index.ts
+var VERSION = "4.3.1";
+
+export { CheckpointManager, ExitCode, ForkManager, ForkRegistrySchema, ForkSchema, RpcError, RpcTimeoutError, SessionManager, SnapshotManager, TaskGraph, VERSION, ZONE_HIERARCHY, 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 };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map